ESPHome  2024.5.3
hitachi_ac424.cpp
Go to the documentation of this file.
1 #include "hitachi_ac424.h"
2 
3 namespace esphome {
4 namespace hitachi_ac424 {
5 
6 static const char *const TAG = "climate.hitachi_ac424";
7 
8 void set_bits(uint8_t *const dst, const uint8_t offset, const uint8_t nbits, const uint8_t data) {
9  if (offset >= 8 || !nbits)
10  return; // Short circuit as it won't change.
11  // Calculate the mask for the supplied value.
12  uint8_t mask = UINT8_MAX >> (8 - ((nbits > 8) ? 8 : nbits));
13  // Calculate the mask & clear the space for the data.
14  // Clear the destination bits.
15  *dst &= ~(uint8_t) (mask << offset);
16  // Merge in the data.
17  *dst |= ((data & mask) << offset);
18 }
19 
20 void set_bit(uint8_t *const data, const uint8_t position, const bool on) {
21  uint8_t mask = 1 << position;
22  if (on) {
23  *data |= mask;
24  } else {
25  *data &= ~mask;
26  }
27 }
28 
29 uint8_t *invert_byte_pairs(uint8_t *ptr, const uint16_t length) {
30  for (uint16_t i = 1; i < length; i += 2) {
31  // Code done this way to avoid a compiler warning bug.
32  uint8_t inv = ~*(ptr + i - 1);
33  *(ptr + i) = inv;
34  }
35  return ptr;
36 }
37 
39 
43 }
44 
46 
48  uint8_t new_mode = mode;
49  switch (mode) {
50  // Fan mode sets a special temp.
53  break;
57  break;
58  default:
59  new_mode = HITACHI_AC424_MODE_COOL;
60  }
62  if (new_mode != HITACHI_AC424_MODE_FAN)
64  set_fan_(get_fan_()); // Reset the fan speed after the mode change.
65  set_power_(true);
66 }
67 
68 void HitachiClimate::set_temp_(uint8_t celsius, bool set_previous) {
69  uint8_t temp;
70  temp = std::min(celsius, HITACHI_AC424_TEMP_MAX);
71  temp = std::max(temp, HITACHI_AC424_TEMP_MIN);
73  if (previous_temp_ > temp) {
75  } else if (previous_temp_ < temp) {
77  }
78  if (set_previous)
79  previous_temp_ = temp;
80 }
81 
83 
85  uint8_t new_speed = std::max(speed, HITACHI_AC424_FAN_MIN);
86  uint8_t fan_max = HITACHI_AC424_FAN_MAX;
87 
88  // Only 2 x low speeds in Dry mode or Auto
90  fan_max = HITACHI_AC424_FAN_AUTO;
91  } else if (get_mode_() == HITACHI_AC424_MODE_DRY) {
92  fan_max = HITACHI_AC424_FAN_MAX_DRY;
93  } else if (get_mode_() == HITACHI_AC424_MODE_FAN && speed == HITACHI_AC424_FAN_AUTO) {
94  // Fan Mode does not have auto. Set to safe low
95  new_speed = HITACHI_AC424_FAN_MIN;
96  }
97 
98  new_speed = std::min(new_speed, fan_max);
99  // Handle the setting the button value if we are going to change the value.
100  if (new_speed != get_fan_())
102  // Set the values
103 
104  set_bits(&remote_state_[HITACHI_AC424_FAN_BYTE], 4, 4, new_speed);
105  remote_state_[9] = 0x92;
106 
107  // When fan is at min/max, additional bytes seem to be set
108  if (new_speed == HITACHI_AC424_FAN_MIN)
109  remote_state_[9] = 0x98;
110  remote_state_[29] = 0x01;
111 }
112 
114  uint8_t button = get_button_(); // Get the current button value.
115  if (on) {
116  button = HITACHI_AC424_BUTTON_SWINGV; // Set the button to SwingV.
117  } else if (button == HITACHI_AC424_BUTTON_SWINGV) { // Asked to unset it
118  // It was set previous, so use Power as a default
120  }
121  set_button_(button);
122 }
123 
125 
127  set_swing_v_toggle_(on); // Set the button value.
129 }
130 
133 }
134 
136  if (position > HITACHI_AC424_SWINGH_LEFT_MAX)
140 }
141 
145 }
146 
148 
150 
152  switch (this->mode) {
155  break;
158  break;
161  break;
164  break;
167  break;
169  set_power_(false);
170  break;
171  default:
172  ESP_LOGW(TAG, "Unsupported mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
173  }
174 
175  set_temp_(static_cast<uint8_t>(this->target_temperature));
176 
177  switch (this->fan_mode.value()) {
180  break;
183  break;
186  break;
189  default:
191  }
192 
193  switch (this->swing_mode) {
195  set_swing_v_(true);
197  break;
199  set_swing_v_(true);
201  break;
203  set_swing_v_(false);
205  break;
207  set_swing_v_(false);
209  break;
210  }
211 
212  // TODO: find change value to set button, now always set to power button
214 
216 
217  auto transmit = this->transmitter_->transmit();
218  auto *data = transmit.get_data();
220 
221  uint8_t repeat = 0;
222  for (uint8_t r = 0; r <= repeat; r++) {
223  // Header
225  // Data
226  for (uint8_t i : remote_state_) {
227  for (uint8_t j = 0; j < 8; j++) {
228  data->mark(HITACHI_AC424_BIT_MARK);
229  bool bit = i & (1 << j);
231  }
232  }
233  // Footer
235  }
236  transmit.perform();
237 
238  dump_state_("Sent", remote_state_);
239 }
240 
241 bool HitachiClimate::parse_mode_(const uint8_t remote_state[]) {
242  uint8_t power = remote_state[HITACHI_AC424_POWER_BYTE];
243  ESP_LOGV(TAG, "Power: %02X %02X", remote_state[HITACHI_AC424_POWER_BYTE], power);
244  uint8_t mode = remote_state[HITACHI_AC424_MODE_BYTE] & 0xF;
245  ESP_LOGV(TAG, "Mode: %02X %02X", remote_state[HITACHI_AC424_MODE_BYTE], mode);
246  if (power == HITACHI_AC424_POWER_ON) {
247  switch (mode) {
249  this->mode = climate::CLIMATE_MODE_COOL;
250  break;
252  this->mode = climate::CLIMATE_MODE_DRY;
253  break;
255  this->mode = climate::CLIMATE_MODE_HEAT;
256  break;
258  this->mode = climate::CLIMATE_MODE_HEAT_COOL;
259  break;
261  this->mode = climate::CLIMATE_MODE_FAN_ONLY;
262  break;
263  }
264  } else {
265  this->mode = climate::CLIMATE_MODE_OFF;
266  }
267  return true;
268 }
269 
270 bool HitachiClimate::parse_temperature_(const uint8_t remote_state[]) {
271  uint8_t temperature =
272  HITACHI_AC424_GETBITS8(remote_state[HITACHI_AC424_TEMP_BYTE], HITACHI_AC424_TEMP_OFFSET, HITACHI_AC424_TEMP_SIZE);
274  ESP_LOGV(TAG, "Temperature: %02X %02u %04f", remote_state[HITACHI_AC424_TEMP_BYTE], temperature,
275  this->target_temperature);
276  return true;
277 }
278 
279 bool HitachiClimate::parse_fan_(const uint8_t remote_state[]) {
280  uint8_t fan_mode = remote_state[HITACHI_AC424_FAN_BYTE] >> 4 & 0xF;
281  ESP_LOGV(TAG, "Fan: %02X %02X", remote_state[HITACHI_AC424_FAN_BYTE], fan_mode);
282  switch (fan_mode) {
285  this->fan_mode = climate::CLIMATE_FAN_LOW;
286  break;
288  this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
289  break;
292  this->fan_mode = climate::CLIMATE_FAN_HIGH;
293  break;
295  this->fan_mode = climate::CLIMATE_FAN_AUTO;
296  break;
297  }
298  return true;
299 }
300 
301 bool HitachiClimate::parse_swing_(const uint8_t remote_state[]) {
302  uint8_t swing_modeh = HITACHI_AC424_GETBITS8(remote_state[HITACHI_AC424_SWINGH_BYTE], HITACHI_AC424_SWINGH_OFFSET,
304  ESP_LOGV(TAG, "SwingH: %02X %02X", remote_state[HITACHI_AC424_SWINGH_BYTE], swing_modeh);
305 
306  if ((swing_modeh & 0x3) == 0x3) {
308  } else {
310  }
311 
312  return true;
313 }
314 
316  // Validate header
318  ESP_LOGVV(TAG, "Header fail");
319  return false;
320  }
321 
322  uint8_t recv_state[HITACHI_AC424_STATE_LENGTH] = {0};
323  // Read all bytes.
324  for (uint8_t pos = 0; pos < HITACHI_AC424_STATE_LENGTH; pos++) {
325  // Read bit
326  for (int8_t bit = 0; bit < 8; bit++) {
328  recv_state[pos] |= 1 << bit;
330  ESP_LOGVV(TAG, "Byte %d bit %d fail", pos, bit);
331  return false;
332  }
333  }
334  }
335 
336  // Validate footer
337  if (!data.expect_mark(HITACHI_AC424_BIT_MARK)) {
338  ESP_LOGVV(TAG, "Footer fail");
339  return false;
340  }
341 
342  dump_state_("Recv", recv_state);
343 
344  // parse mode
345  this->parse_mode_(recv_state);
346  // parse temperature
347  this->parse_temperature_(recv_state);
348  // parse fan
349  this->parse_fan_(recv_state);
350  // parse swingv
351  this->parse_swing_(recv_state);
352  this->publish_state();
353  for (uint8_t i = 0; i < HITACHI_AC424_STATE_LENGTH; i++)
354  remote_state_[i] = recv_state[i];
355 
356  return true;
357 }
358 
359 void HitachiClimate::dump_state_(const char action[], uint8_t state[]) {
360  for (uint16_t i = 0; i < HITACHI_AC424_STATE_LENGTH - 10; i += 10) {
361  ESP_LOGV(TAG, "%s: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", action, state[i + 0], state[i + 1],
362  state[i + 2], state[i + 3], state[i + 4], state[i + 5], state[i + 6], state[i + 7], state[i + 8],
363  state[i + 9]);
364  }
365  ESP_LOGV(TAG, "%s: %02X %02X %02X", action, state[40], state[41], state[42]);
366 }
367 
368 } // namespace hitachi_ac424
369 } // namespace esphome
The fan mode is set to Low.
Definition: climate_mode.h:54
const uint8_t HITACHI_AC424_BUTTON_FAN
Definition: hitachi_ac424.h:21
value_type const & value() const
Definition: optional.h:89
const uint8_t HITACHI_AC424_BUTTON_BYTE
Definition: hitachi_ac424.h:17
ClimateSwingMode swing_mode
The active swing mode of the climate device.
Definition: climate.h:202
uint8_t * invert_byte_pairs(uint8_t *ptr, const uint16_t length)
The fan mode is set to Both.
Definition: climate_mode.h:74
const uint8_t HITACHI_AC424_POWER_BYTE
Definition: hitachi_ac424.h:54
void set_bit(uint8_t *const data, const uint8_t position, const bool on)
const uint8_t HITACHI_AC424_BUTTON_TEMP_DOWN
Definition: hitachi_ac424.h:22
const uint8_t HITACHI_AC424_FAN_HIGH
Definition: hitachi_ac424.h:49
const uint16_t HITACHI_AC424_HDR_MARK
Definition: hitachi_ac424.h:9
float target_temperature
The target temperature of the climate device.
Definition: climate.h:186
const uint8_t HITACHI_AC424_FAN_MEDIUM
Definition: hitachi_ac424.h:48
void set_carrier_frequency(uint32_t carrier_frequency)
Definition: remote_base.h:34
const uint16_t HITACHI_AC424_ZERO_SPACE
Definition: hitachi_ac424.h:13
const LogString * climate_mode_to_string(ClimateMode mode)
Convert the given ClimateMode to a human-readable string.
Definition: climate_mode.cpp:6
const uint16_t HITACHI_AC424_HDR_SPACE
Definition: hitachi_ac424.h:10
The climate device is set to heat to reach the target temperature.
Definition: climate_mode.h:18
const uint8_t HITACHI_AC424_TEMP_FAN
Definition: hitachi_ac424.h:33
const uint8_t HITACHI_AC424_SWINGH_BYTE
Definition: hitachi_ac424.h:58
ClimateMode mode
The active mode of the climate device.
Definition: climate.h:173
const uint8_t HITACHI_AC424_BUTTON_SWINGH
Definition: hitachi_ac424.h:25
int speed
Definition: fan.h:35
const uint8_t HITACHI_AC424_TEMP_SIZE
Definition: hitachi_ac424.h:30
bool parse_swing_(const uint8_t remote_state[])
const uint8_t HITACHI_AC424_MODE_AUTO
Definition: hitachi_ac424.h:42
const uint8_t HITACHI_AC424_MODE_FAN
Definition: hitachi_ac424.h:38
The climate device is set to dry/humidity mode.
Definition: climate_mode.h:22
const uint8_t HITACHI_AC424_POWER_OFF
Definition: hitachi_ac424.h:56
const uint8_t HITACHI_AC424_SWINGV_OFFSET
Definition: hitachi_ac424.h:69
const uint8_t HITACHI_AC424_POWER_ON
Definition: hitachi_ac424.h:55
bool parse_mode_(const uint8_t remote_state[])
const uint16_t HITACHI_AC424_ONE_SPACE
Definition: hitachi_ac424.h:12
const uint8_t HITACHI_AC424_FAN_MAX
Definition: hitachi_ac424.h:51
const uint16_t HITACHI_AC424_STATE_LENGTH
Definition: hitachi_ac424.h:74
const uint16_t HITACHI_AC424_BIT_MARK
Definition: hitachi_ac424.h:11
const uint8_t HITACHI_AC424_FAN_AUTO
Definition: hitachi_ac424.h:50
const uint8_t HITACHI_AC424_FAN_MIN
Definition: hitachi_ac424.h:46
The fan mode is set to Horizontal.
Definition: climate_mode.h:78
The climate device is set to cool to reach the target temperature.
Definition: climate_mode.h:16
The fan mode is set to Auto.
Definition: climate_mode.h:52
const uint8_t HITACHI_AC424_TEMP_OFFSET
Definition: hitachi_ac424.h:29
const uint8_t HITACHI_AC424_TEMP_MIN
Definition: hitachi_ac424.h:31
const uint8_t HITACHI_AC424_MODE_DRY
Definition: hitachi_ac424.h:40
const uint8_t HITACHI_AC424_MODE_BYTE
Definition: hitachi_ac424.h:37
RemoteTransmitterBase * transmitter_
Definition: remote_base.h:276
const uint8_t HITACHI_AC424_BUTTON_SWINGV
Definition: hitachi_ac424.h:24
const uint8_t HITACHI_AC424_SWINGH_AUTO
Definition: hitachi_ac424.h:61
uint16_t temperature
Definition: sun_gtil2.cpp:26
The climate device is set to heat/cool to reach the target temperature.
Definition: climate_mode.h:14
const uint8_t HITACHI_AC424_FAN_LOW
Definition: hitachi_ac424.h:47
The fan mode is set to Vertical.
Definition: climate_mode.h:76
void set_bits(uint8_t *const dst, const uint8_t offset, const uint8_t nbits, const uint8_t data)
const uint8_t HITACHI_AC424_MODE_HEAT
Definition: hitachi_ac424.h:41
bool parse_fan_(const uint8_t remote_state[])
const uint8_t HITACHI_AC424_SWINGV_BYTE
Definition: hitachi_ac424.h:68
const uint8_t HITACHI_AC424_MODE_COOL
Definition: hitachi_ac424.h:39
const uint8_t HITACHI_AC424_SWINGH_SIZE
Definition: hitachi_ac424.h:60
void publish_state()
Publish the state of the climate device, to be called from integrations.
Definition: climate.cpp:395
void set_temp_(uint8_t celsius, bool set_previous=false)
The fan mode is set to High.
Definition: climate_mode.h:58
The swing mode is set to Off.
Definition: climate_mode.h:72
The climate device is off.
Definition: climate_mode.h:12
bool parse_temperature_(const uint8_t remote_state[])
const uint8_t HITACHI_AC424_TEMP_MAX
Definition: hitachi_ac424.h:32
optional< ClimateFanMode > fan_mode
The active fan mode of the climate device.
Definition: climate.h:199
const uint8_t HITACHI_AC424_SWINGH_MIDDLE
Definition: hitachi_ac424.h:64
The fan mode is set to On.
Definition: climate_mode.h:48
bool on_receive(remote_base::RemoteReceiveData data) override
uint16_t length
Definition: tt21100.cpp:12
const uint8_t HITACHI_AC424_BUTTON_TEMP_UP
Definition: hitachi_ac424.h:23
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
Definition: a01nyub.cpp:7
const uint8_t HITACHI_AC424_FAN_BYTE
Definition: hitachi_ac424.h:45
const uint8_t HITACHI_AC424_FAN_MAX_DRY
Definition: hitachi_ac424.h:52
const uint32_t HITACHI_AC424_MIN_GAP
Definition: hitachi_ac424.h:14
const uint8_t HITACHI_AC424_SWINGH_OFFSET
Definition: hitachi_ac424.h:59
const uint8_t HITACHI_AC424_TEMP_BYTE
Definition: hitachi_ac424.h:28
The fan mode is set to Medium.
Definition: climate_mode.h:56
float position
Definition: cover.h:14
uint8_t remote_state_[HITACHI_AC424_STATE_LENGTH]
Definition: hitachi_ac424.h:90
const uint8_t HITACHI_AC424_BUTTON_POWER
Definition: hitachi_ac424.h:18
const uint8_t HITACHI_AC424_SWINGH_LEFT_MAX
Definition: hitachi_ac424.h:66
const uint16_t HITACHI_AC424_FREQ
Definition: hitachi_ac424.h:15
bool expect_item(uint32_t mark, uint32_t space)
Definition: remote_base.cpp:74
The climate device only has the fan enabled, no heating or cooling is taking place.
Definition: climate_mode.h:20
ClimateAction action
The active state of the climate device.
Definition: climate.h:176
bool state
Definition: fan.h:34
void dump_state_(const char action[], uint8_t remote_state[])