ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
noblex.cpp
Go to the documentation of this file.
1#include "noblex.h"
3#include "esphome/core/log.h"
4
5namespace esphome::noblex {
6
7ESPHOME_LOG_TAG(TAG, "noblex.climate");
8
9const uint16_t NOBLEX_HEADER_MARK = 9000;
10const uint16_t NOBLEX_HEADER_SPACE = 4500;
11const uint16_t NOBLEX_BIT_MARK = 660;
12const uint16_t NOBLEX_ONE_SPACE = 1640;
13const uint16_t NOBLEX_ZERO_SPACE = 520;
14const uint32_t NOBLEX_GAP = 20000;
15const uint8_t NOBLEX_POWER = 0x10;
16
18 IR_NOBLEX_MODE_AUTO = 0b000,
19 IR_NOBLEX_MODE_COOL = 0b100,
20 IR_NOBLEX_MODE_DRY = 0b010,
21 IR_NOBLEX_MODE_FAN = 0b110,
22 IR_NOBLEX_MODE_HEAT = 0b001,
23};
24
26 IR_NOBLEX_FAN_AUTO = 0b00,
27 IR_NOBLEX_FAN_LOW = 0b10,
28 IR_NOBLEX_FAN_MEDIUM = 0b01,
29 IR_NOBLEX_FAN_HIGH = 0b11,
30};
31
32// Transmit via IR the state of this climate controller.
34 uint8_t remote_state[8] = {0x80, 0x10, 0x00, 0x0A, 0x50, 0x00, 0x20, 0x00}; // OFF, COOL, 24C, FAN_AUTO
35
36 auto powered_on = this->mode != climate::CLIMATE_MODE_OFF;
37 if (powered_on) {
38 remote_state[0] |= 0x10; // power bit
39 remote_state[2] = 0x02;
40 }
41 if (powered_on != this->powered_on_assumed)
42 this->powered_on_assumed = powered_on;
43
44 auto temp = (uint8_t) roundf(clamp<float>(this->target_temperature, NOBLEX_TEMP_MIN, NOBLEX_TEMP_MAX));
45 remote_state[1] = reverse_bits(uint8_t((temp - NOBLEX_TEMP_MIN) & 0x0F));
46
47 switch (this->mode) {
49 remote_state[0] |= (IRNoblexMode::IR_NOBLEX_MODE_AUTO << 5);
50 remote_state[1] = 0x90; // NOBLEX_TEMP_MAP 25C
51 break;
53 remote_state[0] |= (IRNoblexMode::IR_NOBLEX_MODE_COOL << 5);
54 break;
56 remote_state[0] |= (IRNoblexMode::IR_NOBLEX_MODE_DRY << 5);
57 break;
59 remote_state[0] |= (IRNoblexMode::IR_NOBLEX_MODE_FAN << 5);
60 break;
62 remote_state[0] |= (IRNoblexMode::IR_NOBLEX_MODE_HEAT << 5);
63 break;
65 default:
66 powered_on = false;
67 this->powered_on_assumed = powered_on;
68 remote_state[0] &= 0xEF;
69 remote_state[2] = 0x00;
70 break;
71 }
72
73 switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
75 remote_state[0] |= (IRNoblexFan::IR_NOBLEX_FAN_LOW << 2);
76 break;
78 remote_state[0] |= (IRNoblexFan::IR_NOBLEX_FAN_MEDIUM << 2);
79 break;
81 remote_state[0] |= (IRNoblexFan::IR_NOBLEX_FAN_HIGH << 2);
82 break;
84 default:
85 remote_state[0] |= (IRNoblexFan::IR_NOBLEX_FAN_AUTO << 2);
86 break;
87 }
88
89 switch (this->swing_mode) {
91 remote_state[0] |= 0x02;
92 remote_state[4] = 0x58;
93 break;
95 default:
96 remote_state[0] &= 0xFD;
97 remote_state[4] = 0x50;
98 break;
99 }
100
101 uint8_t crc = 0;
102 for (uint8_t i : remote_state) {
103 crc += reverse_bits(i);
104 }
105 crc = reverse_bits(uint8_t(crc & 0x0F)) >> 4;
106
107 ESP_LOGD_HEX(TAG, remote_state, sizeof(remote_state), sizeof(remote_state), "Sending noblex code: %s");
108
109 ESP_LOGV(TAG, "CRC: %01X", crc);
110
111 auto transmit = this->transmitter_->transmit();
112 auto *data = transmit.get_data();
113 data->set_carrier_frequency(38000);
114
115 // Header
116 data->mark(NOBLEX_HEADER_MARK);
117 data->space(NOBLEX_HEADER_SPACE);
118 // Data (sent remote_state from the MSB to the LSB)
119 for (int byte_idx = 0; byte_idx < 8; byte_idx++) {
120 for (int8_t bit_idx = 7; bit_idx >= 0; bit_idx--) {
121 if ((byte_idx == 4) && (bit_idx == 4)) {
122 // Header intermediate
123 data->mark(NOBLEX_BIT_MARK);
124 data->space(NOBLEX_GAP); // gap en bit 36
125 } else {
126 data->mark(NOBLEX_BIT_MARK);
127 bool bit = remote_state[byte_idx] & (1 << bit_idx);
128 data->space(bit ? NOBLEX_ONE_SPACE : NOBLEX_ZERO_SPACE);
129 }
130 }
131 }
132 // send crc
133 for (int8_t i = 3; i >= 0; i--) {
134 data->mark(NOBLEX_BIT_MARK);
135 bool bit = crc & (1 << i);
136 data->space(bit ? NOBLEX_ONE_SPACE : NOBLEX_ZERO_SPACE);
137 }
138 // Footer
139 data->mark(NOBLEX_BIT_MARK);
140
141 transmit.perform();
142} // end transmit_state()
143
144// Handle received IR Buffer
146 if (data.peek_item(NOBLEX_HEADER_MARK, NOBLEX_HEADER_SPACE)) {
147 // First part: header + first 36 bits, followed by 20ms gap
148 data.expect_item(NOBLEX_HEADER_MARK, NOBLEX_HEADER_SPACE);
149 ESP_LOGV(TAG, "Header");
150 this->receiving_ = false;
151 memset(this->remote_state_, 0, sizeof(this->remote_state_));
152 for (int i = 0; i < 5; i++) {
153 for (int j = 7; j >= 0; j--) {
154 if ((i == 4) && (j == 4)) {
155 this->remote_state_[i] |= 1 << j;
156 ESP_LOGVV(TAG, "GAP");
157 this->receiving_ = true;
158 return false;
159 } else if (data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ONE_SPACE)) {
160 this->remote_state_[i] |= 1 << j;
161 } else if (!data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ZERO_SPACE)) {
162 ESP_LOGVV(TAG, "Byte %d bit %d fail", i, j);
163 return false;
164 }
165 }
166 ESP_LOGV(TAG, "Byte %d %02X", i, this->remote_state_[i]);
167 }
168 return false;
169 }
170
171 // Second part: remaining 28 bits + 4-bit CRC + footer
172 if (!this->receiving_) {
173 return false;
174 }
175 this->receiving_ = false;
176 for (int i = 4; i < 8; i++) {
177 for (int j = 7; j >= 0; j--) {
178 if ((i == 4) && (j >= 4)) {
179 // already decoded in first part
180 } else if (data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ONE_SPACE)) {
181 this->remote_state_[i] |= 1 << j;
182 } else if (!data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ZERO_SPACE)) {
183 ESP_LOGVV(TAG, "Byte %d bit %d fail", i, j);
184 return false;
185 }
186 }
187 ESP_LOGV(TAG, "Byte %d %02X", i, this->remote_state_[i]);
188 }
189
190 // Read CRC
191 uint8_t crc = 0;
192 for (int i = 3; i >= 0; i--) {
193 if (data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ONE_SPACE)) {
194 crc |= 1 << i;
195 } else if (!data.expect_item(NOBLEX_BIT_MARK, NOBLEX_ZERO_SPACE)) {
196 ESP_LOGVV(TAG, "Bit %d CRC fail", i);
197 return false;
198 }
199 }
200 ESP_LOGV(TAG, "CRC %02X", crc);
201
202 // Validate footer
203 if (!data.expect_mark(NOBLEX_BIT_MARK)) {
204 ESP_LOGV(TAG, "Footer fail");
205 return false;
206 }
207
208 // Validate CRC
209 uint8_t crc_calculated = 0;
210 for (uint8_t i : this->remote_state_)
211 crc_calculated += reverse_bits(i);
212 crc_calculated = reverse_bits(uint8_t(crc_calculated & 0x0F)) >> 4;
213 ESP_LOGVV(TAG, "CRC calc %02X", crc_calculated);
214
215 if (crc != crc_calculated) {
216 ESP_LOGV(TAG, "CRC fail");
217 return false;
218 }
219
220 ESP_LOGD_HEX(TAG, this->remote_state_, sizeof(this->remote_state_), sizeof(this->remote_state_),
221 "Received noblex code: %s");
222
223 auto powered_on = false;
224 if ((this->remote_state_[0] & NOBLEX_POWER) == NOBLEX_POWER) {
225 powered_on = true;
226 this->powered_on_assumed = powered_on;
227 } else {
228 powered_on = false;
229 this->powered_on_assumed = powered_on;
231 }
232 // powr on/off button
233 ESP_LOGV(TAG, "Power: %01X", powered_on);
234
235 // Set received mode
236 if (powered_on_assumed) {
237 auto mode = (this->remote_state_[0] & 0xE0) >> 5;
238 ESP_LOGV(TAG, "Mode: %02X", mode);
239 switch (mode) {
240 case IRNoblexMode::IR_NOBLEX_MODE_AUTO:
242 break;
243 case IRNoblexMode::IR_NOBLEX_MODE_COOL:
245 break;
246 case IRNoblexMode::IR_NOBLEX_MODE_DRY:
248 break;
249 case IRNoblexMode::IR_NOBLEX_MODE_FAN:
251 break;
252 case IRNoblexMode::IR_NOBLEX_MODE_HEAT:
254 break;
255 default:
256 break;
257 }
258 }
259
260 // Set received temp
261 uint8_t temp = this->remote_state_[1];
262 ESP_LOGVV(TAG, "Temperature Raw: %02X", temp);
263
264 temp = 0x0F & reverse_bits(temp);
265 temp += NOBLEX_TEMP_MIN;
266 ESP_LOGV(TAG, "Temperature Climate: %u", temp);
267 this->target_temperature = temp;
268
269 // Set received fan speed
270 auto fan = (this->remote_state_[0] & 0x0C) >> 2;
271 ESP_LOGV(TAG, "Fan: %02X", fan);
272 switch (fan) {
273 case IRNoblexFan::IR_NOBLEX_FAN_HIGH:
275 break;
276 case IRNoblexFan::IR_NOBLEX_FAN_MEDIUM:
278 break;
279 case IRNoblexFan::IR_NOBLEX_FAN_LOW:
281 break;
282 case IRNoblexFan::IR_NOBLEX_FAN_AUTO:
283 default:
285 break;
286 }
287
288 // Set received swing status
289 if (this->remote_state_[0] & 0x02) {
290 ESP_LOGV(TAG, "Swing vertical");
292 } else {
293 ESP_LOGV(TAG, "Swing OFF");
295 }
296
297 this->publish_state();
298 return true;
299} // end on_receive()
300
301} // namespace esphome::noblex
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_state() override
Transmit via IR the state of this climate controller.
Definition noblex.cpp:33
bool on_receive(remote_base::RemoteReceiveData data) override
Handle received IR Buffer.
Definition noblex.cpp:145
bool expect_item(uint32_t mark, uint32_t space)
@ CLIMATE_SWING_OFF
The swing mode is set to Off.
@ CLIMATE_SWING_VERTICAL
The fan mode is set to Vertical.
@ 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_HIGH
The fan mode is set to High.
const uint16_t NOBLEX_ONE_SPACE
Definition noblex.cpp:12
const uint16_t NOBLEX_HEADER_SPACE
Definition noblex.cpp:10
const uint8_t NOBLEX_POWER
Definition noblex.cpp:15
const uint16_t NOBLEX_ZERO_SPACE
Definition noblex.cpp:13
const uint32_t NOBLEX_GAP
Definition noblex.cpp:14
const uint16_t NOBLEX_HEADER_MARK
Definition noblex.cpp:9
ESPHOME_LOG_TAG(TAG, "noblex.climate")
const uint16_t NOBLEX_BIT_MARK
Definition noblex.cpp:11
enum IRNoblexMode { IR_NOBLEX_MODE_AUTO=0b000, IR_NOBLEX_MODE_COOL=0b100, IR_NOBLEX_MODE_DRY=0b010, IR_NOBLEX_MODE_FAN=0b110, IR_NOBLEX_MODE_HEAT=0b001, } IRNoblexMode
Definition noblex.cpp:17
const uint8_t NOBLEX_TEMP_MIN
Definition noblex.h:8
const uint8_t NOBLEX_TEMP_MAX
Definition noblex.h:9
enum IRNoblexFan { IR_NOBLEX_FAN_AUTO=0b00, IR_NOBLEX_FAN_LOW=0b10, IR_NOBLEX_FAN_MEDIUM=0b01, IR_NOBLEX_FAN_HIGH=0b11, } IRNoblexFan
Definition noblex.cpp:25
uint8_t reverse_bits(uint8_t x)
Reverse the order of 8 bits.
Definition helpers.h:1159
static void uint32_t