Homeyduino geschikt maken voor moderne ESP32 boards (C3 & C6)

Wie al wat langer met Homeyduino speelt, weet hoe leuk het is om je eigen sensoren en schakelaars aan Homey te koppelen. Een Wemos, NodeMCU of ESP-boardje, een sensor van een paar euro en ineens praat je zelfbouwproject gewoon mee in je Smart Home. Precies dat maakt Homeyduino zo leuk.

Maar zoals wel vaker bij zelfbouwprojecten zit de uitdaging in de kleine details. Je denkt: even een nieuwer ESP32 boardje pakken, sketch uploaden en klaar. Maar in plaats daarvan krijg je een berg compile errors voorgeschoteld. Niet echt het Huis van de Toekomst gevoel waar je op hoopte.

Gelukkig is de oplossing verrassend simpel. De Homeyduino library is namelijk niet per se kapot, maar gaat op sommige plekken nog uit van oudere ESP32 boards. En die hadden een andere indeling van analoge pinnen dan moderne varianten zoals de ESP32-C3 en ESP32-C6.

Wat gaat er precies mis?

In de originele Homeyduino library staat in chip.h een vaste lijst met analoge pinnen. Denk aan A0 tot en met A19. Op oudere ESP32 DevKit-achtige boards is dat meestal geen probleem.

Maar pak je een ESP32-C3, ESP32-C6 of een ander nieuwer board, dan kan het zomaar zijn dat bepaalde A-pinnen helemaal niet bestaan. Arduino probeert die pinnen dan alsnog te gebruiken, de compiler kijkt je streng aan en je project komt geen stap verder.

• Oude situatie: Homeyduino gaat uit van een vaste lijst met analoge pinnen.
• Het probleem: sommige moderne boards hebben die pinnen niet.
• Het gevolg: compile errors nog voordat je sensor iets kan meten.
• De oplossing: alleen pinnen opnemen als ze op dat board ook echt bestaan.

Waarom deze oplossing werkt

De truc zit hem in #ifdef. Daarmee zeg je tegen de compiler: gebruik deze pin alleen wanneer hij bekend is op dit board. Bestaat A7 niet? Dan wordt die regel gewoon overgeslagen. Bestaat A0 wel? Dan wordt die netjes meegenomen.

Dat klinkt misschien als een kleine aanpassing, maar dit is precies het soort oplossing waar je bij domotica blij van wordt. Niet alles opnieuw bouwen, geen ingewikkelde workarounds, maar gewoon een bestaande library nét even slimmer maken.

Of anders gezegd: Homeyduino hoeft niet langer te bepalen welk board jij mag gebruiken. Het board vertelt voortaan zelf welke pinnen beschikbaar zijn.

Stap voor stap aan de slag

Maak eerst een kopie van de originele Homeyduino library. Geef deze bijvoorbeeld de naam Homeyduino_ESP32_HVV. Zo houd je de originele versie netjes intact en kun je altijd terug wanneer iets niet werkt zoals verwacht.

De plek waar je moet zijn is gelukkig niet verstopt in een of andere mysterieuze systeemmap. Ga op je computer naar je Arduino folder en open daarna:

Open vervolgens het bestand chip.h. Dit is het bestand waarin Homeyduino probeert te herkennen met welk type board je werkt en welke pinnen daarbij horen. Precies daar gaat het bij moderne ESP32-C3 en ESP32-C6 boards vaak mis.

Pas eventueel ook library.properties aan wanneer je met een kopie van de library werkt, zodat Arduino IDE jouw aangepaste versie herkent. Controleer daarna in Arduino IDE of je het juiste board hebt geselecteerd en upload een simpele Homeyduino sketch. Werkt die? Dan kun je daarna weer verder met het echte werk: je eigen CO2 sensor, relaismodule, bewegingsmelder of ander zelfbouwproject.

Het volledige aangepaste chip.h bestand

Onderstaand vind je het volledige aangepaste chip.h bestand. Je kunt de inhoud van je huidige chip.h hiermee vervangen. Het belangrijkste verschil zit in het ESP32-gedeelte: daar wordt per analoge pin eerst gecontroleerd of deze op jouw board bestaat.

#include "Arduino.h"
#include "pins_arduino.h"

#ifndef __CHIP__
#define __CHIP__

#if defined(ARDUINO_ARCH_ESP8266)
// ESP8266
static const char* arduino_arch = "esp8266";
#elif defined(ARDUINO_ARCH_ESP32)
// ESP32
static const char* arduino_arch = "esp32";
#elif defined(ARDUINO_ARCH_AVR)
static const char* arduino_arch = "avr";
#elif defined(ARDUINO_ARCH_SAM)
// Arduino Due
static const char* arduino_arch = "sam";
#else
static const char* arduino_arch = "unknown";
#endif

static const uint8_t analog_input_map[] = {
#if defined(ARDUINO_ARCH_ESP32)
  #ifdef A0
    A0,
  #endif
  #ifdef A1
    A1,
  #endif
  #ifdef A2
    A2,
  #endif
  #ifdef A3
    A3,
  #endif
  #ifdef A4
    A4,
  #endif
  #ifdef A5
    A5,
  #endif
  #ifdef A6
    A6,
  #endif
  #ifdef A7
    A7,
  #endif
  #ifdef A8
    A8,
  #endif
  #ifdef A9
    A9,
  #endif
  #ifdef A10
    A10,
  #endif
  #ifdef A11
    A11,
  #endif
  #ifdef A12
    A12,
  #endif
  #ifdef A13
    A13,
  #endif
  #ifdef A14
    A14,
  #endif
  #ifdef A15
    A15,
  #endif
  #ifdef A16
    A16,
  #endif
  #ifdef A17
    A17,
  #endif
  #ifdef A18
    A18,
  #endif
  #ifdef A19
    A19,
  #endif
#else
  #if (NUM_ANALOG_INPUTS > 0)
    A0
  #endif
  #if (NUM_ANALOG_INPUTS > 1)
    ,A1
  #endif
  #if (NUM_ANALOG_INPUTS > 2)
    ,A2
  #endif
  #if (NUM_ANALOG_INPUTS > 3)
    ,A3
  #endif
  #if (NUM_ANALOG_INPUTS > 4)
    ,A4
  #endif
  #if (NUM_ANALOG_INPUTS > 5)
    ,A5
  #endif
  #if (NUM_ANALOG_INPUTS > 6)
    ,A6
  #endif
  #if (NUM_ANALOG_INPUTS > 7)
    ,A7
  #endif
  #if (NUM_ANALOG_INPUTS > 8)
    ,A8
  #endif
  #if (NUM_ANALOG_INPUTS > 9)
    ,A9
  #endif
  #if (NUM_ANALOG_INPUTS > 10)
    ,A10
  #endif
  #if (NUM_ANALOG_INPUTS > 11)
    ,A11
  #endif
  #if (NUM_ANALOG_INPUTS > 12)
    ,A12
  #endif
  #if (NUM_ANALOG_INPUTS > 13)
    ,A13
  #endif
  #if (NUM_ANALOG_INPUTS > 14)
    ,A14
  #endif
  #if (NUM_ANALOG_INPUTS > 15)
    ,A15
  #endif
  #if (NUM_ANALOG_INPUTS > 16)
    ,A16
  #endif
  #if (NUM_ANALOG_INPUTS > 17)
    ,A17
  #endif
  #if (NUM_ANALOG_INPUTS > 18)
    ,A18
  #endif
  #if (NUM_ANALOG_INPUTS > 19)
    ,A19
  #endif
  #if (NUM_ANALOG_INPUTS > 20)
    ,A20
  #endif
  #if (NUM_ANALOG_INPUTS > 21)
    ,A21
  #endif
  #if (NUM_ANALOG_INPUTS > 22)
    ,A22
  #endif
  #if (NUM_ANALOG_INPUTS > 23)
    ,A23
  #endif
  #if (NUM_ANALOG_INPUTS > 24)
    ,A24
  #endif
  #if (NUM_ANALOG_INPUTS > 25)
    ,A25
  #endif
  #if (NUM_ANALOG_INPUTS > 26)
    ,A26
  #endif
  #if (NUM_ANALOG_INPUTS > 27)
    ,A27
  #endif
  #if (NUM_ANALOG_INPUTS > 28)
    ,A28
  #endif
  #if (NUM_ANALOG_INPUTS > 29)
    ,A29
  #endif
  #if (NUM_ANALOG_INPUTS > 30)
    ,A30
  #endif
  #if (NUM_ANALOG_INPUTS > 31)
    ,A31
  #endif
#endif
};

static const uint8_t digital_pin_map[] = {
#if defined(ARDUINO_ESP8266_WEMOS_D1MINI)
  D0, D1, D2, D3, D4, D5, D6, D7, D8
#elif defined(ARDUINO_ESP8266_NODEMCU)
  D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10
#else
  #ifdef D0
    D0
  #endif
  #ifdef D1
    ,D1
  #endif
  #ifdef D2
    ,D2
  #endif
  #ifdef D3
    ,D3
  #endif
  #ifdef D4
    ,D4
  #endif
  #ifdef D5
    ,D5
  #endif
  #ifdef D6
    ,D6
  #endif
  #ifdef D7
    ,D7
  #endif
  #ifdef D8
    ,D8
  #endif
  #ifdef D9
    ,D9
  #endif
  #ifdef D10
    ,D10
  #endif
  #ifdef D11
    ,D11
  #endif
  #ifdef D12
    ,D12
  #endif
  #ifdef D13
    ,D13
  #endif
  #ifdef D14
    ,D14
  #endif
  #ifdef D15
    ,D15
  #endif
  #ifdef D16
    ,D16
  #endif
  #ifdef D17
    ,D17
  #endif
  #ifdef D18
    ,D18
  #endif
  #ifdef D19
    ,D19
  #endif
  #ifdef D20
    ,D20
  #endif
  #ifdef D21
    ,D21
  #endif
  #ifdef D22
    ,D22
  #endif
  #ifdef D23
    ,D23
  #endif
  #ifdef D24
    ,D24
  #endif
  #ifdef D25
    ,D25
  #endif
  #ifdef D26
    ,D26
  #endif
  #ifdef D27
    ,D27
  #endif
  #ifdef D28
    ,D28
  #endif
  #ifdef D29
    ,D29
  #endif
  #ifdef D30
    ,D30
  #endif
  #ifdef D31
    ,D31
  #endif
#endif
};

#endif

Dit lijkt misschien een flinke lap code, maar de gedachte erachter is juist heel simpel. Een ESP32-C3 of ESP32-C6 hoeft niet langer te doen alsof alle oude ESP32 analoge pinnen bestaan. Bestaat een pin niet? Dan wordt hij ook niet meegenomen. En precies daardoor voorkom je die vervelende compile errors.

Belangrijke nuance

Deze aanpassing zorgt ervoor dat Homeyduino niet meer struikelt over niet-bestaande analoge pinnen. Daarmee los je een belangrijk compile-probleem op bij moderne ESP32 boards.

Dat betekent alleen niet automatisch dat ieder ESP32 board volledig en officieel ondersteund is. Sommige boards hebben afwijkende USB-chips, andere pinlayouts of net even andere instellingen in Arduino IDE. Test dus altijd eerst met een eenvoudige sketch voordat je meteen een complete multisensor bouwt.

• ✔ In veel gevallen compileert Homeyduino hierna probleemloos.
• ✔ Pairing met Homey werkt meestal zoals je gewend bent.
• ✔ Je kunt bestaande Homeyduino projecten makkelijker naar nieuwere hardware brengen.
• ⚠ Controleer altijd de pinout van jouw specifieke ESP32 board.

Wat kun je hierna bouwen?

Nu Homeyduino weer netjes compileert op je moderne ESP32 board, gaat de leuke kant van het verhaal beginnen. Want waarom zou je stoppen bij alleen een testsketch?

• Een CO2 sensor die automatisch je mechanische ventilatie aanstuurt.
• Een deur- of raamsensor die Homey als alarmsysteem gebruikt.
• Een relaismodule waarmee je verlichting of apparaten via flows schakelt.
• Een klein ESP32 dashboard met statusinformatie uit je Smart Home.

Juist dit soort projecten maken Homeyduino zo interessant. Je bent niet afhankelijk van kant-en-klare sensoren, maar bouwt gewoon precies wat je zelf nodig hebt. Betaalbaar, leerzaam en helemaal naar eigen wens.

Conclusie

Met een kleine aanpassing in chip.h maak je Homeyduino een stuk vriendelijker voor moderne ESP32 boards zoals de ESP32-C3 en ESP32-C6. Geen eindeloze zoektocht naar vage compile errors, maar gewoon weer verder bouwen aan je eigen slimme huis.

En dat is wat mij betreft precies waar Homeyduino voor bedoeld is: bestaande techniek betaalbaar en toegankelijk maken, zodat je zelf je eigen Huis van de Toekomst kunt bouwen. Niet over tien jaar, maar gewoon vandaag al.