SmartHome im Weihnachtshaus - AZ-Delivery

Deel

0 Reacties

De Christmas House-kit heeft de Nano Microcontroller heeft slechts beperkte functies, zoals het licht aandoen via de knop naast de deur.

In deze blogpost wordt de set met behulp van een D1 mini-microcontroller omgetoverd tot een kleine smart home met WiFi-functie in kerstsfeer.

Hardware

Voor implementatie heeft u nodig:

Kersthuispakket

D1 mini-ESP8266 (andere versies ook mogelijk)

LED-kerstboomset (andere versies ook mogelijk)

Ook als Bundel beschikbaar:

SmartHome in de Kersthuisbundel

Sluit de niveauomvormer als volgt aan op de D1mini met behulp van de siliconenkabels:

Figuur 1: Bedrading D1mini

Voor de rechterzijde kunt u een D1mini stekkerdoos gebruiken. Als u over het juiste gereedschap beschikt, is een krimpverbinding uiteraard de professionele optie.

Nadat je het Kersthuis-pakket volgens de instructies in elkaar hebt gezet, open je het dakpaneel aan de zijkant van de accubak.

Sluit nu het relais en de DHT22 aan op de volgende aansluitingen op de Nano-Schilden aan.

DHT22	Schild	relais	Schild
+	V11	-	G7
UIT	S11	+	(V7)
-	G11	S	S7

De reeds geïnstalleerde modules uit de kit blijven op de aansluitingen die in de instructies worden beschreven.

In deze blog wordt niet de WS2812 LED-strip gebruikt, maar wordt de LED-kerstboom aangestuurd via het relais. Dit kan ook worden gebruikt door het aantal LED's aan te passen.

Sluit de LED-boom als volgt aan:

boom	relais	Schild
VCC		v
GND	NEE
	COM	G

Figuur 2: Aansluitingen voor 5V-voeding

Opmerking:

Als u het project met het relais en de kerstboom via een externe spanningsbron (bijvoorbeeld batterijpakket aan de achterkant) voedt, kunnen de extra componenten ervoor zorgen dat de regelaar met lage uitval aanzienlijk opwarmt als er een hoge stroombehoefte is. Dit kan mogelijk tot schade leiden. Als de stroombehoefte groter is dan 500 mA, gebruik dan een aparte spanningsbron of een buck-converter.

De relais en de DHT22-sensor kunnen nu bijvoorbeeld met dubbelzijdig plakband in huis worden bevestigd.

Blijf het achterste gedeelte van het dak open laten voor de volgende stappen.

Software

Sinds de Nano heeft geen WLAN-interface, dan is de D1 mini vereist. De enige taak van deze persoon is het ter beschikking stellen van de webserver voor de besturing. De informatie wordt vervolgens naar de UART-interface verzonden Nano, die de volledige controle over de componenten overneemt.

Omdat de twee microcontrollers gegevens uitwisselen via de UART-interface, moet de verbinding worden gescheiden om een microcontroller te kunnen flashen.

Arduino IDE voorbereiden

Als u voor het eerst met microcontrollers te maken heeft, moet u nog steeds de juiste driver downloaden om het programma naar het bord te kunnen overbrengen.

U kunt het installatiebestand voor het juiste stuurprogramma downloaden hier downloaden.

Voor de D1 mini heb je een extra pakket nodig. Om het te installeren, kopieert u de volgende link in de Arduino IDE onder: Bestand->Voorkeuren->Additional boards manager URLs:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

en installeer het ESP32-pakket in het Arduino IDE-bordbeheer.

Verder zijn er bibliotheken nodig om het LCD-display, de LED-module en de DHT22-sensor te kunnen bedienen:

Adafruit_NeoPixel

Vloeistofkristal_I2C

DHT_sensor_bibliotheek

U kunt de bibliotheken installeren met behulp van het in de Arduino IDE geïntegreerde bibliotheekbeheer of ze downloaden als .zip via de link van Github en ga naar
Schets > Bibliotheek opnemen > .zip-bibliotheek toevoegen …

opnemen.

Codeer Nano

Download het volgende programma Nano:

#omvatten
#omvatten
#omvatten
#omvatten "DHT.h"

#definiëren LED           A0
#definiëren KNOP        2
#definiëren LDR           A3
#definiëren RELAIS         7
#definiëren DHTPIN        11

#definiëren NUMPIXELEN     4
#definiëren DHTTYPE DHT22   // DHT 22 (AM2302), AM2321

lang laatsteMillis;

LiquidCrystal_I2C-lcd(0x27, 16, 2);
Adafruit_NeoPixel-strip = Adafruit_NeoPixel (NUMPIXELS, LED, NEO_GRB + NEO_KHZ800);
DHT dht(DHTPIN, DHTTYPE);

leegte handleSensoren() {
zweven.zweven h = dht.readHumidity();
// Lees de temperatuur als Celsius (de standaard)
zweven.zweven t = dht.leesTemperatuur();

zweven.zweven b = kaart(analoogLezen(LDR), 900, 100, 0, 100);
//Lees sensorwaarden
touwtje json = "{";
json += "\"v1\": + touwtje(b) + ",";
json += "\"v2\": + touwtje(t) + ",";
json += "\"v3\": + touwtje(u) + "";
json += "}";

Serieel.println(json);
}

touwtje leesregel(Stroom &poort, niet ondertekend lang time-out = 1000) {
touwtje lijn = "";
niet ondertekend lang begin= milli();
terwijl (milli() - start <time-out) {
    terwijl (poort.beschikbaar()) {
      verkoold c = poort.lezen();
      als (c == '\r') doorgaan;
      als (c == '\n') terug lijn;
      lijn += c;
      als (lijn.lengte() > 256) terug lijn;
    }
}
terug lijn;
}

leegte opstelling() {
Serieel.beginnen(9600);
dht.beginnen();
lcd-scherm.beginnen(16, 2);
lcd-scherm.duidelijk();
lcd.achtergrondverlichting();
pinModus(RELAIS, UITGANG);
strippen.beginnen();
}

leegte lus() {
als(milli()-laatste Millis >= 1000) { //elke seconde
    handleSensoren();
    laatsteMillis = milli();
}

touwtje lijn = leesregel(Serieel);
int idx1 = lijn.indexOf(';');
int IDx2 = lijn.indexOf(';', idx1 + 1);
int idx3 = lijn.indexOf(';', idx2 + 1);
int IDx4 = lijn.indexOf(';', idx3+ 1);

als (idx1 < 0 || idx2 < 0 || idx3 < 0 || idx4 < 0) terug;

touwtje recvHexColor = lijn.subtekenreeks(1, idx1);//.toInt();
touwtje recvTekst1    = lijn.subtekenreeks(idx1 + 1, idx2);
touwtje recvText2    = lijn.subtekenreeks(idx2 + 1, idx3);
Booleaans relais = lijn.subtekenreeks(idx3 + 1, idx4).toInt() == 1;

niet ondertekend lang colorInt = strtoul(recvHexColor.c_str(), NULL, 16);

     voor(int ik=0; ik<=4; ik++) {
      strip.setPixelColor(i, colorInt);
    }
    strip.show();

lcd-scherm.setCursor(0, 0);
lcd-scherm.afdrukken(recvText1);
lcd-scherm.setCursor(0, 1);
lcd-scherm.afdrukken(recvText2);

digitaalSchrijf(RELAIS, relais);
}

De volledige code kan hier worden gedownload.

Uitleg:

In het begin zijn de bibliotheken geïntegreerd en worden er macro's gemaakt voor de pinnamen van de aangesloten modules.

Dit wordt gevolgd door de initialisatie van de globale variabelen en objecten van de bibliotheken.

De volgende methode leest de sensorwaarden en genereert hieruit een json-string, die vervolgens via de seriële interface (UART) naar de D1mini wordt gestuurd, zodat de klimaatwaarden op de website kunnen worden weergegeven. Omdat de LDR slechts een weerstand is en daarom niet in de fabriek is gekalibreerd, kunnen de werkelijke grenswaarden variëren. Je kunt dit instellen in de map() functie. (900 onder limiet 0%; 100 bovenlimiet 100%)

De volgende readLine()-functie vormt een string uit de afzonderlijke tekens die via de UART-interface worden ontvangen. De tekens worden hier bij elkaar opgeteld totdat een nieuwe regel (\n) begint. De functie is vereist voor latere gegevensevaluatie.

In setup() worden de startmethoden van de bibliotheken aangeroepen en wordt de IO van het relais geconfigureerd als uitvoer.

De lus() begint met het uitvoeren van de handvatSensoren elke seconde functioneren. De tijdsvertraging wordt hier geïmplementeerd met een vergelijking met behulp van de functie millis(). Dit betekent dat de lus() niet wordt geblokkeerd.
Vervolgens wordt de string met de invoer van de webserver geëvalueerd, wordt de LED op de geselecteerde kleur gezet, wordt de tekst op het display weergegeven en tenslotte wordt het relais in de verzonden toestand gezet.

Webserver:

Nu volgt de html-code die de webserver weergeeft:

<html>
<hoofd>
<meta tekenset="UTF-8">
<titel>AZ Kersthuiscontrole</titel>

<stijl>
lichaam { lettertype-familie:Arial; marge: 20px; achtergrond:#f0f0f0; }
#box { opvulling:20px; achtergrond:wit; grensradius:10px; breedte:300px; }
etiket { lettertype-gewicht:vet; }

/* Tuimelschakelaar */
.schakelaar { positie: relatief; weergeven: inline-blok; breedte: 50px; hoogte: 24px; }
.schakelaar invoer.invoer { weergeven:geen; }
.schuifregelaar {
positie: absoluut; cursor: wijzer; geweldig: 0; links: 0; juist: 0; onderkant: 0;
achtergrondkleur: #ccc; overgang: .4s; grensradius: 24px;
}
.schuifregelaar:voor {
positie: absoluut; inhoud: ""; hoogte: 18px; breedte: 18px;
links: 3px; onderkant: 3px; achtergrondkleur:wit;
overgang: .4s; grensradius: 50%;
}
invoer.invoer:gecontroleerd + .schuifregelaar { achtergrondkleur: #4CAF50; }
invoer.invoer:gecontroleerd + .schuifregelaar:voor { transformeren: vertalenX(26px); }
</stijl>

</hoofd>

<lichaam>
<verschillende ID="doos">
<h1> Kersthuis </h1>
<h2> Slim huis</h2>

<etiket>Verlichting:</etiket><br>
<invoer.invoer typ="kleur" ID="kleur" onchange="verzendkleur()"><br><br>

<etiket>Weergave:</etiket><br>
<invoer.invoer typ="tekst" ID="t1" maximalelengte="16"><br><br>

<invoer.invoer typ="tekst" ID="t2" maximalelengte="16"><br><br>

<knop onclick="stuurTekst()">Advertenties</knop><br><br>

<etiket>Boom:</etiket><br>
<etiket klasse="schakelaar">
<invoer.invoer typ="selectievakje" ID="schakelen" onchange="verzendToggle()">
<Spaans klasse="schuifregelaar"></Spaans>
</etiket><br><br>

<h3>Klimaat:</h3>
Helderheid: <Spaans ID="v1">--</Spaans> % <br>
Temperatuur: <Spaans ID="v2">--</Spaans> °C <br>
Vochtigheid: <Spaans ID="v3">--</Spaans> %H <br>

</verschillende>

<schrift>
// ---------------- Beginwaarden laden -----------------
venster.venster.onload = functie() {
ophalen("/getState")
    .then(r => r.json())
    .then(gegevens => {
      documenteren.getElementById("kleur").waarde = gegevens.kleur;
      documenteren.getElementById("t1").waarde = gegevens.tekst1;
      documenteren.getElementById("t2").waarde = gegevens.tekst2;
      documenteren.getElementById("schakelen").gecontroleerd = data.toggle;
    });
};

// ---- RGB verzenden ----
functie verzendKleur(){
laat col = documenteren.getElementById("kleur").waarde;
ophalen("/setColor?hex=" + encodeURIComponent(kol));
}

// ---- Sms'jes versturen ----
functie verzendTekst(){
laat tx1 = documenteren.getElementById("t1").waarde;
laat tx2 = documenteren.getElementById("t2").waarde;
ophalen("/setText?t1=" +tx1+ "&t2=" + tx2);
}

// ---- Stuurschakelaar ----
functie verzendenToggle(){
laat st = documenteren.getElementById("schakelen").gecontroleerd? 1 : 0;
ophalen("/setToggle?state=" + st);
}

// ---- Haal waarden op van ESP ----
setInterval(()=>{
ophalen("/waarden")
    .then(reactie => reactie.json())
    .dan(gegevens =>{
      documenteren.getElementById("v1").innerHTML = data.v1;
      documenteren.getElementById("v2").innerHTML = data.v2;
      documenteren.getElementById("v3").innerHTML = data.v3;
    });
},1000);
</schrift>

</lichaam>
</html>

In principe zit elk HTML-bestand in één hoofd en lichaam verdeeld. De configuratie vindt plaats in het hoofd. Hierbij hoort ook de styling van de elementen.

De body bevat ook de afzonderlijke HTML-elementen zoals invoervelden en knoppen schrift Deel dat methoden bevat.
Wanneer u op een knop drukt, wordt een toegewezen methode uitgevoerd, die vervolgens de invoer naar de microcontroller verzendt.

De exacte HTML-functies en -structuur worden hier echter niet verder besproken.

D1mini-code

Download het volledige programma (download aan het einde) op de D1mini:

#omvatten
#omvatten

ESP8266WebServer-server(80);

// Opgeslagen waarden
touwtje kleurHex = "#ff0000";
touwtje tekst1 = "";
touwtje tekst2 = "";
bool toggleState = onwaar;

touwtje gegevens;
touwtje jsonVal = "{\"v1\":-99,\"v2\":-99,\"v3\":-99}";

lang laatsteMillis;

// --------------------- HTML ----------------------
const verkoold MAIN_page[] PROGMEM = R"=====(

//Webserverhtml//
)=====";

// ----------------------------------------------------------

leegte handleRoot() {
server.send_P(200, "tekst/html", MAIN_pagina);
}

leegte handleSetColor() {
colorHex = server.arg("hexadecimaal");
server.send(200, "tekst/gewoon", "OK");
}

leegte handleSetText() {
tekst1 = server.arg("t1");
tekst2 = server.arg("t2");
server.send(200, "tekst/gewoon", "OK");
}

leegte handleSetToggle() {
toggleState = (server.arg("staat") == "1");
server.send(200, "tekst/gewoon", "OK");
}

leegte handleValues() {
server.send(200, "applicatie/json", jsonVal);
}

leegte handleGetState() {
touwtje json = "{";
json += "\"kleur\":\"" +kleurHex+ "\",";
json += "\"tekst1\":\"" + tekst1 + "\",";
json += "\"tekst2\":\"" + tekst2 + "\",";
json += "\"toggle\" + touwtje(toggleState ? "waar" : "vals");
json += "}";
server.send(200, "applicatie/json", json);
}

touwtje leesregel(Stroom &poort, niet ondertekend lang time-out = 1000) {
touwtje lijn = "";
niet ondertekend lang begin= milli();
terwijl (milli() - start <time-out) {
    terwijl (poort.beschikbaar()) {
      verkoold c = poort.lezen();
      als (c == '\r') doorgaan;
      als (c == '\n') terug lijn;
      lijn += c;
      als (lijn.lengte() > 256) terug lijn;
    }
    opbrengst();
}
terug lijn;
}

leegte opstelling() {
Serieel.beginnen(9600);

WiFi.softAP("SmartHome", "");

server.on("/", handleRoot);
server.on("/setKleur", handleSetColor);
server.on("/setTekst", handleSetText);
server.on("/setToggle", handleSetToggle);
server.on("/waarden", handleValues);
server.on("/getState", handleGetState);

server.server.beginnen();
}

leegte lus() {
als(milli()-laatste Millis >= 500) {
    touwtje pakket = kleurHex + ";" + tekst1 + ";" + tekst2 + ";" + toggleState + ";";
    Serieel.println(pakket);
    laatsteMillis = milli();
}

server.handleClient();
gegevens = leesregel(Serieel);
als(data.indexOf("{") == 0) {
    jsonVal = gegevens;
}
}

De volledige code kan hier worden gedownload.

Uitleg:

Zoals in de code voor de Nano, In het begin worden de bibliotheken geïntegreerd en worden objecten en globale variabelen geïnitialiseerd.

De html-code wordt hier ook in het geheugen geladen. Voor de duidelijkheid is hier het gehele HTML-bestand weggelaten.

De volgende methoden zijn de callback-functies van de webserver, waarmee de gegevens bij een wijziging worden gelezen en weergegeven.

De readLine-functie komt in principe overeen met die in Nanoprogramma gebruikt. Het enige verschil is dat hier de functie yield() wordt gebruikt, waarmee functies op de achtergrond kunnen worden uitgevoerd. Dit betekent dat er geen problemen zijn met de webserver vanwege geblokkeerde achtergrondprocessen.

In setup() wordt een access point gestart zodat u direct verbinding kunt maken met de D1mini en er dus geen WiFi-verbinding nodig is.
Vervolgens worden de callback-methoden toegewezen en wordt de webserver gestart.

De loop() is opnieuw analoog aan het Nano-programma gestructureerd. Hier wordt de ontvangen string niet geëvalueerd, maar rechtstreeks naar de server verzonden omdat deze al in json-formaat is.

Nadat beide microcontrollers zijn geflitst, sluit u de D1-mini-assemblage aan op de vrije UART-pinheader op de Nano-Schild. Zorg ervoor dat deze correct is aangesloten (u kunt de GND-pin gebruiken als referentie in de bovenstaande bedrading.

Maak na het uploaden verbinding met het open ‘SmartHome’-netwerk. Als u een melding ontvangt dat het netwerk geen internettoegang heeft, schakelt u dit in Onderhoud verbinding voor het netwerk. Eenmaal verbonden met het netwerk, opent u de browser op het aangesloten apparaat en voert u het adres 192.168.4.1 in. Vervolgens verschijnt de volgende pagina waarop u de smart home kunt bedienen.

Figuur 3: Screenshot van de webserver

Conclusie:

Nu u de afzonderlijke delen van het project via een webserver kunt besturen, kunt u nog steeds automatiseringen instellen op de Nano programmeer hem in, bijvoorbeeld om de knop als bediening te gebruiken. Zorg er echter voor dat er geen blokken (while of delay) worden gebruikt in de loop() om de verwerking van de gegevens door de webserver niet te onderbreken.

Met deze automatiseringen en eventueel extra sensoren of modules kunt u uw eigen kleine smart home-project implementeren en uitbreiden.

Veel plezier met het repliceren :)

Voor lezers met gevorderde kennis is het ook de moeite waard om een kijkje te nemen op de blog een boom hakken, waarin het kerstboompakket opnieuw wordt geprogrammeerd en je je eigen patronen kunt programmeren.

Categorieën: Projekte für anfänger, Smart home, Specials

Deel