-
Notifications
You must be signed in to change notification settings - Fork 838
/
Copy pathir_Fujitsu.h
266 lines (251 loc) · 10.1 KB
/
ir_Fujitsu.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
// Copyright 2017 Jonny Graham
// Copyright 2018-2022 David Conran
// Copyright 2021 siriuslzx
/// @file
/// @brief Support for Fujitsu A/C protocols.
/// Fujitsu A/C support added by Jonny Graham
/// @warning Use of incorrect model may cause the A/C unit to lock up.
/// e.g. An A/C that uses an AR-RAH1U remote may lock up requiring a physical
/// power rest, if incorrect model (ARRAH2E) is used with a Swing command.
/// The correct model for it is ARREB1E.
/// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1376
// Supports:
// Brand: Fujitsu, Model: AR-RAH2E remote (ARRAH2E)
// Brand: Fujitsu, Model: ASYG30LFCA A/C (ARRAH2E)
// Brand: Fujitsu General, Model: AR-RCE1E remote (ARRAH2E)
// Brand: Fujitsu General, Model: ASHG09LLCA A/C (ARRAH2E)
// Brand: Fujitsu General, Model: AOHG09LLC A/C (ARRAH2E)
// Brand: Fujitsu, Model: AR-DB1 remote (ARDB1)
// Brand: Fujitsu, Model: AST9RSGCW A/C (ARDB1)
// Brand: Fujitsu, Model: AR-REB1E remote (ARREB1E)
// Brand: Fujitsu, Model: ASYG7LMCA A/C (ARREB1E)
// Brand: Fujitsu, Model: AR-RAE1E remote (ARRAH2E)
// Brand: Fujitsu, Model: AGTV14LAC A/C (ARRAH2E)
// Brand: Fujitsu, Model: AR-RAC1E remote (ARRAH2E)
// Brand: Fujitsu, Model: ASTB09LBC A/C (ARRY4)
// Brand: Fujitsu, Model: AR-RY4 remote (ARRY4)
// Brand: Fujitsu General, Model: AR-JW2 remote (ARJW2)
// Brand: Fujitsu, Model: AR-DL10 remote (ARDB1)
// Brand: Fujitsu, Model: ASU30C1 A/C (ARDB1)
// Brand: Fujitsu, Model: AR-RAH1U remote (ARREB1E)
// Brand: Fujitsu, Model: AR-RAH2U remote (ARRAH2E)
// Brand: Fujitsu, Model: ASU12RLF A/C (ARREB1E)
// Brand: Fujitsu, Model: AR-REW4E remote (ARREW4E)
// Brand: Fujitsu, Model: ASYG09KETA-B A/C (ARREW4E)
// Brand: Fujitsu, Model: AR-REB4E remote (ARREB1E)
// Brand: Fujitsu, Model: ASTG09K A/C (ARREW4E)
// Brand: Fujitsu, Model: ASTG18K A/C (ARREW4E)
// Brand: Fujitsu, Model: AR-REW1E remote (ARREW4E)
// Brand: Fujitsu, Model: AR-REG1U remote (ARRAH2E)
// Brand: OGeneral, Model: AR-RCL1E remote (ARRAH2E)
// Brand: Fujitsu General, Model: AR-JW17 remote (ARDB1)
#ifndef IR_FUJITSU_H_
#define IR_FUJITSU_H_
#define __STDC_LIMIT_MACROS
#include <stdint.h>
#ifdef ARDUINO
#include <Arduino.h>
#endif
#include "IRrecv.h"
#include "IRremoteESP8266.h"
#include "IRsend.h"
#ifdef UNIT_TEST
#include "IRsend_test.h"
#endif
/// Native representation of a Fujitsu A/C message.
union FujitsuProtocol {
struct {
uint8_t longcode[kFujitsuAcStateLength]; ///< The state of the IR remote.
uint8_t shortcode[kFujitsuAcStateLengthShort];
};
struct {
// Byte 0~1
uint64_t :16; // Fixed header
// Byte 2
uint64_t :4;
uint64_t Id :2; // Device Number/Identifier
uint64_t :2;
// Byte 3-4
uint64_t :16;
// Byte 5
uint64_t Cmd :8; // short codes:cmd; long codes:fixed value
// Byte 6
uint64_t RestLength :8; // Nr. of bytes in the message after this byte.
// Byte 7
uint64_t Protocol :8; // Seems like a protocol version number. Not sure.
// Byte 8
uint64_t Power :1;
uint64_t Fahrenheit :1;
uint64_t Temp :6; // Internal representation varies between models.
// Byte 9
uint64_t Mode :3;
uint64_t Clean :1; // Also 10C Heat in ARREW4E.
uint64_t TimerType :2;
uint64_t :2;
// Byte 10
uint64_t Fan :3;
uint64_t :1;
uint64_t Swing :2;
uint64_t :2;
// Byte 11~13
uint64_t OffTimer :11; // Also is the sleep timer value
uint64_t OffTimerEnable :1;
uint64_t OnTimer :11;
uint64_t OnTimerEnable :1;
// Byte 14
uint64_t :3;
uint64_t Filter :1;
uint64_t :1;
uint64_t unknown :1;
uint64_t :1;
uint64_t OutsideQuiet :1;
// Byte 15
uint64_t :0; // Checksum
};
};
// Constants
const uint8_t kFujitsuAcModeAuto = 0x0; // 0b000
const uint8_t kFujitsuAcModeCool = 0x1; // 0b001
const uint8_t kFujitsuAcModeDry = 0x2; // 0b010
const uint8_t kFujitsuAcModeFan = 0x3; // 0b011
const uint8_t kFujitsuAcModeHeat = 0x4; // 0b100
const uint8_t kFujitsuAcCmdStayOn = 0x00; // b00000000
const uint8_t kFujitsuAcCmdTurnOn = 0x01; // b00000001
const uint8_t kFujitsuAcCmdTurnOff = 0x02; // b00000010
const uint8_t kFujitsuAcCmdEcono = 0x09; // b00001001
const uint8_t kFujitsuAcCmdPowerful = 0x39; // b00111001
const uint8_t kFujitsuAcCmdStepVert = 0x6C; // b01101100
const uint8_t kFujitsuAcCmdToggleSwingVert = 0x6D; // b01101101
const uint8_t kFujitsuAcCmdStepHoriz = 0x79; // b01111001
const uint8_t kFujitsuAcCmdToggleSwingHoriz = 0x7A; // b01111010
const uint8_t kFujitsuAcFanAuto = 0x00;
const uint8_t kFujitsuAcFanHigh = 0x01;
const uint8_t kFujitsuAcFanMed = 0x02;
const uint8_t kFujitsuAcFanLow = 0x03;
const uint8_t kFujitsuAcFanQuiet = 0x04;
const float kFujitsuAcMinHeat = 10; // 10C
const float kFujitsuAcMinTemp = 16; // 16C
const float kFujitsuAcMaxTemp = 30; // 30C
const uint8_t kFujitsuAcTempOffsetC = kFujitsuAcMinTemp;
const float kFujitsuAcMinHeatF = 50; // 50F
const float kFujitsuAcMinTempF = 60; // 60F
const float kFujitsuAcMaxTempF = 88; // 88F
const uint8_t kFujitsuAcTempOffsetF = 44;
const uint8_t kFujitsuAcSwingOff = 0x00;
const uint8_t kFujitsuAcSwingVert = 0x01;
const uint8_t kFujitsuAcSwingHoriz = 0x02;
const uint8_t kFujitsuAcSwingBoth = 0x03;
const uint8_t kFujitsuAcStopTimers = 0b00; // 0
const uint8_t kFujitsuAcSleepTimer = 0b01; // 1
const uint8_t kFujitsuAcOffTimer = 0b10; // 2
const uint8_t kFujitsuAcOnTimer = 0b11; // 3
const uint16_t kFujitsuAcTimerMax = 12 * 60; ///< Minutes.
// Legacy defines.
#define FUJITSU_AC_MODE_AUTO kFujitsuAcModeAuto
#define FUJITSU_AC_MODE_COOL kFujitsuAcModeCool
#define FUJITSU_AC_MODE_DRY kFujitsuAcModeDry
#define FUJITSU_AC_MODE_FAN kFujitsuAcModeFan
#define FUJITSU_AC_MODE_HEAT kFujitsuAcModeHeat
#define FUJITSU_AC_CMD_STAY_ON kFujitsuAcCmdStayOn
#define FUJITSU_AC_CMD_TURN_ON kFujitsuAcCmdTurnOn
#define FUJITSU_AC_CMD_TURN_OFF kFujitsuAcCmdTurnOff
#define FUJITSU_AC_CMD_STEP_HORIZ kFujitsuAcCmdStepHoriz
#define FUJITSU_AC_CMD_STEP_VERT kFujitsuAcCmdStepVert
#define FUJITSU_AC_FAN_AUTO kFujitsuAcFanAuto
#define FUJITSU_AC_FAN_HIGH kFujitsuAcFanHigh
#define FUJITSU_AC_FAN_MED kFujitsuAcFanMed
#define FUJITSU_AC_FAN_LOW kFujitsuAcFanLow
#define FUJITSU_AC_FAN_QUIET kFujitsuAcFanQuiet
#define FUJITSU_AC_MIN_TEMP kFujitsuAcMinTemp
#define FUJITSU_AC_MAX_TEMP kFujitsuAcMaxTemp
#define FUJITSU_AC_SWING_OFF kFujitsuAcSwingOff
#define FUJITSU_AC_SWING_VERT kFujitsuAcSwingVert
#define FUJITSU_AC_SWING_HORIZ kFujitsuAcSwingHoriz
#define FUJITSU_AC_SWING_BOTH kFujitsuAcSwingBoth
/// Class for handling detailed Fujitsu A/C messages.
class IRFujitsuAC {
public:
explicit IRFujitsuAC(const uint16_t pin,
const fujitsu_ac_remote_model_t model = ARRAH2E,
const bool inverted = false,
const bool use_modulation = true);
void setModel(const fujitsu_ac_remote_model_t model);
fujitsu_ac_remote_model_t getModel(void) const;
void stateReset(void);
#if SEND_FUJITSU_AC
void send(const uint16_t repeat = kFujitsuAcMinRepeat);
/// Run the calibration to calculate uSec timing offsets for this platform.
/// @return The uSec timing offset needed per modulation of the IR Led.
/// @note This will produce a 65ms IR signal pulse at 38kHz.
/// Only ever needs to be run once per object instantiation, if at all.
int8_t calibrate(void) { return _irsend.calibrate(); }
#endif // SEND_FUJITSU_AC
void begin(void);
void stepHoriz(void);
void toggleSwingHoriz(const bool update = true);
void stepVert(void);
void toggleSwingVert(const bool update = true);
void setCmd(const uint8_t cmd);
uint8_t getCmd(void) const;
void setTemp(const float temp, const bool useCelsius = true);
float getTemp(void) const;
void setFanSpeed(const uint8_t fan);
uint8_t getFanSpeed(void) const;
void setMode(const uint8_t mode);
uint8_t getMode(void) const;
void setSwing(const uint8_t mode);
uint8_t getSwing(void) const;
uint8_t* getRaw(void);
bool setRaw(const uint8_t newState[], const uint16_t length);
uint8_t getStateLength(void);
static bool validChecksum(uint8_t* state, const uint16_t length);
bool isLongCode(void) const;
void setPower(const bool on);
void off(void);
void on(void);
bool getPower(void) const;
void setClean(const bool on);
bool getClean(void) const;
void setFilter(const bool on);
bool getFilter(void) const;
void set10CHeat(const bool on);
bool get10CHeat(void) const;
void setOutsideQuiet(const bool on);
bool getOutsideQuiet(void) const;
uint8_t getTimerType(void) const;
void setTimerType(const uint8_t timertype);
uint16_t getOnTimer(void) const;
void setOnTimer(const uint16_t nr_mins);
uint16_t getOffSleepTimer(void) const;
void setOffTimer(const uint16_t nr_mins);
void setSleepTimer(const uint16_t nr_mins);
void setId(const uint8_t num);
uint8_t getId(void) const;
void setCelsius(const bool on);
bool getCelsius(void) const;
static uint8_t convertMode(const stdAc::opmode_t mode);
static uint8_t convertFan(stdAc::fanspeed_t speed);
static stdAc::opmode_t toCommonMode(const uint8_t mode);
static stdAc::fanspeed_t toCommonFanSpeed(const uint8_t speed);
stdAc::state_t toCommon(const stdAc::state_t *prev = NULL);
String toString(void) const;
#ifndef UNIT_TEST
private:
IRsend _irsend; ///< Instance of the IR send class
#else
/// @cond IGNORE
IRsendTest _irsend; ///< Instance of the testing IR send class
/// @endcond
#endif
FujitsuProtocol _;
uint8_t _cmd;
fujitsu_ac_remote_model_t _model;
uint8_t _state_length;
uint8_t _state_length_short;
bool _rawstatemodified;
void checkSum(void);
bool updateUseLongOrShort(void);
void buildFromState(const uint16_t length);
void setOffSleepTimer(const uint16_t nr_mins);
};
#endif // IR_FUJITSU_H_