Need a check for breaking changes here

WallyR · October 21, 2025, 7:29am

I have this ESPHome config and it works in 2025.9.3, but not in 2025.10.X.

I get an error saying.
WARNING Can't connect to ESPHome API for onkyo @ 10.10.12.58: Error connecting to [AddrInfo(family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, proto=6, sockaddr=IPv4Sockaddr(address='10.10.12.58', port=6053))]: [Errno 111] Connect call failed ('10.10.12.58', 6053) (SocketAPIError)

The funny thing is that I then can not connect to the logger stream, but I can still update the device, which means I can install ESPHome 2025.9.4 and OTA update it, which makes all work again.
If I try 2025.10.X again, then it will fail again. I have done it a couple of times just to be sure.

I hope someone can tell me, if I have done something wrong or if I have a bug.
I know that something happend with the arduino framework, but I tried to switch to esp-idf, but with no change in behavior.

The YAML config is here.

esphome:
  name: onkyo
  friendly_name: Onkyo
  
esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:
#  baud_rate: 0
  tx_buffer_size: 256
  level: DEBUG
ota:
  - platform: esphome
    password: !secret esphome_ota_pass


wifi:
  output_power: 20db
  fast_connect: true
  ssid: DWsh
  password: !secret dwsh_pass
  manual_ip:
    static_ip: 10.10.12.58
    subnet: 255.255.255.0
    gateway: 10.10.12.1
    dns1: 10.10.12.1

globals:
  # Custom input names. Values set to be empty is skipped and can't be selected from here, but can still be chosen directly on the receiver!
  # Also input names must be unique!
  - id: vcr_dvr
    type: std::string
    initial_value: '"VCR/DVR"' # VCR/DVR
  - id: cbl_sat
    type: std::string
    initial_value: '"MINIJACK"' # CBL/SAT
  - id: game_tv
    type: std::string
    initial_value: '"PS3"' # GAME/TV
  - id: aux
    type: std::string
    initial_value: '"AUX"' # AUX
  - id: dvd
    type: std::string
    initial_value: '"SNAPCAST"' # DVD
  - id: tape
    type: std::string
    initial_value: '"TAPE"' # TAPE
  - id: phono
    type: std::string
    initial_value: '"PHONO"' # PHONO
  - id: cd
    type: std::string
    initial_value: '"TV SOUND"' # CD
  # Previous values for restoring when receiver return n/a
  - id: previous_input
    type: std::string
    initial_value: '"N/A"'
  - id: previous_listening_mode
    type: std::string
    initial_value: '"N/A"'

text_sensor:
  - platform: template
    name: "Input"
    icon: mdi:video-input-component
    id: "input"
    on_value:
      then:
        - if:
            condition:
              - lambda: |-
                  if (id(input).state=="Not available") {
                    return true;
                  } else {
                    return false;
                  }
            then:
              - delay: 2s
              - uart.write:
                  id: uart_onkyo
                  data: "1!SLIQSTN"
  - platform: template
    name: "Input Available"
    icon: mdi:video-input-component
    id: "input_available"
    on_value:
      then:
        - if:
            condition:
              - lambda: |-
                  if (id(listening_mode).state=="Not available") {
                    return true;
                  } else {
                    return false;
                  }
            then:
              - delay: 2s
              - uart.write:
                  id: uart_onkyo
                  data: "1!LMDQSTN"
  - platform: template
    name: "Listening Mode"
    icon: mdi:surround-sound
    id: "listening_mode"
  - platform: template
    name: "Listening Mode Available"
    icon: mdi:surround-sound
    id: "listening_mode_available"

binary_sensor:
  - platform: template
    name: "Power"
    icon: mdi:power
    id: "power"
  - platform: template
    name: "Mute"
    icon: mdi:volume-variant-off
    id: "mute"

sensor:
  - platform: wifi_signal
    name: "wifi Signal"
  - platform: uptime
    name: "Uptime"
  - platform: template
    name: "Volume"
    icon: mdi:volume-high
    id: "volume"

button:
  - platform: restart
    name: "restart"
  - platform: factory_reset
    name: Restart with Factory Default Settings
    id: onkyo_factory_reset
    entity_category: "diagnostic"

api:
  encryption:
    key: !secret api_key
  actions:
    # Direct Onkyo Command
    - action: write
      variables:
        command: string
      then:
        - uart.write:
            id: uart_onkyo
            data: !lambda |-
              std::string str = command;
              std::vector<uint8_t> vec(str.begin(), str.end());
              return vec;
        - uart.write:
            id: uart_onkyo
            data: "\r"
    # Power
    - action: power_on
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1PWR01\r"
    - action: power_off
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1PWR00\r"
    - action: power_update
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1PWRQSTN\r"
    # Mute
    - action: mute_on
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1AMT01\r"
    - action: mute_off
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1AMT00\r"
    - action: mute_toggle
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1AMTTG\r"
    - action: mute_update
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1AMTQSTN\r"
    # Volume
    - action: set_volume
      variables:
        volume: string
      then:
        - if:
            condition:
              lambda: |-
                int new_value = stoi(((std::string)volume),0,10);
                if (new_value<=100 && new_value>=0) {
                  return true;
                } else {
                  return false;
                }
            then:
              - uart.write:
                  id: uart_onkyo
                  data: "!1MVL"
              - uart.write:
                  id: uart_onkyo
                  data: !lambda |-
                    int new_value = stoi(((std::string)volume),0,10);
                    int first = new_value/16;
                    char first_char;
                    switch (first) {
                      case 0:
                        first_char = '0';
                        break;
                      case 1:
                        first_char = '1';
                        break;
                      case 2:
                        first_char = '2';
                        break;
                      case 3:
                        first_char = '3';
                        break;
                      case 4:
                        first_char = '4';
                        break;
                      case 5:
                        first_char = '5';
                        break;
                      case 6:
                        first_char = '6';
                        break;
                      case 7:
                        first_char = '7';
                        break;
                      case 8:
                        first_char = '8';
                        break;
                      case 9:
                        first_char = '9';
                        break;
                      case 10:
                        first_char = 'A';
                        break;
                      case 11:
                        first_char = 'B';
                        break;
                      case 12:
                        first_char = 'C';
                        break;
                      case 13:
                        first_char = 'D';
                        break;
                      case 14:
                        first_char = 'E';
                        break;
                      case 15:
                        first_char = 'F';
                        break;
                      default:
                        first_char = 'Q';
                        break;
                    }
                    std::string str(1, first_char);
                    std::vector<uint8_t> vec(str.begin(), str.end());
                    return vec;
              - uart.write:
                  id: uart_onkyo
                  data: !lambda |-
                    int new_value = stoi(((std::string)volume),0,10);
                    int first = new_value/16;
                    int second = new_value - (first*16);
                    char second_char;
                    switch (second) {
                      case 0:
                        second_char = '0';
                        break;
                      case 1:
                        second_char = '1';
                        break;
                      case 2:
                        second_char = '2';
                        break;
                      case 3:
                        second_char = '3';
                        break;
                      case 4:
                        second_char = '4';
                        break;
                      case 5:
                        second_char = '5';
                        break;
                      case 6:
                        second_char = '6';
                        break;
                      case 7:
                        second_char = '7';
                        break;
                      case 8:
                        second_char = '8';
                        break;
                      case 9:
                        second_char = '9';
                        break;
                      case 10:
                        second_char = 'A';
                        break;
                      case 11:
                        second_char = 'B';
                        break;
                      case 12:
                        second_char = 'C';
                        break;
                      case 13:
                        second_char = 'D';
                        break;
                      case 14:
                        second_char = 'E';
                        break;
                      case 15:
                        second_char = 'F';
                        break;
                      default:
                        second_char = 'Q';
                        break;
                    }
                    std::string str(1, second_char);
                    std::vector<uint8_t> vec(str.begin(), str.end());
                    return vec;
              - uart.write:
                  id: uart_onkyo
                  data: "\r"
    - action: volume_update
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1MVLQSTN\r"
    # Input
    - action: set_input
      variables:
        input: string
      then:
        - if:
            condition:
              lambda: |-
                if (input=="") {
                  return false;
                } else {
                  return true;
                }
            then:
              - lambda: |-
                  id(previous_input)=id(input);
              - uart.write:
                  id: uart_onkyo
                  data: "!1SLI"
              - uart.write:
                  id: uart_onkyo
                  data: !lambda |-
                    std::string str;
                    if (input==id(vcr_dvr)) { str="00"; }
                    if (input==id(cbl_sat)) { str="01"; }
                    if (input==id(game_tv)) { str="02"; }
                    if (input==id(aux))     { str="03"; }
                    if (input==id(dvd))     { str="10"; }
                    if (input==id(tape))    { str="20"; }
                    if (input==id(phono))   { str="22"; }
                    if (input==id(cd))      { str="23"; }
                    if (input=="FM TUNER")  { str="24"; }
                    if (input=="AM TUNER")  { str="25"; }
                    if (input=="MULTI CH")  { str="30"; }
                    if (str.length()==0)    { str="QSTN"; }
                    std::vector<uint8_t> vec(str.begin(), str.end());
                    return vec;
              - uart.write:
                  id: uart_onkyo
                  data: "\r"
              - delay: 1s
              - uart.write:
                  id: uart_onkyo
                  data: "!1SLIQSTN\r"
    - action: input_update
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1SLIQSTN\r"
    - action: available_input_update
      then:
        - lambda: |-
            std::string str;
            if (id(vcr_dvr).length()>0) {
              str.append(id(vcr_dvr));
            }
            if (id(cbl_sat).length()>0) { 
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(cbl_sat));
            }
            if (id(game_tv).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(game_tv));
            }
            if (id(aux).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(aux));
            }
            if (id(dvd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(dvd));
            }
            if (id(tape).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(tape));
            }
            if (id(phono).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(phono));
            }
            if (id(cd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(cd));
            }
            if (id(cd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append("FM TUNER, AM TUNER, MULTI CH");
            }
            id(input_available).publish_state(str.c_str());
    # Listening Mode
    - action: set_listening_mode
      variables:
        mode: string
      then:
        - if:
            condition:
              lambda: |-
                if (mode=="") {
                  return false;
                } else {
                  return true;
                }
            then:
              - uart.write:
                  id: uart_onkyo
                  data: "!1LMD"
              - uart.write:
                  id: uart_onkyo
                  data: !lambda |-
                    std::string str;
                    if (mode=="STEREO")     { str="00"; }
                    if (mode=="DIRECT")     { str="01"; }
                    if (mode=="SURROUND")   { str="02"; }
                    if (mode=="THEATER")    { str="13"; }
                    if (mode=="MONO")       { str="15"; }
                    if (mode=="PURE AUDIO") { str="17"; }
                    if (mode=="STRAIGHT")   { str="64"; }
                    if (str.length()==0)    { str="QSTN"; }
                    std::vector<uint8_t> vec(str.begin(), str.end());
                    return vec;
              - uart.write:
                  id: uart_onkyo
                  data: "\r"
              - delay: 1s
              - uart.write:
                  id: uart_onkyo
                  data: "!1LMDQSTN\r"
    - action: listening_mode_update
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1LMDQSTN\r"
    - action: available_listening_mode_update
      then:
        - lambda: |-
            id(listening_mode_available).publish_state("STEREO, DIRECT, SURROUND, THEATER, MONO, PURE AUDIO, STRAIGHT");
    # Initialize settings
    - action: update_all
      then:
        - uart.write:
            id: uart_onkyo
            data: "!1PWRQSTN"
        - uart.write:
            id: uart_onkyo
            data: "\r"
        - delay: 1s
        - uart.write:
            id: uart_onkyo
            data: "!1AMTQSTN"
        - uart.write:
            id: uart_onkyo
            data: "\r"
        - delay: 1s
        - uart.write:
            id: uart_onkyo
            data: "!1MVLQSTN"
        - uart.write:
            id: uart_onkyo
            data: "\r"
        - delay: 1s
        - uart.write:
            id: uart_onkyo
            data: "!1SLIQSTN"
        - uart.write:
            id: uart_onkyo
            data: "\r"
        - delay: 1s
        - uart.write:
            id: uart_onkyo
            data: "!1LMDQSTN"
        - uart.write:
            id: uart_onkyo
            data: "\r"
        - lambda: |-
            std::string str;
            if (id(vcr_dvr).length()>0) {
              str.append(id(vcr_dvr));
            }
            if (id(cbl_sat).length()>0) { 
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(cbl_sat));
            }
            if (id(game_tv).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(game_tv));
            }
            if (id(aux).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(aux));
            }
            if (id(dvd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(dvd));
            }
            if (id(tape).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(tape));
            }
            if (id(phono).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(phono));
            }
            if (id(cd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append(id(cd));
            }
            if (id(cd).length()>0) {
              if (str.length()>0) {
                str.append(", ");
              }
              str.append("FM TUNER, AM TUNER, MULTI CH");
            }
            id(input_available).publish_state(str.c_str());
        - lambda: |-
            id(listening_mode_available).publish_state("STEREO, DIRECT, SURROUND, THEATER, MONO, PURE AUDIO, STRAIGHT");

uart:
  - id: uart_onkyo
    baud_rate: 9600
    data_bits: 8
    stop_bits: 1
    parity: NONE
    rx_buffer_size: 128
    tx_pin:
      number: GPIO17
      inverted: false
    rx_pin:
      number: GPIO16
      inverted: false
    debug:
      direction: RX
      dummy_receiver: true
      after:
        bytes: 16
      sequence:
        - lambda: |-
            UARTDebug::log_string(direction, bytes);
            std::string str(bytes.begin(), bytes.end());
            if (str.substr(0,2)=="!1") {
              if (str.substr(2,3)=="PWR") {
                if (str.substr(5,2)=="00") {
                  id(power).publish_state(false);
                }
                if (str.substr(5,2)=="01") {
                  id(power).publish_state(true);
                  id(listening_mode_available).publish_state("STEREO, DIRECT, SURROUND, THEATER, MONO, PURE AUDIO, STRAIGHT");
                  std::string str;
                  if (id(vcr_dvr).length()>0) {
                    str.append(id(vcr_dvr));
                  }
                  if (id(cbl_sat).length()>0) { 
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(cbl_sat));
                  }
                  if (id(game_tv).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(game_tv));
                  }
                  if (id(aux).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(aux));
                  }
                  if (id(dvd).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(dvd));
                  }
                  if (id(tape).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(tape));
                  }
                  if (id(phono).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(phono));
                  }
                  if (id(cd).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append(id(cd));
                  }
                  if (id(cd).length()>0) {
                    if (str.length()>0) {
                      str.append(", ");
                    }
                    str.append("FM TUNER, AM TUNER, MULTI CH");
                  }
                  id(input_available).publish_state(str.c_str());
                }
              }
              if (str.substr(2,3)=="AMT") {
                if (str.substr(5,2)=="00") {
                  id(mute).publish_state(false);
                }
                if (str.substr(5,2)=="01") {
                  id(mute).publish_state(true);
                }
              }
              if (str.substr(2,3)=="MVL") {
                id(volume).publish_state(stoi((std::string)(str.substr(5,2)),0,16));
              }
              if (str.substr(2,3)=="SLI") {
                if (str.substr(5,3)=="N/A") {
                  id(input).publish_state("Not available");
                } else {
                  switch (stoi((std::string)(str.substr(5,2)))) {
                    case 00:
                      id(input).publish_state(id(vcr_dvr).c_str());
                      break;
                    case 01:
                      id(input).publish_state(id(cbl_sat).c_str());
                      break;
                    case 02:
                      id(input).publish_state(id(game_tv).c_str());
                      break;
                    case 03:
                      id(input).publish_state(id(aux).c_str());
                      break;
                    case 10:
                      id(input).publish_state(id(dvd).c_str());
                      break;
                    case 20:
                      id(input).publish_state(id(tape).c_str());
                      break;
                    case 22:
                      id(input).publish_state(id(phono).c_str());
                      break;
                    case 23:
                      id(input).publish_state(id(cd).c_str());
                      break;
                    case 24:
                      id(input).publish_state("FM TUNER");
                      break;
                    case 25:
                      id(input).publish_state("AM TUNER");
                      break;
                    case 30:
                      id(input).publish_state("MULTI CH");
                      break;
                    default:
                      id(input).publish_state("NA");
                      break;
                  }
                }
              }
              if (str.substr(2,3)=="LMD") {
                if (str.substr(5,3)=="N/A") {
                  id(listening_mode).publish_state("Not available");
                } else {
                  switch (stoi((std::string)(str.substr(5,2)),0,16)) {
                    case 00:
                      id(listening_mode).publish_state("STEREO");
                      break;
                    case 01:
                      id(listening_mode).publish_state("DIRECT");
                      break;
                    case 02:
                      id(listening_mode).publish_state("SURROUND");
                      break;
                    case 13:
                      id(listening_mode).publish_state("THEATER");
                      break;
                    case 15:
                      id(listening_mode).publish_state("MONO");
                      break;
                    case 17:
                      id(listening_mode).publish_state("PURE AUDIO");
                      break;
                    case 64:
                      id(listening_mode).publish_state("STRAIGHT");
                      break;
                    default:
                      id(listening_mode).publish_state("NA");
                      break;
                  }
                }
              }
            }

Holdestmade · October 21, 2025, 7:43am

I was having the same issue and few others on discord were too. After a few reflashes with the USB connected it eventually worked. It takes a lot longer to compile now, as it sees to compile every component even when its only a basic config

WallyR · October 21, 2025, 7:47am

It compiles fine and it also uploads, but then the logger component does not work, so I can not use my UART setup.
If I move back to ESPHome 2025.9.3 and compile and OTA upload, then it all works again.

Holdestmade · October 21, 2025, 7:55am

Yes, same. I did find that if you go to the esphome dashboard the logs work from there.

WallyR · October 21, 2025, 8:11am

Nope, that is where I get the error message.

Holdestmade · October 21, 2025, 8:15am

Try doing a few reflashes with cable connected, I don’t know why but it suddenly started working after a few tries. Might be worth looking on Discord as there was a discussion about it

WallyR · October 21, 2025, 8:44am

I avoid Discord. I find it a mess with no continuity.
I tried to find it though, but found nothing related to the issue.

I filed a bug report on the ESPHome Github page.