ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
fujitsu_general.cpp
Go to the documentation of this file.
1#include "fujitsu_general.h"
2
4
5ESPHOME_LOG_TAG(TAG, "fujitsu_general.climate");
6
7// Common header
8constexpr uint8_t FUJITSU_GENERAL_COMMON_LENGTH = 6;
9constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE0 = 0x14;
10constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE1 = 0x63;
11constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE2 = 0x00;
12constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE3 = 0x10;
13constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE4 = 0x10;
15
16// State message - temp & fan etc.
18constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_STATE = 0xFE;
19
20// Util messages - off & eco etc.
22// Turns the unit off; a util message, but transmit_state() owns it because it changes the climate state
23constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_OFF = 0x02;
24
25// State header
26constexpr uint8_t FUJITSU_GENERAL_STATE_HEADER_BYTE0 = 0x09;
27constexpr uint8_t FUJITSU_GENERAL_STATE_HEADER_BYTE1 = 0x30;
28
29// State footer
30constexpr uint8_t FUJITSU_GENERAL_STATE_FOOTER_BYTE0 = 0x20;
31
32// Power on
33constexpr uint8_t FUJITSU_GENERAL_POWER_OFF = 0x00;
34constexpr uint8_t FUJITSU_GENERAL_POWER_ON = 0x01;
35
36// Mode
37// Bit 3 is the clean flag, which is also 10 degree heat on the ARRAH2E and ARREW4E remotes.
38constexpr uint8_t FUJITSU_GENERAL_MODE_MASK = 0b0111;
39constexpr uint8_t FUJITSU_GENERAL_CLEAN_BIT = 0b1000;
40constexpr uint8_t FUJITSU_GENERAL_MODE_AUTO = 0x00;
41constexpr uint8_t FUJITSU_GENERAL_MODE_COOL = 0x01;
42constexpr uint8_t FUJITSU_GENERAL_MODE_DRY = 0x02;
43constexpr uint8_t FUJITSU_GENERAL_MODE_FAN = 0x03;
44constexpr uint8_t FUJITSU_GENERAL_MODE_HEAT = 0x04;
45
46// Swing
47constexpr uint8_t FUJITSU_GENERAL_SWING_MASK = 0b0011;
48constexpr uint8_t FUJITSU_GENERAL_SWING_NONE = 0x00;
49constexpr uint8_t FUJITSU_GENERAL_SWING_VERTICAL = 0x01;
50constexpr uint8_t FUJITSU_GENERAL_SWING_HORIZONTAL = 0x02;
51constexpr uint8_t FUJITSU_GENERAL_SWING_BOTH = 0x03;
52
53// Fan
54constexpr uint8_t FUJITSU_GENERAL_FAN_MASK = 0b0111;
55constexpr uint8_t FUJITSU_GENERAL_FAN_AUTO = 0x00;
56constexpr uint8_t FUJITSU_GENERAL_FAN_HIGH = 0x01;
57constexpr uint8_t FUJITSU_GENERAL_FAN_MEDIUM = 0x02;
58constexpr uint8_t FUJITSU_GENERAL_FAN_LOW = 0x03;
59constexpr uint8_t FUJITSU_GENERAL_FAN_SILENT = 0x04;
60
61// TODO Outdoor Unit Low Noise
62// const uint8_t FUJITSU_GENERAL_OUTDOOR_UNIT_LOW_NOISE_BYTE14 = 0xA0;
63// const uint8_t FUJITSU_GENERAL_STATE_BYTE14 = 0x20;
64
65constexpr uint16_t FUJITSU_GENERAL_HEADER_MARK = 3300;
66constexpr uint16_t FUJITSU_GENERAL_HEADER_SPACE = 1600;
67
68static constexpr remote_base::BitTimings FUJITSU_GENERAL_BIT_TIMINGS{
69 .bit_mark = 420, .one_space = 1200, .zero_space = 420};
70
71constexpr uint16_t FUJITSU_GENERAL_TRL_MARK = 420;
72constexpr uint16_t FUJITSU_GENERAL_TRL_SPACE = 8000;
73
75
77 if (this->mode == climate::CLIMATE_MODE_OFF) {
78 ESP_LOGV(TAG, "Transmit off");
79 this->transmit_util(FUJITSU_GENERAL_MESSAGE_TYPE_OFF);
80 this->power_ = false;
81 return;
82 }
83
84 ESP_LOGV(TAG, "Transmit state");
85
86 uint8_t remote_state[FUJITSU_GENERAL_STATE_MESSAGE_LENGTH] = {0};
87
88 // Common message header
89 remote_state[0] = FUJITSU_GENERAL_COMMON_BYTE0;
90 remote_state[1] = FUJITSU_GENERAL_COMMON_BYTE1;
91 remote_state[2] = FUJITSU_GENERAL_COMMON_BYTE2;
92 remote_state[3] = FUJITSU_GENERAL_COMMON_BYTE3;
93 remote_state[4] = FUJITSU_GENERAL_COMMON_BYTE4;
94 remote_state[5] = FUJITSU_GENERAL_MESSAGE_TYPE_STATE;
95 remote_state[6] = FUJITSU_GENERAL_STATE_HEADER_BYTE0;
96 remote_state[7] = FUJITSU_GENERAL_STATE_HEADER_BYTE1;
97
98 // unknown, does not appear to change with any remote settings
99 remote_state[14] = FUJITSU_GENERAL_STATE_FOOTER_BYTE0;
100
101 // Set temperature
102 uint8_t temperature_clamped =
103 (uint8_t) roundf(clamp<float>(this->target_temperature, FUJITSU_GENERAL_TEMP_MIN, FUJITSU_GENERAL_TEMP_MAX));
104 uint8_t temperature_offset = temperature_clamped - FUJITSU_GENERAL_TEMP_MIN;
105 set_nibble(remote_state, FUJITSU_GENERAL_TEMPERATURE_NIBBLE, temperature_offset);
106
107 // Set power on
108 if (!this->power_) {
110 }
111
112 // Set mode
113 switch (this->mode) {
116 break;
119 break;
122 break;
125 break;
127 default:
129 break;
130 }
131
132 // Set fan
133 switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
136 break;
139 break;
142 break;
145 break;
147 default:
149 break;
150 }
151
152 // Set swing
153 switch (this->swing_mode) {
156 break;
159 break;
162 break;
164 default:
166 break;
167 }
168
169 // TODO: missing support for outdoor unit low noise
170 // remote_state[14] = (byte) remote_state[14] | FUJITSU_GENERAL_OUTDOOR_UNIT_LOW_NOISE_BYTE14;
171
172 remote_state[FUJITSU_GENERAL_STATE_MESSAGE_LENGTH - 1] = this->checksum_state_(remote_state);
173
175
176 this->power_ = true;
177}
178
180 uint8_t remote_state[FUJITSU_GENERAL_UTIL_MESSAGE_LENGTH] = {0};
181
182 remote_state[0] = FUJITSU_GENERAL_COMMON_BYTE0;
183 remote_state[1] = FUJITSU_GENERAL_COMMON_BYTE1;
184 remote_state[2] = FUJITSU_GENERAL_COMMON_BYTE2;
185 remote_state[3] = FUJITSU_GENERAL_COMMON_BYTE3;
186 remote_state[4] = FUJITSU_GENERAL_COMMON_BYTE4;
187 remote_state[5] = command;
188 remote_state[6] = this->checksum_util_(remote_state);
189
191}
192
193void FujitsuGeneralClimate::transmit_(uint8_t const *message, uint8_t length) {
194 ESP_LOGV(TAG, "Transmit message length %d", length);
195
196 auto transmit = this->transmitter_->transmit();
197 auto *data = transmit.get_data();
198
199 data->set_carrier_frequency(FUJITSU_GENERAL_CARRIER_FREQUENCY);
200
201 // Header
202 data->mark(FUJITSU_GENERAL_HEADER_MARK);
203 data->space(FUJITSU_GENERAL_HEADER_SPACE);
204
205 // Data
206 data->item_bytes<FUJITSU_GENERAL_BIT_TIMINGS>(message, length);
207
208 // Footer
209 data->mark(FUJITSU_GENERAL_TRL_MARK);
210 data->space(FUJITSU_GENERAL_TRL_SPACE);
211
212 transmit.perform();
213}
214
218
219uint8_t FujitsuGeneralClimate::checksum_util_(uint8_t const *message) { return 255 - message[5]; }
220
221// These decoders use if chains rather than switches: on ESP8266 the compiler turns a dense switch
222// into a lookup table in .rodata, which lives in RAM there.
223climate::ClimateMode decode_mode(uint8_t mode_field, climate::ClimateMode current_mode) {
224 const uint8_t mode = mode_field & FUJITSU_GENERAL_MODE_MASK;
235 // A state frame means the unit is on, so never keep OFF.
236 ESP_LOGW(TAG, "Received unassigned mode %X, keeping the current mode", mode);
237 return current_mode == climate::CLIMATE_MODE_OFF ? climate::CLIMATE_MODE_HEAT_COOL : current_mode;
238}
239
240optional<climate::ClimateFanMode> decode_fan_mode(uint8_t fan_field, optional<climate::ClimateFanMode> current_mode) {
241 const uint8_t fan = fan_field & FUJITSU_GENERAL_FAN_MASK;
242 if (fan == FUJITSU_GENERAL_FAN_HIGH)
246 if (fan == FUJITSU_GENERAL_FAN_LOW)
250 if (fan == FUJITSU_GENERAL_FAN_AUTO)
252 ESP_LOGW(TAG, "Received unassigned fan speed %X, keeping the current fan mode", fan);
253 return current_mode;
254}
255
266
268 ESP_LOGV(TAG, "Received IR message");
269
270 // Validate header
272 ESP_LOGV(TAG, "Header fail");
273 return false;
274 }
275
276 uint8_t recv_message[FUJITSU_GENERAL_STATE_MESSAGE_LENGTH];
277
278 // Read header
279 if (!data.expect_bytes<FUJITSU_GENERAL_BIT_TIMINGS>(recv_message, FUJITSU_GENERAL_COMMON_LENGTH)) {
280 ESP_LOGV(TAG, "Header bytes fail");
281 return false;
282 }
283
284 const uint8_t recv_message_type = recv_message[FUJITSU_GENERAL_MESSAGE_TYPE_BYTE];
285 uint8_t recv_message_length;
286
287 switch (recv_message_type) {
289 ESP_LOGV(TAG, "Received state message");
290 recv_message_length = FUJITSU_GENERAL_STATE_MESSAGE_LENGTH;
291 break;
296 ESP_LOGV(TAG, "Received util message");
297 recv_message_length = FUJITSU_GENERAL_UTIL_MESSAGE_LENGTH;
298 break;
299 default:
300 ESP_LOGV(TAG, "Unknown message type %X", recv_message_type);
301 return false;
302 }
303
304 // Read message body
305 if (!data.expect_bytes<FUJITSU_GENERAL_BIT_TIMINGS>(recv_message + FUJITSU_GENERAL_COMMON_LENGTH,
306 recv_message_length - FUJITSU_GENERAL_COMMON_LENGTH)) {
307 ESP_LOGV(TAG, "Body bytes fail");
308 return false;
309 }
310
311 for (uint8_t byte = 0; byte < recv_message_length; ++byte) {
312 ESP_LOGVV(TAG, "%02X", recv_message[byte]);
313 }
314
315 const uint8_t recv_checksum = recv_message[recv_message_length - 1];
316 uint8_t calculated_checksum;
317 if (recv_message_type == FUJITSU_GENERAL_MESSAGE_TYPE_STATE) {
318 calculated_checksum = this->checksum_state_(recv_message);
319 } else {
320 calculated_checksum = this->checksum_util_(recv_message);
321 }
322
323 if (recv_checksum != calculated_checksum) {
324 ESP_LOGV(TAG, "Checksum fail - expected %X - got %X", calculated_checksum, recv_checksum);
325 return false;
326 }
327
328 if (recv_message_type == FUJITSU_GENERAL_MESSAGE_TYPE_STATE) {
329 const uint8_t recv_tempertature = get_nibble(recv_message, FUJITSU_GENERAL_TEMPERATURE_NIBBLE);
330 const uint8_t offset_temperature = recv_tempertature + FUJITSU_GENERAL_TEMP_MIN;
331 this->target_temperature = offset_temperature;
332 ESP_LOGV(TAG, "Received temperature %d", offset_temperature);
333
334 const uint8_t recv_mode = get_nibble(recv_message, FUJITSU_GENERAL_MODE_NIBBLE);
335 ESP_LOGV(TAG, "Received mode %X", recv_mode);
336 if ((recv_mode & FUJITSU_GENERAL_CLEAN_BIT) != 0) {
337 ESP_LOGW(TAG, "Received a frame with the clean / 10 degree heat bit set, which is not supported");
338 }
339 this->mode = decode_mode(recv_mode, this->mode);
340
341 const uint8_t recv_fan_mode = get_nibble(recv_message, FUJITSU_GENERAL_FAN_NIBBLE);
342 ESP_LOGV(TAG, "Received fan mode %X", recv_fan_mode);
343 this->fan_mode = decode_fan_mode(recv_fan_mode, this->fan_mode);
344
345 const uint8_t recv_swing_mode = get_nibble(recv_message, FUJITSU_GENERAL_SWING_NIBBLE);
346 ESP_LOGV(TAG, "Received swing mode %X", recv_swing_mode);
347 this->swing_mode = decode_swing_mode(recv_swing_mode);
348
349 this->power_ = true;
350 }
351
352 else if (recv_message_type == FUJITSU_GENERAL_MESSAGE_TYPE_OFF) {
353 ESP_LOGV(TAG, "Received off message");
355 this->power_ = false;
356 }
357
358 else {
359 ESP_LOGV(TAG, "Received unsupprted message type %X", recv_message_type);
360 return false;
361 }
362
363 this->publish_state();
364 return true;
365}
366
367} // namespace esphome::fujitsu_general
BedjetMode mode
BedJet operating mode.
ClimateMode mode
The active mode of the climate device.
Definition climate.h:317
optional< ClimateFanMode > fan_mode
The active fan mode of the climate device.
Definition climate.h:311
float target_temperature
The target temperature of the climate device.
Definition climate.h:298
ClimateSwingMode swing_mode
The active swing mode of the climate device.
Definition climate.h:323
void publish_state()
Publish the state of the climate device, to be called from integrations.
Definition climate.cpp:432
void transmit_util(uint8_t command)
Transmit a util message that does not change the climate state (economy, vane steps)
uint8_t checksum_state_(uint8_t const *message)
Calculate checksum for a state message.
void transmit_state() override
Transmit via IR the state of this climate controller.
uint8_t checksum_util_(uint8_t const *message)
Calculate cecksum for a util message.
bool on_receive(remote_base::RemoteReceiveData data) override
Parse incoming message.
void transmit_(uint8_t const *message, uint8_t length)
Transmit message as IR pulses.
const LogString * message
Definition component.cpp:35
ClimateSwingMode
Enum for all modes a climate swing can be in NOTE: If adding values, update ClimateSwingModeMask in c...
@ CLIMATE_SWING_OFF
The swing mode is set to Off.
@ CLIMATE_SWING_HORIZONTAL
The fan mode is set to Horizontal.
@ CLIMATE_SWING_VERTICAL
The fan mode is set to Vertical.
@ CLIMATE_SWING_BOTH
The fan mode is set to Both.
ClimateMode
Enum for all modes a climate device can be in.
@ CLIMATE_MODE_DRY
The climate device is set to dry/humidity mode.
@ CLIMATE_MODE_FAN_ONLY
The climate device only has the fan enabled, no heating or cooling is taking place.
@ CLIMATE_MODE_HEAT
The climate device is set to heat to reach the target temperature.
@ CLIMATE_MODE_COOL
The climate device is set to cool to reach the target temperature.
@ CLIMATE_MODE_HEAT_COOL
The climate device is set to heat/cool to reach the target temperature.
@ CLIMATE_MODE_OFF
The climate device is off.
@ CLIMATE_FAN_MEDIUM
The fan mode is set to Medium.
@ CLIMATE_FAN_ON
The fan mode is set to On.
@ CLIMATE_FAN_AUTO
The fan mode is set to Auto.
@ CLIMATE_FAN_LOW
The fan mode is set to Low.
@ CLIMATE_FAN_QUIET
The fan mode is set to Quiet.
@ CLIMATE_FAN_HIGH
The fan mode is set to High.
optional< climate::ClimateFanMode > decode_fan_mode(uint8_t fan_field, optional< climate::ClimateFanMode > current_mode)
Unassigned values keep the current fan mode.
constexpr uint16_t FUJITSU_GENERAL_TRL_MARK
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_ECONOMY
constexpr uint8_t FUJITSU_GENERAL_FAN_LOW
constexpr uint8_t FUJITSU_GENERAL_POWER_ON_NIBBLE
constexpr uint8_t FUJITSU_GENERAL_FAN_MASK
constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE1
constexpr uint16_t FUJITSU_GENERAL_HEADER_SPACE
constexpr uint8_t FUJITSU_GENERAL_FAN_SILENT
constexpr uint8_t FUJITSU_GENERAL_FAN_AUTO
constexpr uint8_t get_nibble(const uint8_t *message, uint8_t nibble)
constexpr uint8_t FUJITSU_GENERAL_CLEAN_BIT
constexpr uint8_t FUJITSU_GENERAL_STATE_MESSAGE_LENGTH
constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE4
constexpr uint16_t FUJITSU_GENERAL_HEADER_MARK
constexpr uint8_t FUJITSU_GENERAL_STATE_FOOTER_BYTE0
ESPHOME_LOG_TAG(TAG, "fujitsu_general.climate")
constexpr uint8_t FUJITSU_GENERAL_TEMPERATURE_NIBBLE
constexpr uint8_t FUJITSU_GENERAL_MODE_DRY
constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE0
constexpr uint8_t FUJITSU_GENERAL_STATE_HEADER_BYTE1
climate::ClimateSwingMode decode_swing_mode(uint8_t swing_field)
constexpr uint8_t FUJITSU_GENERAL_TEMP_MIN
constexpr uint8_t FUJITSU_GENERAL_SWING_NIBBLE
constexpr uint8_t FUJITSU_GENERAL_UTIL_MESSAGE_LENGTH
constexpr uint8_t FUJITSU_GENERAL_FAN_HIGH
constexpr uint8_t FUJITSU_GENERAL_MODE_FAN
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_BYTE
constexpr uint8_t FUJITSU_GENERAL_MODE_NIBBLE
constexpr uint8_t FUJITSU_GENERAL_FAN_MEDIUM
constexpr uint8_t FUJITSU_GENERAL_SWING_BOTH
constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE2
climate::ClimateMode decode_mode(uint8_t mode_field, climate::ClimateMode current_mode)
Unassigned values keep the current mode, except that OFF becomes HEAT_COOL.
constexpr uint8_t FUJITSU_GENERAL_MODE_MASK
constexpr uint8_t FUJITSU_GENERAL_POWER_OFF
constexpr uint8_t FUJITSU_GENERAL_SWING_HORIZONTAL
constexpr uint8_t FUJITSU_GENERAL_POWER_ON
constexpr uint16_t FUJITSU_GENERAL_TRL_SPACE
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_NUDGE_VERTICAL
constexpr uint8_t FUJITSU_GENERAL_SWING_MASK
constexpr uint8_t FUJITSU_GENERAL_MODE_HEAT
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_STATE
constexpr uint8_t FUJITSU_GENERAL_STATE_HEADER_BYTE0
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_OFF
constexpr uint32_t FUJITSU_GENERAL_CARRIER_FREQUENCY
constexpr uint8_t FUJITSU_GENERAL_MESSAGE_TYPE_NUDGE_HORIZONTAL
constexpr uint8_t FUJITSU_GENERAL_FAN_NIBBLE
constexpr void set_nibble(uint8_t *message, uint8_t nibble, uint8_t value)
Write a nibble into a zero-initialised frame.
constexpr uint8_t FUJITSU_GENERAL_SWING_VERTICAL
constexpr uint8_t FUJITSU_GENERAL_TEMP_MAX
constexpr uint8_t FUJITSU_GENERAL_MODE_AUTO
constexpr uint8_t FUJITSU_GENERAL_SWING_NONE
constexpr uint8_t FUJITSU_GENERAL_COMMON_BYTE3
constexpr uint8_t FUJITSU_GENERAL_MODE_COOL
constexpr uint8_t FUJITSU_GENERAL_COMMON_LENGTH
constexpr uint8_t sum_bytes(const uint8_t *data, size_t len, uint8_t sum=0)
Add up the bytes of data with size len, truncated to 8 bits: the checksum many serial and IR protocol...
Definition helpers.h:939
static void uint32_t
A bit is a mark (one_mark or zero_mark, both bit_mark unless set) and a space (one_space or zero_spac...
Definition remote_base.h:29
uint16_t length
Definition tt21100.cpp:0