Open AIR (open source smart ventilatieaansturing)

[Odie]

@thomasv je zou haast de hele MV box opensource gaan produceren. De controller heb je al, de rest is een standaard motor en veel plastic en schuim 😌

[Odie]

Ik ben eens flink aan het klussen gegaan met mijn nieuwe OpenAir Mini in mijn Orcon, samen met het setje van 4 sensoren.

Mijn uitgangspunten:

• Ik wil dat de Orcon zelfs zonder HA en HomeKit (mijn primaire interface) sensorgestuurd kan draaien
• Ik wil naast een auto-mode ook een off-mode en manual-3-standen modus hebben, waarin sensordata niet meer leidend is
• Ik wil de manual mode zowel vanuit HA als HK kunnen aansturen
• Ik wil dat ik eventueel nog automatiseringen in HA of HK kan maken op basis van weetikveel, maar daarmee dus de logica op het ESP bordje buiten spel kan zetten
• De handmatige bediening in HomeKit is nodig omdat ik daar twee 4 remotes in keuken en badkamer gebruik, als ik weet dat ik fors ga koken of k*kken dan wil ik meteen naar standje 'paniek' kunnen met een druk op de knop
• Ik wil een configureerbare day/night stand voor auto mode, waarbij naar keuze de high en auto speed in de nacht anders (lager) gezet kunnen worden ivm geluid van de installatie.

Verder wilde ik: als een sensor verhoogde ventilatie triggert dan moet een daling niet direct ervoor zorgen dat de ventilatie stopt maar een configurable hold timer gaan tellen, bij mij 5 minuten. In die hold gaat de ventilatie wel iets achter draaien. Ik doe dit omdat ik merk dat het aanzuigen van meer lucht (alles komt bij mij via 1 pijp op zolder) direct een verlaging van vocht, co2 of voc veroorzaakt, die weer oploopt als ik te vroeg stop met extra ventileren.

Disclaimer: ik ben beginner met ESPHome, ESP32, YAML en ik ben al helemaal geen c++ developer, onderstaande code heb ik grotendeels met Claude eruit geperst (en gevalideerd met andere models en roestige oude matige dev skills van lang geleden).

Voor mij werkt dit nu en ben ik best tevreden, maar: er is nu heel veel functionaliteit in de c++ Lambda gekomen, wat natuurlijk een beetje voorbij gaat aan het ESPhome concept. Pak ik het te complex aan?

Opmerkingen, correcties, aanvullingen en alles wat er tussen zit meer dan welkom.

Edit: bugfixes, code optimalisatie en commentaren gefikst

Edit2: Nu met een configureerbare day/night mode waarin naar wens de auto high speed en hold speed gedurende de dag en nacht anders gezet kunnen worden. Omdat mijn Orcon boven de 50% redelijk hoorbaar is in een stil huis vind ik dat gedurende de nacht minder acceptabel.

Edit3: meer bugfixes, er stond oude foute code op de sensors in de on_value.

code:

esphome:
  name: orcon
  friendly_name: Orcon
  on_boot:
    then:
      - delay: 15s
      # After reboot >> Auto mode
      - select.set:
          id: ventilation_manual_control
          option: "AUTO"
      - script.execute: evaluate_air_quality

esp32:
  board: esp32dev
  framework:
    type: esp-idf
    
logger:
  level: DEBUG

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  ap:
    ssid: "Orcon_Fallback"
    password: !secret wifi_password

api:
  encryption:
    key: !secret api_encryption_key

ota:
  - platform: esphome
    password: !secret ota_password
  

captive_portal:

time:
  - platform: homeassistant
    id: homeassistant_time

substitutions:
  # Night mode configuration
  night_mode_start: 22       # hour in 24h format, start of night
  night_mode_end: 7          # hour in 24h format, end of night
  
  # Thresholds for sensors
  voc_threshold: "200"
  co2_threshold: "800" 
  humidity_threshold: "60"
  nox_threshold: "5"
  
  # Fan speeds in auto mode
  fan_speed_high_day: "40" # Fan speed when triggered by sensor thresholds during day window
  fan_speed_high_night: "30" #Fan speed when triggered by sensor thresholds during night window
  fan_speed_hold_day: "35" # Fanspeed when in Hold mode during day window
  fan_speed_hold_night: "25" # Fanspeed when in Hold mode during day window
  fan_speed_low: "15"  # Default idle speed

  # Fan speeds in manual mode
  manual_idle: "15"
  manual_low: "35"
  manual_medium: "55"
  manual_high: "85"
  
   # Timing (seconds)
  hold_time_seconds: "300"     # hold duration after high state
  cooldown_seconds: "30"       # min seconds between evaluations

# Global vars for auto mode
globals:
  - id: fan_hold_until
    type: time_t
    initial_value: '0'
  - id: last_evaluation_time
    type: time_t
    initial_value: '0'
  - id: current_target_speed
    type: int
    initial_value: '15'
  - id: auto_mode_active
    type: bool
    initial_value: 'true'

# Select function for manual control in Home Assistant and HomeKit (exported via HomeBridge)
select:
  - platform: template
    name: "Manual Control"
    id: ventilation_manual_control
    optimistic: true 
    options:
      - "UIT"
      - "AUTO"
      - "RUST"
      - "LAAG"
      - "MEDIUM"
      - "HOOG"
    initial_option: "RUST"
    icon: "mdi:fan"

    on_value:
      - logger.log:
          format: "Manual control changed to: %s"
          args: ['x.c_str()']
          level: INFO
      - script.execute: evaluate_air_quality

status_led:
  pin:
    number: GPIO33

# From V1.4.0 The Sensor pins on the Open AIR Mini are swapped. Correct example is below:

uart:
#UART For Sensor 2
  - rx_pin: GPIO13
    tx_pin: GPIO12
    baud_rate: 9600
    id: uart_sensor_2
#UART For Sensor 1
  - rx_pin: GPIO25
    tx_pin: GPIO26
    baud_rate: 9600
    id: uart_sensor_1

i2c:
#I2C For Sensor 2
  - id: i2c_sensor_2
    sda: GPIO19
    scl: GPIO18
    scan: false
    frequency: 400kHz
#I2C For Sensor 1
  - id: i2c_sensor_1
    sda: GPIO16
    scl: GPIO4
    scan: false
    frequency: 400kHz

script:
  - id: evaluate_air_quality
    mode: single
    then:
      - lambda: |-
          auto now = id(homeassistant_time).now();
          auto ts = now.timestamp;
          std::string current_mode = id(ventilation_manual_control).state;

          ESP_LOGD("air_quality", 
            "Evaluation start: VOC=%.0f CO2=%.0f RH=%.0f NOx=%.0f",
           id(sgp4x_voc_index).state,
           id(scd4x_co2).state,
           id(sht4x_air_humidity).state,
           id(sgp4x_nox_index).state);

          // === DAY/NIGHT PROFILE ===
          int current_hour = now.hour;
          bool is_night;
          if (${night_mode_start} < ${night_mode_end}) {
            is_night = (current_hour >= ${night_mode_start} && current_hour < ${night_mode_end});
          } else {
            // night passes midnight (e.g. 22 -> 07)
            is_night = (current_hour >= ${night_mode_start} || current_hour < ${night_mode_end});
          }

          int high_speed = is_night ? ${fan_speed_high_night} : ${fan_speed_high_day};
          int hold_speed = is_night ? ${fan_speed_hold_night} : ${fan_speed_hold_day};

          ESP_LOGI("air_quality", "Profile active: %s (high=%d%%, hold=%d%%)",
                   is_night ? "NIGHT" : "DAY", high_speed, hold_speed);

          // === MANUAL MODES ===
          if (!id(auto_mode_active)) {
            int manual_speed = 0;
            if (current_mode == "UIT") manual_speed = 0;
            else if (current_mode == "RUST") manual_speed = ${manual_idle};
            else if (current_mode == "LAAG") manual_speed = ${manual_low};
            else if (current_mode == "MEDIUM") manual_speed = ${manual_medium};
            else if (current_mode == "HOOG") manual_speed = ${manual_high};

            if (id(current_target_speed) != manual_speed ||
                (manual_speed == 0 && id(fan_motor).state) ||
                (manual_speed > 0 && !id(fan_motor).state)) {

              ESP_LOGI("manual_control", "Manual mode '%s' - setting fan to %d%%",
                      current_mode.c_str(), manual_speed);

              if (manual_speed == 0) {
                auto call = id(fan_motor).make_call();
                call.set_state(false);
                call.perform();
              } else {
                auto call = id(fan_motor).turn_on();
                call.set_speed(manual_speed);
                call.perform();
              }
              id(current_target_speed) = manual_speed;
            }
            return;
          }

          // === AUTO MODE ===
          ESP_LOGD("air_quality", "AUTO mode active");

          // Reset only if current target is not one of the valid AUTO values
          if (id(current_target_speed) != ${fan_speed_low} &&
              id(current_target_speed) != high_speed &&
              id(current_target_speed) != hold_speed) {
            ESP_LOGI("air_quality", "Switch to AUTO - fan to %d%% (clean start)", ${fan_speed_low});
            auto call = id(fan_motor).turn_on();
            call.set_speed(${fan_speed_low});
            call.perform();
            id(current_target_speed) = ${fan_speed_low};
            id(fan_hold_until) = 0;  // reset any old hold timer
          }

          // cooldown check
          if (ts - id(last_evaluation_time) < ${cooldown_seconds}) {
            ESP_LOGV("air_quality", "Cooldown active, evaluation skipped");
            return;
          }
          id(last_evaluation_time) = ts;

          // read sensor values
          float voc = id(sgp4x_voc_index).state;
          float co2 = id(scd4x_co2).state;
          float humidity = id(sht4x_air_humidity).state;
          float nox = id(sgp4x_nox_index).state;

          if (isnan(voc) || isnan(co2) || isnan(humidity) || isnan(nox)) {
            ESP_LOGW("air_quality", "One or more sensors have invalid values");
            return;
          }

          // threshold check
          bool voc_high = (voc > ${voc_threshold});
          bool co2_high = (co2 > ${co2_threshold});
          bool humidity_high = (humidity > ${humidity_threshold});
          bool nox_high = (nox > ${nox_threshold});
          bool any_high = voc_high || co2_high || humidity_high || nox_high;

          ESP_LOGD("air_quality", "Thresholds: VOC %s (%.0f>%s) CO2 %s (%.0f>%s) RH %s (%.0f>%s) NOx %s (%.0f>%s)",
                   voc_high ? "HIGH" : "ok", voc, "${voc_threshold}",
                   co2_high ? "HIGH" : "ok", co2, "${co2_threshold}",
                   humidity_high ? "HIGH" : "ok", humidity, "${humidity_threshold}",
                   nox_high ? "HIGH" : "ok", nox, "${nox_threshold}");

          int current_speed = id(current_target_speed);

          if (any_high) {
            if (current_speed != high_speed) {
              std::string high_sensors = "";
              if (voc_high) high_sensors += "VOC(" + to_string((int)voc) + ") ";
              if (co2_high) high_sensors += "CO2(" + to_string((int)co2) + ") ";
              if (humidity_high) high_sensors += "RH(" + to_string((int)humidity) + "%) ";
              if (nox_high) high_sensors += "NOx(" + to_string((int)nox) + ") ";

              ESP_LOGI("air_quality", "Sensors too high: %s - fan to %d%%",
                       high_sensors.c_str(), high_speed);

              auto call = id(fan_motor).turn_on();
              call.set_speed(high_speed);
              call.perform();
              id(current_target_speed) = high_speed;
              id(fan_hold_until) = 0;
            }
          } else {
            if (current_speed == high_speed) {
              ESP_LOGI("air_quality", "Sensors normal - start %d min hold at %d%%",
                       ${hold_time_seconds}/60, hold_speed);
              auto call = id(fan_motor).turn_on();
              call.set_speed(hold_speed);
              call.perform();
              id(current_target_speed) = hold_speed;
              id(fan_hold_until) = ts + ${hold_time_seconds};
            } else if (current_speed == hold_speed) {
              if (ts >= id(fan_hold_until)) {
                ESP_LOGI("air_quality", "Hold done - fan to %d%%", ${fan_speed_low});
                auto call = id(fan_motor).turn_on();
                call.set_speed(${fan_speed_low});
                call.perform();
                id(current_target_speed) = ${fan_speed_low};
              } else {
                long time_left = id(fan_hold_until) - ts;
                ESP_LOGD("air_quality", "Hold active - %ld sec left", time_left);
              }
            }
          }

sensor:

  - platform: pulse_counter #reports the fan tacho
    pin: GPIO14
    unit_of_measurement: "rpm"
    name: 'Fan Tacho'
    id: orcon_rpm
    update_interval: 5s
    
  - platform: wifi_signal # Reports the WiFi signal strength/RSSI in dB
    name: "WiFi Signal dB"
    id: wifi_signal_db
    update_interval: 30s
    entity_category: "diagnostic"
    device_class: "signal_strength"

  - platform: copy # Reports the WiFi signal strength in %
    source_id: wifi_signal_db
    name: "WiFi Signal Percent"
    filters:
      - lambda: return min(max(2 * (x + 100.0), 0.0), 100.0);
    unit_of_measurement: "%"
    entity_category: "diagnostic"
    device_class: "signal_strength"

  - platform: sht4x
    i2c_id: i2c_sensor_1
    # check for need of co2 heater, these are conservative values
    #heater_max_duty: 0.01
    #heater_power: Low
    #heater_time: Short
    update_interval: 30s

    temperature:
      name: "SHT4x Temperature"
      id: sht4x_air_temperature
      accuracy_decimals: 2
      state_class: measurement
      device_class: temperature
      # No delta filters and on_value trigger, sensor not part of automation

    humidity:
      name: "SHT4x Humidity"
      id: sht4x_air_humidity
      accuracy_decimals: 2
      state_class: measurement
      device_class: humidity
      # Trigger central evaluation at new value that is >2%
      filters:
        - delta: 2%      
      on_value:
        - script.execute:
            id: evaluate_air_quality

  - platform: sgp4x
    i2c_id: i2c_sensor_1
    update_interval: 30s
    compensation:
      temperature_source: sht4x_air_temperature
      humidity_source: sht4x_air_humidity

    voc:
      name: "SGP4x VOC Index"
      id: sgp4x_voc_index
      state_class: measurement
      device_class: volatile_organic_compounds
      # Trigger central evaluation at new value that is >5%
      filters:
        - delta: 5%  
      on_value:
        - script.execute:
            id: evaluate_air_quality

    nox:
      name: "SGP4x NOx Index"
      id: sgp4x_nox_index
      state_class: measurement
      device_class: nitrous_oxide
      # Trigger central evaluation at new value that is >2%
      filters:
        - delta: 2%  
      on_value:
        - script.execute: 
            id: evaluate_air_quality

  - platform: scd4x
    i2c_id: i2c_sensor_1
    update_interval: 30s

    co2:
      name: "SCD4x CO2"
      id: scd4x_co2
      state_class: measurement
      device_class: carbon_dioxide
      # Trigger central evaluation at new value that is >25ppm
      filters:
        - delta: 25    
      on_value:
        - script.execute: 
            id: evaluate_air_quality

    temperature:
      name: "SCD4x Temperature"
      id: scd4x_temperature
      accuracy_decimals: 2
      state_class: measurement
      device_class: temperature
      # No delta filters and on_value trigger, sensor not part of automation

    humidity:
      name: "SCD4x Humidity"
      id: scd4x_humidity
      accuracy_decimals: 2
      state_class: measurement
      device_class: humidity
      # No delta filters and on_value trigger, sensor not part of automation

output:
  - id: orcon_fan
    platform: ledc
    pin: GPIO15
    inverted: true

# Slow rise of values -due to delta- may cause no triggering of evaluation, so running every 2 minutes regardless
interval:
  - interval: 2min
    then:
      - script.execute:
          id: evaluate_air_quality
          trigger_source: "watchdog"

fan:
  - id: fan_motor
    name: "Fan"
    platform: speed
    output: orcon_fan

[ Voor 15% gewijzigd door Odie op 11-09-2025 16:16 . Reden: Nog een bugfix ]

[Tarquin]

djuro499 schreef op zaterdag 6 september 2025 @ 11:33:
[...]
Zou je kunnen uitleggen hoe de Open AIR mini precies werkt i.c.m. een perilex schakelaar? Werkt de override van beide kanten en kan je b.v. de schakelaar gebruiken als de wifi of HA uitvalt?

Voor zover ik weet: Gewoon niet.

Ik zit te kijken naar Silent/Reno met perilex (bv. the last resort of als ik ga verhuizen) of naar de gewone randaarde variant als er geen toegevoegde waarde is.
Nog een punt, ik probeer zo veel mogelijk ethernet te gebruiken, maar met de valve's ben ik sowieso afhankelijk van de wifi.

Perilex werd gebruikt om oude boxen te regelen. Ik weet het niet zeker, maar het zou me niets verbazen als ze gewoon direct op de spoelen van de motor zijn aangesloten, want de echte ouderwetse systemen hebben natuurlijk geen enkele electronische regeling.

Nieuwe boxen kunnen een motor traploos regelen.
De Open Air gaat daar nog overheen door er wifi besturing aan toe te voegen.

Een perilex is dan echt niet meer nodig. Als je een standaard box koopt zit er meestal een afstandsbediening bij.
En sturing via OpenAir gaat nog beter, omdat je hem kunt programmeren om te reageren op vochtpercentages, op tijden en op meerdere knoppen.

De afstandsbediening die je bij een box krijgt werkt niet met OA. Reden is dat OA de hele printplaat vervangt, inclusief de radio-ontvanger van de afstandsbediening.
Als HA uitvalt gaat de OpenAir naar een 'disconnected mode'. Het is programmeerbaar wat hij dan doet.
Hij kan bv gewoon basic op vochtigheidslevels reageren: veel vocht=hard draaien.
Wel heeft de OpenAir een web-interface. In geval van nood kun je er naartoe met een browser en zelf de instellingen & fanspeed veranderen.

Echter je wilt wel zsm je HA weer aan de praat krijgen, dat klopt.

[mrwiggs]

Kan het kloppen dat dit schroefgaatje op de verkeerde plek zit?

[Caelorum]

In het geval van perilex komt ook nog bij dat de indeling van de stekkerdoos anders is per merk. Even een Duco perilex box aansluiten op een doos waar voorheen een Orcon zat gaat dus niet werken. Zal je eerst de stekkerdoos open moeten maken en twee of drie draadjes anders moeten lussen.
Perilex zelf heeft namelijk wel een standaard, maar dat is voor vermogen aanleveren in de keuken aan een kookplaat bijv. Voor ventilatieboxen wordt het gebruikt als handige interface voor regeling met een driestandenschakelaar en dan gaan blijkbaar alle standaarden overboord.

En als je het dan toch al open moet maken, waarom niet gewoon meteen die doos vervangen voor een reguliere stekkerdoos en de driestandenschakelaar van de muur halen en op die plek een draadloos bedieningspaneel plaatsen? Heb ik hier in ieder geval wel gedaan en nog geen moment spijt van gehad.

[nairolf]

mrwiggs schreef op donderdag 11 september 2025 @ 14:44:
Kan het kloppen dat dit schroefgaatje op de verkeerde plek zit?

[Afbeelding]

Dat had ik inderdaad ook. In de fotos op GitHub lijkt hij ook op een andere locatie te zitten.

---

@The_ Mad_Ping heb je nog tijd om mijn vragen te beantwoorden? Onder andere over bovenstaande schroefgas, maar ook over de firmware: Ik zou namelijk graag een eigen ESPHome firmware maken en erop zetten, maar het apparaat wordt helaas niet herkend door ESPHome device builder..

[Odie]

Tarquin schreef op donderdag 11 september 2025 @ 14:31:
[...]


Voor zover ik weet: Gewoon niet.

Volgens mij ligt dat aan je systeem. Bij Orcon dient de perilex simpelweg om een stand te signaleren. Drie pinnen voeren de L, N en PE aan en twee pinnen signaleren afwijking van 'laag' naar 'midden' en 'hoog' door stroom van L op een van beide pinnen te zetten. Die komt binnen op de Orcon controller.

Op de controller zit 'gewoon' de motor met een eigen L+N aansluiting en een motor-controller kabel zoals ik die ook in mijn RF versie had waar een 0-10v of PWM signaal wordt gezet en waar je een tacho op terug leest.

Aangezien de OpenAir die hele controller vervangt zou deze versie dus ook gewoon geschikt zijn voor OpenAir: je gooit de Perilexstekker, de driestanden schakelaar en de Orcon controller bij het grof vuil, sluit een normale 230V stekker op de OpenAir aan en prikt de motor met voeding en aansturing ook op de OpenAir.

Met deze oplossing is de Perilex serie ook geschikt voor RF, wat wel blijkt uit de RF ontvanger die er ook in lijkt te zitten.

*note: tot zover de theorie, gebaseerd op de MVS-15-xxxP handleiding https://community.homey.a...met-perilex-stekker/29653

Maar ik had vroeger een MV die middels perilex keihard de motor aanstuurde door de 230V op een andere set windingen te zetten. Niets traploos aan. Het zal dus erg aan de leeftijd en merk van je box liggen. De hamvraag: wat voor soort motor zit er in je box, de rest is bijvangst.

[Odie]

Caelorum schreef op donderdag 11 september 2025 @ 15:04:
En als je het dan toch al open moet maken, waarom niet gewoon meteen die doos vervangen voor een reguliere stekkerdoos en de driestandenschakelaar van de muur halen en op die plek een draadloos bedieningspaneel plaatsen? Heb ik hier in ieder geval wel gedaan en nog geen moment spijt van gehad.

Dat kan dus alleen als je systeem geen directe koppeling tussen de driestanden schakelaar heeft qua voeding, oudere systemen hebben dat wel zijn niet niet geschikt om later te retrofitten met RF en variabele aansturing.

[Caelorum]

@Odie hoe bedoel je dit? In mijn geval gingen alle kabels naar de badkamer waar de box hing en van daaruit de voeding naar de driestandenschakelaar een verdieping lager, om weer drie voedingsdraden terug te krijgen. Elk van die waren op een aparte ingang van de box aangesloten. (De box kwam uit 1989 en was echt een enorm oud ding. Ook rechtstreeks 230v op de goede ingang voor een andere snelheid).

In zo'n systeem krijgt de box wel enkel voeding vanuit de driestandenschakelaar, maar kan je deze ook vrij eenvoudig compleet ombouwen.

En mocht het draad niet eerst via de goede ruimte gaan kan je ook vanaf de driestandenschakelaar 1 van de draden opnieuw trekken en direct doorlussen.

[ Voor 9% gewijzigd door Caelorum op 11-09-2025 22:10 ]

[Odie]

Er zijn twee manieren om een motor op verschillende snelheden aan te sturen: via een stuursignaal (meestal 0-10v of een pwm signaal dat de motor zelf vertaalt in een traploze snelheid via spannings- of frequentie regeling) of door de 230v direct naar de motor te sturen maar naar gelang de wenste snelheid een andere set windingen aan te spreken (Dahlander- of meerwikkelmotor). De eerste methode is traploos, de tweede niet.

MVs van het eerste type zijn makkelijk te converteren van perilex aansluiting met driestanden schakelaar naar iets traploos en draadloos, de tweede niet.

Of je dus kan ombouwen hangt heel erg af van de leeftijd van de box en hoe hij intern werkt. Van de Orcon MVS serie weet ik zeker dat je makkelijk om kunt met minimale aanpassingen omdat bij de perilex uitvoering de keuze simpelweg vertaald wordt door de controller naar een PWM signaal op de motor. Controller eruit, Open Air erin, standaars 230v stekker eraan en klaar.