[RSS] Home

Let op: Tweakers stopt per 2023 met Tweakblogs. In dit artikel leggen we uit waarom we hiervoor hebben gekozen.

DIY Modbus naar Wifi Bridge

Door ronaldmathies op donderdag 16 december 2021 16:42 - Reacties (4)
Categorie: -, Views: 6.141

Introductie


Een tijd geleden had ik een post met als titel "Meten is weten! De warmtepomp". Dit keer heb ik hier eigenlijk een vervolg op maar omdat het toepasbaar is op verschillende soorten apparaten met een Modbus interface houd ik het verhaal wat meer generiek.

Mijn warmtepomp is van het type Mitsubishi (specifiek binnenunit: ERSC-VM2CR2, en buitenunit is een PUHZ-SHW140 YHA). Deze kan op verschillende manieren uitgelezen worden maar op mijn lijstje stond al meer dan een jaar om een Procon MelcoBEMS MINI A1M aan te sluiten. Dit is een klein apparaatje wat een modbus interface toevoegt.

Echter, modbus heeft als nadeel dat het bedraad is en dat kwam mij niet handig uit. Ik wilde dus een oplossing vinden waarbij ik de modbus data beschikbaar kon stellen op mijn interne netwerk. Zodat ik deze kan uitlezen via een Python script wat bijvoorbeeld binnen een Docker container draait.

Om dit mogelijk te maken had ik het volgende idee, de modbus sluit ik aan op een ESP8266, en die heeft een API beschikbaar waarbij deze continue de vertaling doet tussen HTTP en Modbus.

Voordeel is, alle software eromheen zoals mijn python script hoeft alleen maar HTTP te kunnen doen, en de ESP haalt de data op, en vertaald dit terug naar een Json structuur.

We proberen hier een aantal vragen te beantwoorden:
  • Hoe een Modbus interface aansluiten op een ESP8266?
  • Software om de vertaling te doen tussen Modbus en HTTP
  • De API gebruiken om registers uit te lezen

Hoe een Modbus interface aansluiten op een ESP8266?


De ESP8266 kan standaard niet met Modbus communiceren. Dit komt mede omdat modbus op een compleet ander voltage bereik werkt dan een ESP8266.

Om dit probleem op te lossen voegen we een module toe die dit probleem oplost. Ik zelf heb gebruik gemaakt van een module met een Max485, deze modules kosten meestal rond de drie euro.



Daarnaast hebben we natuurlijk een ESP8266 nodig, ik zelf gebruik de NodeMCU 12E, de reden dat ik deze gebruik heeft er meer mee te maken dat ik ooit een redelijke hoeveelheid van deze modules in één keer had gekocht.



Om de twee modules aan elkaar aan te sluiten kan het volgende schema gebruikt worden:
  • Max485->VCC ---> ESP->VIN
  • Max485->GND ---> ESP->GND
  • Max485->DI ---> ESP->TX
  • Max485->DE ---> ESP->D2
  • Max485->RE ---> ESP->D2
  • Max485->RO ---> ESP->RX
Dat de DE en RE beide aan D2 aangesloten zijn klopt.


Software om de vertaling te doen tussen Modbus en HTTP


Om het geheel werkend te krijgen hebben we ook nog wat software nodig. In dit geval is er niet echt een kant en klaar stukje software te downloaden. Echter is de software niet heel groot of complex dus kunnen we het zelf maken. Als je alle blokken code hieronder kopieert en bij elkaar plakt in een enkel bestand heb je alles compleet. Ik heb het even in stukken gehakt zodat het wat makkelijker is om te bespreken wat welk deel doet.


code:
1
2
3
4
5
6

#include <ModbusRtu.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ESP8266WebServer.h>
#include <ArduinoJson.h>


Het bovenstaande deel zijn de standaard Arduino imports. De meeste zijn direct te downloaden via de Manage Libraries functie van de Arduino. De enige die daarin niet staat is de ModbusRtu.h bibliotheek. Deze moest ik handmatig downloaden van de volgende repository:

code:
1

https://github.com/smarmengol/Modbus-Master-Slave-for-Arduino


Download de zip en pak deze uit in de libraries map van je Arduino IDE (bij mij staat dit in mijn ~/Documents/Arduino/Libraries/ ).

code:
1
2
3
4
5
6
7

#define ENABLE_DEBUG true

#if ENABLE_DEBUG
  #define DEBUG_log(...) Serial.printf((const char *)__VA_ARGS__);
#else
  #define DEBUG_log(...) ((void) 0)
#endif


Een handigheid om makkelijk alle debug logging aan / uit te zetten.

code:
1
2
3

#define WIFI_HOSTNAME "ProconA1Bridge"
#define WIFI_SSID     "[MYSSID]
#define WIFI_PASSWORD "[MYPASSWORD]"


Vul hier je SSID en PASSWORD in van je WiFi netwerk, let op dat dit wel een 2,4Ghz Wifi netwerk is. Verder kan je hier eventueel een HOSTNAME opgeven, zodat je ESP8266 een bekende naam heeft op het netwerk.

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ESP8266WebServer server(80);

Modbus master(0, 0, D2);
  
void setup() {
  Serial.begin(9600);
  Serial.println("Test");
  DEBUG_log("\nInitializing");
  master.begin(9600);
  master.setTimeOut(1000);

  setupWiFi();
  setupApi();
}


We zetten de seriële poort op 9600 baud, dit heeft te maken met dat mijn Modbus aansluiting standaard op 9600 baud staat. Bekijk de documentatie van jouw apparaat waar deze op ingesteld staat. Het is belangrijk dat zowel de Serial.begin als de master.begin dezelfde baud rate hebben omdat beide dezelfde tx / rx pins gebruiken van je ESP8266.

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

void setupWiFi() {
  DEBUG_log("Connecting with WiFi network\n");
  WiFi.setHostname(WIFI_HOSTNAME);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    DEBUG_log("Connection Failed! Rebooting...\n");
    delay(5000);
    ESP.restart();
  }
  
  DEBUG_log("WiFi connection established\n");
  DEBUG_log("Local IP Address:");
  IPAddress ipAddress = WiFi.localIP();
  DEBUG_log("%d.%d.%d.%d\n", ipAddress[0], ipAddress[1], ipAddress[2], ipAddress[3]);
}

void setupApi() {
  DEBUG_log("Initializing HTTP Web Server\n");
  server.on("/", handleGet);
  server.begin();
}


De bovenstaande code initialiseert het WiFi netwerk, en start de HTTP webserver op, alle requests die binnenkomen op / zullen doorverwezen worden naar de handleGet methode.

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void handleGet() {
  StaticJsonDocument<1024> doc;

  int _time = -1, _slave = -1, _function = -1;
  int _registerIdx = 0;
  String _registers[32];
  for (int i = 0; i < server.args(); i++) {
    if (server.argName(i) == "s") {
      _slave = server.arg("s").toInt();
      DEBUG_log("Slave: %d\n", _slave);
    } else if (server.argName(i) == "t") {
      _time = server.arg("t").toInt();
      DEBUG_log("Time: %d\n", _time);
    } else if (server.argName(i).startsWith("r")) {
      _registers[_registerIdx] = server.arg(server.argName(i));
      DEBUG_log("Register entry: %s\n", _registers[_registerIdx]);
      _registerIdx++;
    }
  }


Het eerste deel van de code kijkt of je alle argumenten hebt meegegeven die nodig zijn om een uitlees actie te kunnen uitvoeren. Al deze argumenten worden wanneer debug logging aan staat naar de seriële poort weggeschreven zodat je deze in de console van je Arduino IDE kan terug zien,.

Wanneer je niet alle argumenten mee hebt gegeven die noodzakelijk zijn dan zal dit resulteren in een Json object met een error code:

code:
1
2
3
4
5
6
7

  if (_slave == -1) {
    doc["error"] = "Slave (param: s) has not been specified.";
  } else if (_time == -1) {
    doc["error"] = "Time (param: t (in ms)) has not been specified.";
  } else if (_registers[0] == "") {
    doc["error"] = "Register/Number of elements (param: r[i]) has not been specified.";
  }


Dit ziet er dan als volgt uit:

code:
1

{"error":"Slave (param: s) has not been specified."}


Wanneer er geen fouten zijn ontdekt dan zal de programmatuur de gevraagde registers proberen uit te lezen:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

  if (!doc.containsKey("error")) {
    for (int idx = 0; idx < _registerIdx; idx++) {

      int _start_pos = 0;
      int _end_pos = _registers[idx].indexOf(":");
      int _function = _registers[idx].substring(_start_pos, _end_pos).toInt();

      _start_pos = _end_pos + 1;
      _end_pos = _registers[idx].indexOf(":", _start_pos);
      int _start = _registers[idx].substring(_start_pos, _end_pos).toInt();

      _start_pos = _end_pos + 1;
      int _length =  _registers[idx].substring(_start_pos).toInt();
      DEBUG_log("Decoded registry entry, function: %d, start: %d,  length: %d\n", _function, _start, _length);

      uint16_t _response[16];
      int _state = 0;
      while(_state != 2) {
        delay(_time);
        switch (_state) {
          case 0: // Request
            modbus_t telegram;
            telegram.u8id = _slave; // slave address
            telegram.u8fct = _function; // function code (this one is registers read)
            telegram.u16RegAdd = _start; // start address in slave
            telegram.u16CoilsNo = _length; // number of elements (coils or registers) to read
            telegram.au16reg = _response; // pointer to a memory array in the Arduino
            master.query(telegram); // send query (only once)
            _state++;
            break;
          case 1: // Response
            master.poll(); // check incoming messages
            if (master.getState() == COM_IDLE) {
              JsonVariant _functionObject = doc[String(_function)];
              if (_functionObject.isNull()) {
                _functionObject = doc.createNestedObject(String(_function));
              }
              for (int idx = 0; idx < _length; idx++) {
                _functionObject[String(_start + idx)] = _response[idx];
              }
              _state++;
            }
            break;
        }
      }
    }

  }
  
#if ENABLE_DEBUG
  serializeJson(doc, Serial);
#endif

  String output;
  serializeJson(doc, output);
  server.send(200, F("application/json"), output);
}


Als dit lukt dan zal er een resultaat gegeven worden van alle gevraagde registers en de bijbehorende waarden:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13

{
  "4": {
    "32":0,
    "56":3050,
    "57":3050
  },
  "3": {
    "25":1,
    "26":2,
    "27":1,
    "37":0
  }
}




De API gebruiken om registers uit te lezen



Deze is redelijk simpel, de volgende argumenten moeten meegegeven worden:
  • s - Slave ID, dus het ID van het apparaat waarmee je wilt communiceren.
  • t - Timing, tijdens de communicatie met het modbus apparaat moeten geregeld vertragingen aangehouden worden, met deze timing argument kan je in milliseconden aangeven hoeveel vertraging er moet zijn.
  • r[x] - Functie, register ene aantal, met dit argument geef je aan met welke functie wat het start register is wat je wilt uitlezen en hoeveel register posities je in totaal wilt uitlezen. Het aantal posities is in de code gemaximaliseerd op 16 posities tegelijk. Het aantal start registers is gemaximaliseerd op 10.
Om even een voorbeeld te geven:

code:
1

http://192.168.1.1/?s=1&t=50&r1=4:32:1&r2=4:56:3&r3=3:60:5&r4=3:173:1


Heeft de volgende argumenten, de slave Id is ingesteld op "1".

We hebben een timing ingesteld van 50ms, dit getal werkt toevallig bij mij consistent,. Houd er rekening mee dat dit voor verschillende apparaten anders kan zijn. Als je niet de waarden krijg die je verwacht dan kan het handig zijn om dit gedaan iets te verhogen naar bijvoorbeeld 100, 200 of 300.

Als laatste geven we een aantal functie, start registers en lengte argumenten op:

r1 is functie 4, start register 32 met een lengte van 1, dus alleen register 32.
r2 is functie 4, start register 56 met een lengte van 3, dus registers 56, 57 en 58 zullen uitgelezen worden.
r3 is functie 3, start register 60 met een lengte van 5, dus 60, 61, 62, 63 en 64.
r4 is functie 3, start register 173 met een lengte van 1, dus alleen 173.

Als resultaat krijg ik in dit geval:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

{
  "4": {
    "32":0,
    "56":3050,
    "57":3050,
    "58": 10
  },
  "3": {
    "60":1,
    "61":2,
    "62":1,
    "63":0,
    "64":0,
    "173":0
  }
}


Ik hoop dat het allemaal een beetje duidelijk is zo.

Meten is weten! De Warmtepomp

Door ronaldmathies op woensdag 3 oktober 2018 07:44 - Reacties (7)
Categorie: -, Views: 10.773

Introductie


"Meten is weten", dat is toch wel een veel gebruikt gezegde wanneer het aankomt op het afstellen van apparatuur of om te weten hoe goed apparatuur functioneert.

Met de ontwikkelingen van de laatste jaren is de hoeveelheid van aanwezige apparatuur in huis alleen maar toegenomen, en niet alleen toegenomen ze zijn vaak ook complexer geworden. Apparatuur is steeds vaker intelligenter en beter configureerbaar wat ook betekend dat het neerplempen van een apparaat vaak niet meer afdoende is.

Maar hoe kom je nou te weten of het apparaat goed geconfigureerd is in jouw omstandigheden, hoe zorg je ervoor dat hij optimaal presteert op de momenten dat je er wel of niet aanwezig bent, en hoe hou je rekening met de omstandigheden waarin het apparaat moet functioneren.

Om een simpel voorbeeld te geven, een WTW Ventilatie, voor degene die het niet kennen, een WTW unit zuigt lucht aan vanuit het huis en transporteert deze lucht naar buiten. Aan de andere kant zuigt het lucht aan van buiten en transporteert dit juist naar binnen. Tijdens dit proces probeert de unit de warmte van de afgezogen lucht zoveel mogelijk over te brengen naar de toe te voegen lucht.

Hoe je hiermee omgaat is in de zomer vaak volledig anders als in de winter. In de zomer wil je wel lucht verversen maar je wilt juist geen warmte overbrenging hebben, je wilt koelere lucht naar binnen krijgen. En in de winter wil je juist wel zoveel mogelijk warmte overbrenging hebben om zoveel mogelijk aan stook kosten te besparen.

Dit gedrag kan het apparaat vaak zelf wel redelijk bepalen, maar je kan zelf ook weer invloed uitoefenen. Bijvoorbeeld door in de winter juist niet 's nachts te gaan ventileren, dan is het buiten veel kouder en is de overbrenging juist veel lager, door meer overdag op de warmere uren te ventileren ga je veel efficiënter om met het behouden van de warmte. Maar in de zomer wil je juist wel 's nachts ventileren zodat je de koelere lucht binnen krijgt.

Dit is maar één voorbeeld en één scenario, zo zijn er voor veel meer apparaten optimalisaties te bedenken. Maar als je optimalisaties bedenkt dan moet je dit dus ook staven met metingen, want hoe weet je zeker dat wat je gedaan hebt een positief effect heeft.

Dat is waar deze blog reeks over gaat, we proberen hier een aantal vragen te beantwoorden:
  • Welk apparaat wil ik gaan meten?
  • Wat wil ik weten?
  • Hoe kan ik dit meten?
  • Hoe verzamel ik deze meetgegevens?
  • Hoe bewaar ik de resultaten van de metingen?

Disclaimer


Wat gaan we niet behandelen, hoe je een apparaat daadwerkelijk optimaliseert. Bij iedereen zijn de omstandigheden anders, er is dus geen one-size-fits-all oplossing. Daarom probeer ik hier wel de spreekwoordelijk vishengel te geven waarmee je dan hopelijk zelf kan uitpuzzelen hoe je het betreffende apparaat kan optimaliseren.

De apparaten die ik als voorbeeld zal gebruiken zijn apparaten waartoe ik toegang heb, het kan dus voor andere merken / types net anders zijn, maar hopelijk geeft deze blog voldoende houvast en inspiratie om zelf verder te kunnen uitzoeken hoe het bij jouw apparaat zit.

In bijna alle gevallen is de manier hoe ik de meetgegevens achterhaal non-intrusive, maar soms houd het ook in dat je wijzigingen moet aanbrengen aan bijvoorbeeld je meterkast. Nog niet in deze blog maar in een toekomstige blog zou dit wel kunnen.

Dit is vooropgesteld gevaarlijk werk, als je de kennis niet hebt doe het dan ook niet en vraag iemand / installateur om de wijzigingen toe te passen. De bedoeling is dat we het leuk houden en niet dat er mensen gewond raken.

Verder, als je gaat optimaliseren, hou heel goed bij wat je veranderd en wanneer. Want niets is zo vervelend als iets aanpassen om later achter te komen dat het toch geen goed idee was maar je weet ook niet meer hoe het ervoor configureer was.


Welk apparaat wil ik gaan meten?


We gaan ons nu focussen op een warmtepomp, niet geheel toevallig want dit was een vraag vanuit het Lucht/Water warmtepomp om mee te verwarmen en koelen topic.


Wat wil ik weten?


Vandaag wil ik gaan kijken naar hoe we de temperaturen kunnen verzamelen van een warmtepomp installatie.

Hierin zijn verschillende manieren om de gegevens te verzamelen, soms heb je geluk en kan je direct koppelen aan je warmtepomp door middel van bijvoorbeeld een modbus interface of bied het apparaat een directe API aan waarop je kan aansluiten. Helaas heb ik die niet en zal ik dus zelf een oplossing moeten vinden om de temperaturen te achterhalen.

De oplossing die ik bedacht had is niet heel uniek, het is een veelgebruikte manier om veel verschillende temperaturen te kunnen meten. We hebben hiervoor wel wat hardware nodig maar gelukkig vallen deze kosten enorm mee, voor rond de 15 tot 20 euro is dit allemaal wel te verzamelen.

Als eerste moeten we bepalen welke temperaturen we bijvoorbeeld willen meten, bijvoorbeeld:
  • De aanvoer en retour temperatuur tussen de warmtepomp en de rest van het systeem
  • De temperatuur van het sanitair warm water vat bovenin en onderin.
  • De temperatuur van het buffervat bovenin en onderin
  • De temperatuur van het getapte sanitair warm water
  • De aanvoer en retour temperatuur tussen het buffervat en de verwarming
  • De retour temperatuur van de verwarming naar het buffervat
Je moet natuurlijk voor jezelf bepalen hoeveel locaties je wilt meten.

Denk hierbij vooral aan locaties waar je juist sensoren in kan stoppen, vaten en leidingen hebben soms kleine gaatjes waar sensoren in kunnen, soms zitten er al sensoren in maar passen die van jezelf er nog naast.


Hoe kan ik dit meten?


Hiervoor hebben we een aantal componenten nodig, de temperatuur probes die we op specifieke plaatsen inVoor de volledigheid, dat alle linkjes verwijzen naar Banggood is gewoon meer dat je even een idee hebt wat de kosten zijn. Het zijn geen affiliate links dus ik krijg er ook niets voor. Andere mogelijke online winkels zijn bijvoorbeeld AliExpress, of als je liever op eigen bodem besteld dan kan je terecht bij bijvoorbeeld Hackerstore.nl voor de DS18B20 Probe en NodeMcu Board.

Dit is de minimale set aan componenten die we nodig hebben, dit kan je verder nog uitbreiden met een breadboard, jumperwires etc... voor als je niet meteen wilt solderen. Dit heeft als voordeel dat je wat makkelijker kan experimenteren.

https://cdn-reichelt.de/bilder/web/artikel_ws/A300/DEBO_JT_ESP8266_01.jpg

De NodeMcu Board is de controller in dit hele verhaal, het is in feite een kleine computer met WiFi ondersteuning waarop je via de pinnetjes bijvoorbeeld allerlei sensoren kan koppelen.

Mocht je voor een andere type controller kiezen zorg er dan voor dat hij voorkomt in de hardware compatibility lijst van ESPEasy. Dit houd dan wel in dat de uitleg over het flashen van de firmware op een aantal punten kan afwijken in verband met de hoeveelheid geheugen die beschikbaar is, en de pin-layout zou kunnen afwijken

Om de afwijking van de pin-layout inzichtelijk te krijgen is het handig om hiervoor documentatie op te zoeken.

De pin-layout geeft een overzicht van welke GPIO poorten matchen met de labels op het board zelf en wat de functie van de betreffende GPIO poort is:




Aansluit schema
Hierin zit het meeste werk, het aansluiten van de sensoren aan elkaar en aan de controller bord. De DS18B20 sensoren werken volgens het on-wire protocol. De technische details ga ik je besparen (deels omdat ik het zelf ook niet helemaal heb uitgezocht) maar waar het op neer komt is dat je alle sensoren door kan lussen aan elkaar.

Dit doorlussen is in onze situatie erg ideaal is, veelal is een warmtepomp installatie nogal breed opgezet, en de sensoren liggen erg verspreid over de hele installatie. Door alle sensoren aan elkaar te kunnen knopen kan je aan de ene kant van de installatie beginnen met het plaatsen van je sensoren en kan je aan de andere kant eindigen bij het controler bord, zo hoef je niet een enorme hoeveelheid aan draden aan te leggen maar is het eigenlijk één lange kerstverlichting van sensoren.


Zwart is aarde, rood is 3.3V, geel is data

De sensoren zien er anders uit als degene die ik in de boodschappenlijst heb gezet, maar ze zijn hetzelfde, binnen de buisjes van de DS18B20 probe sensoren zit niets anders als wat je hier op de breadboard ziet, alleen dan omhulst met een soort epoxy erin voor stevigheid en een langer draad aan de drie pootjes.

Het schema kan er wat verwarrend uitzien maar ik heb geprobeerd het zo simpel mogelijk weer te geven zoals je het ook qua bedrading zou doen wanneer je het niet op een breadboard doet.

Het voorbeeld is uitgewerkt op een breadboard, voor degene die hier niet zo bekend mee zijn is enige uitleg handig, hiervoor verwijs ik je graag door naar de volgende website waarin de history wordt besproken alsook hoe een breadboard nu eigenlijk werkt. Daar waar de link direct naar toe verwijst is in ieder geval het meest belangrijke onderdeel om te begrijpen van een breadboard.

Een andere manier van aansluiten is door de voedings pin van de sensor te koppelen aan de aarde, hierdoor zal de datapin als voeding gaan functioneren, dit noemen ze ook wel de parasite power mode, ikzelf heb hier geen ervaring mee, ik leerde pas later van deze variant.


Zwart is aarde, rood is 3.3V, geel is data

Verder kan dit schema uitgebreid worden met nog meer sensoren, je moet in dat geval het patroon aan de rechterkant doorzetten. Enige waar je een beetje rekening mee moet houden is de totale lengte, maak de volledige kabel niet enorm lang, het is maar 3.3Volt wat er over die kabel gaat en dat is niet heel veel, er ontstaan verliezen wat kan leiden tot sensoren die niet uitgelezen kunnen worden.

Is solderen niet echt jouw ding? kan ik mij goed voorstellen, het is ook niet mijn ding. Kijk onderaan even bij final notes hoe je de sensoren aan elkaar kan linken zonder solderen.


Hoe verzamel ik deze meetgegevens?


Nu we de bedrading in orde hebben is het tijd om de firmware op de controller in te laden. Hiervoor heb je een USB naar Micro USB kabel nodig (let even op, als je een andere ESP8266 hebt dan kan dit afwijken).

Om de sensoren uit te lezen gaan we gebruiken maken van ESPEasy, dit is een firmware die standaard vrij veel ondersteuning heeft voor verschillende sensoren, daarnaast bied ESPEasy ondersteuning voor verschillende domotica systemen als Domoticz. Je kan hiermee ook zelf rechtstreeks de sensoren uitlezen doordat ESPEasy een API aanbied die je met een standaard URL aanroep kan bevragen.

De firmware kan gedownload worden vanaf hun github pagina, download het bestand ESPEasy_mega-20181003.zip.

Wanneer je dit bestand hebt gedownload en uitgepakt hebt dan zie je onder andere de volgende bestanden staan:
  • ESP_Easy_mega-20181003_xxx.bin (firmware)
  • esptool.exe (flashtool)
  • FlashESP8266.exe (configuratie tool)
De verschillen zitten hem in hoeveel geheugen je controller heeft (in het geval van de NodeMcu is dit 4096Kb), en wat voor build het is (test, dev, normal, etc..).

Waar wij op gaan focussen is de ESP_Easy_mega-20181003_normal_ESP8266_4096.bin versie. Dit is de normale 4Mb versie die geschikt is voor de controller.

Sluit de controller aan op je computer via de USB kabel, hij hoeft hiervoor niet in de breadboard te zitten en de sensoren hoeven niet aangesloten te zijn.

Notitie: Mocht je in het vervolg process tegen problemen aanlopen probeer dan een andere USB poort op je computer, USB poorten aan de voorkant van je kast werken in mijn ervaring minder goed dan degene die rechtstreeks op je moederbord zitten.

Start nu de FlashESP8266.exe flashtool, je krijgt nu een scherm te zien waarin je een COM poort kan opgeven en een flash grootte kan selecteren.



Selecteer de COM poort, mocht je er meerdere hebben dan is het misschien handig om eerst je controller lost te koppelen en de applicatie te starten, de COM poort die je nu mist is degene waarop de controller gekoppeld is.

Selecteer de juiste juiste firmware, in ons geval de ESP_Easy_mega-20181003_normal_ESP8266_4096.bin firmware.

Als alles is ingevuld kan je op Flash drukken, je krijgt dan het onderstaande scherm te zien met de voortgang van het flashen.



Zodra het geheel klaar is kan je de controller los koppelen.


WiFi Configuratie
De controller ondersteund WiFi b/g/n, het is dus belangrijk dat dit beschikbaar is. Dus zorg dat je een 2.4Ghz netwerk in de lucht hebt. Voordeel van dit netwerk is dat het een groter bereik heeft, je WiFi access point heb je meestal niet naast je warmte pomp staan.

Wanneer je nu je controller van stroom voorziet wordt er automatisch een ad-hoc access point gestart door de controller, kijk op je computer, laptop of telefoon of je dit WiFi netwerk kan vinden, meestal staat er iets van ESP_Easy_0 in de naam. Vervolgens verbind je met dit netwerk, het wachtwoord is configesp

Eenmaal verbonden kan je je browser starten en kom je in een portaal terecht waar je de WiFi van de controller kan configureren, dit moet het WiFi netwerk zijn waar de controller zelf als client naar toe kan verbinden. Volg deze stappen in het portaal. Aan het einde krijg je de melding dat je weer kan verbinden met je eigen WiFi netwerk.

Nu de WiFi is ingeregeld is het van belang om het IP adres te achterhalen, gezien dit verschilt per gebruiker is het wat lastig om dit enduidig uit te leggen. In het algemeen kan je deze informatie terugvinden in je router of access point.


EspEasy Configuratie
Wanneer je het IP adres achterhaald hebt kan je deze gebruiken in je browser nadat je weer verbonden bent met je eigen netwerk om naar de EspEasy console te navigeren.

We kunnen nu de verschillende sensoren gaan toevoegen. Ga naar het tabblad Devices. En klik in de eerste regel op Edit.

Je krijgt dan het volgende scherm:

Selecteer uit de drop-down lijst de Environment - DS18b20 optie.

Nu wordt het scherm aangepast en kan je wat meer velden invullen. In het volgende schermvoorbeeld zie je een vulling zoals ik hem heb voor de sanitair warm water buffer boven helft.

Als je de bedrading uitgevoerd hebt zoals in het voorbeeld dan dien je GPIO-0 wat op je controller aangeduid is als D3 te selecteren. Als je dat gedaan hebt dan heb je de mogelijkheid om èèn van je sensoren te selecteren.

Nu wordt de sensor aangeduid als een serie nummer wat onhandig is, zeker omdat je niet weet welke het precies is. Een oplossing hiervoor is door eerst alle sensoren toe te voegen, en daarna èèn voor èèn de sensoren vast te houden zodat deze kan opwarmen, dan is er vanzelf èèn sensor die uitspringt qua temperatuur. Een koud glas water kan ook helpen, dit werkt dan overigens alleen bij de probe variant gezien deze beschermt zijn.

Je kan de sensor ook een naam geven, zodat het overzicht wat duidelijker is. Vergeet ook niet om de Enable checkbox aan te klikken.

Uiteindelijk eindig je als het goed is met een lijst met sensoren, zo ziet de lijst er bij mij uit:


Als je lijst compleet is en je hebt overal nette namen aan gegeven dan ben je feitelijk klaar. Je controller is nu aan het meten en houd de laatste getallen bij.


Hoe bewaar ik de resultaten van de metingen?


Dit is over het algemeen een lastiger stuk, er zijn een aantal scenario's mogelijk maar dit is deels afhankelijk van wat je al hebt qua software.

ESPEasy bied een aantal mogelijkheden, als je Domoticz of Openhab gebruikt dan kan je direct aansluiten. Ga hiervoor naar het Controllers tabblad en vul een controller in a.h.v. de optie

Als je alles wilt uitlezen via een API, dan kan je met de volgende URL alle sensor informatie opvragen en krijg je een JSON bericht terug:
code:
1

http://[IP_ADRES_CONTROLLER]/json?view=sensorupdate

Je krijgt dan een bericht wat er ongeveer zo uit ziet:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

{
  "Sensors": [
    {
      "TaskValues": [
        {
          "ValueNumber": 1,
          "Name": "Temperature",
          "NrDecimals": 2,
          "Value": 23.5
        }
      ],
      "TaskEnabled": "true",
      "TaskNumber": 1
    },
    {
      "TaskValues": [
        {
          "ValueNumber": 1,
          "Name": "Temperature",
          "NrDecimals": 2,
          "Value": 44.06
        }
      ],
      "TaskEnabled": "true",
      "TaskNumber": 2
    }
  ],
  "TTL": 20000
}


De TaskNumber komt dan overeen met de volgorde in de lijst bij devices.


Final notes?

Geen soldeer held?

Geen probleem. Ik heb ook niets gesoldeerd, ik heb aan elke sensor een kroonsteen gemaakt en deze aan èèn kant met een lijmpistool volledig vast gezet. De andere kant van de kroonsteen is de kant die ik gebruik om door te lussen:



Voordeel hiervan is dat het hierdoor makkelijker is om alles anders in te delen als je de sensoren toch op een andere plaats wilt positioneren.

Wijkt de sensor teveel af met de werkelijkheid?

Mijn ervaring tot nu toe is dat deze sensoren vrij nauwkeurig zijn, ongecalibreerd kan de sensor een afwijking hebben van 0.5c, mocht je onverhoopt toch het idee hebben dat hij teveel afwijkt dan zijn er een aantal mogelijkheden. Je kan de sensor evetueel gaan ijken:

https://www.kandrsmith.org/RJS/Misc/Thermometers/absolute_ds18b20.html
https://thecavepearlproject.org/2016/03/05/ds18b20-calibration-we-finally-nailed-it/

Als je een afwijking hebt kunnen constateren dan kan je deze correct in EspEasy invullen, hiervoor ga je weer terug naar het Devices tabblad, onderin is een Formula veld waarin je de afwijking kan opnemen. Voor uitleg over de formules verwijs ik je door naar de documentatie van EspEasy.

Inloggen

Login met je Tweakers profiel.

Recente posts

Categorieën

Er zijn nog geen categorieën beschikbaar.

Archieven

About