SmartHome im Weihnachtshaus - AZ-Delivery

0 commenti

Il kit della Casa di Natale ha il Nano Il microcontrollore ha solo funzioni limitate, come accendere la luce utilizzando il pulsante accanto alla porta.

In questo post del blog il set si trasformerà in una piccola casa intelligente con funzione WiFi in look natalizio utilizzando un mini microcontrollore D1.

Hardware

Per l'implementazione è necessario:

Kit per la casa di Natale

D1miniESP8266 (possibili anche altre versioni)

Convertitore di livello

Kit albero di Natale a LED (possibili anche altre versioni)

Anche come Fascio disponibile:

SmartHome nel pacchetto Casa di Natale

Collegare il convertitore di livello al D1mini utilizzando i cavi in silicone come segue:

Figura 1: cablaggio del D1mini

Per il lato destro è possibile utilizzare una presa multipla D1mini. Se si dispone degli strumenti adeguati, una connessione crimpata è ovviamente l'opzione professionale.

Dopo aver assemblato il kit Christmas House secondo le istruzioni, aprire il pannello del tetto sul lato del vano batteria.

Ora collega il relè e il DHT22 alle seguenti connessioni su Nano- Scudi accesi.

DHT22	Scudo	relè	Scudo
+	V11	-	G7
FUORI	S11	+	(V7)
-	G11	S	S7

I moduli già installati del kit rimangono ai collegamenti descritti nelle istruzioni.

La striscia LED WS2812 non viene utilizzata in questo blog, invece l'albero di Natale a LED viene controllato tramite il relè. Questo può essere utilizzato anche regolando il numero di LED.

Collegare l'albero LED come segue:

albero	relè	Scudo
VCC		v
GND	NO
	COM	G

Figura 2: Collegamenti per l'alimentazione a 5 V

Nota:

Se si alimenta il progetto con il relè e l'albero di Natale tramite una fonte di tensione esterna (ad esempio la batteria sul retro), i componenti aggiuntivi possono causare un notevole surriscaldamento del regolatore a bassa caduta di tensione in caso di fabbisogno di corrente elevato. Ciò può potenzialmente causare danni. Se il fabbisogno di corrente è superiore a 500 mA, utilizzare una fonte di tensione separata o un convertitore buck.

I relè e il sensore DHT22 ora possono essere fissati in casa, ad esempio, con nastro biadesivo.

Continua a lasciare aperta la parte posteriore del tetto per i passaggi successivi.

Software

Dal momento che Nano non ha un'interfaccia WLAN, è necessario il D1 mini. L'unico compito di questa persona è quello di mettere a disposizione il web server per il controllo. Le informazioni vengono quindi inviate all'interfaccia UART Nano, che assume il controllo totale dei componenti.

Poiché i due microcontrollori scambiano dati tramite l'interfaccia UART, la connessione deve essere separata per eseguire il flashing di un microcontrollore.

Preparazione dell'IDE di Arduino

Se siete alle prese con i microcontrollori per la prima volta, sarà comunque necessario scaricare gli appositi driver per poter trasferire il programma sulla scheda.

È possibile scaricare il file di installazione per il driver appropriato qui scaricare.

Per il D1 mini è necessario un pacchetto aggiuntivo. Per installarlo, copiare il seguente collegamento nell'IDE di Arduino in: File->Preferenze->URL gestione schede aggiuntive:

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

e installare il pacchetto ESP32 nella gestione della scheda IDE Arduino.

Inoltre, le librerie devono poter controllare il display LCD, il modulo LED e il sensore DHT22:

Adafruit_NeoPixel

LiquidCrystal_I2C

Libreria_sensori_DHT

Puoi installare le librerie utilizzando la gestione delle librerie integrata nell'IDE di Arduino o scaricarle come .zip utilizzando il collegamento da Github e andare su
Schizzo > includi libreria > Aggiungi libreria .zip...

incorporare.

Codice Nano

Scarica il seguente programma Nano:

#includere
#includere
#includere
#includere "DHT.h"

#definire LED           A0
#definire PULSANTE        2
#definire LDR           A3
#definire RELÈ         7
#definire PIN DHT        11

#definire NUMPIXEL     4
#definire DHTTYPE DHT22   //DHT22 (AM2302), AM2321

lungo ultimoMillis;

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

vuoto handleSensori() {
float.float h = dht.readUmidità();
// Legge la temperatura in gradi Celsius (impostazione predefinita)
float.float t = dht.leggereTemperatura();

float.float b = mappa(analogicoLeggi(LDR), 900, 100, 0, 100);
//Leggi i valori del sensore
stringa json = "{";
json += "\"v1\":" + stringa(b)+ ",";
json += "\"v2\":" + stringa(t)+ ",";
json += "\"v3\":" + stringa(h)+ "";
json += "}";

Seriale.println(json);
}

stringa readLine(Flusso &porto, non firmato lungo timeout = 1000) {
stringa linea = "";
non firmato lungo inizio = millis();
mentre (millis() - inizio < timeout) {
    mentre (porto.disponibile()) {
      car c = porto.leggere();
      se (c == '\r') continuare;
      se (c == '\n') ritorno linea;
      linea += c;
      se (linea.lunghezza() > 256) ritorno linea;
    }
}
ritorno linea;
}

vuoto impostazione() {
Seriale.iniziare(9600);
dht.iniziare();
lcd.iniziare(16, 2);
lcd.chiaro();
lcd.retroilluminazione();
pinMode(RELÈ, USCITA);
striscia.iniziare();
}

vuoto ciclo() {
se(millis()-ultimoMillis >= 1000) { //ogni secondo
    handleSensori();
    ultimoMillis = millis();
}

stringa linea = leggiRiga(Seriale);
int idx1 = linea.indiceDi(';');
int idx2 = linea.indiceDi(';', idx1 + 1);
int idx3 = linea.indiceDi(';', idx2 + 1);
int idx4 = linea.indiceDi(';', idx3+ 1);

se (idx1 < 0 || idx2 < 0 || idx3 < 0 || idx4 < 0) ritorno;

stringa recvHexColor = linea.sottostringa(1, idx1);//.toInt();
stringa recvText1    = linea.sottostringa(idx1 + 1, idx2);
stringa recvText2    = linea.sottostringa(idx2 + 1, idx3);
booleano relè = linea.sottostringa(idx3 + 1, idx4).toInt() == 1;

non firmato lungo colorInt = strtoul(recvHexColor.c_str(), NULL, 16);

     per(int io=0; io<=4; i++) {
      strip.setPixelColor(i, colorInt);
    }
    spogliarello.mostra();

lcd.setCursor(0, 0);
lcd.stampa(testoricev1);
lcd.setCursor(0, 1);
lcd.stampa(recvText2);

digitalWrite(RELÈ, relè);
}

Il codice completo può qui essere scaricato.

Spiegazione:

All'inizio vengono integrate le librerie e create delle macro per i nomi dei pin dei moduli collegati.

Segue l'inizializzazione delle variabili globali e degli oggetti delle librerie.

Il seguente metodo legge i valori del sensore e genera da essi una stringa json, che viene poi inviata al D1mini tramite l'interfaccia seriale (UART) in modo che i valori climatici possano essere visualizzati sul sito web. Poiché l'LDR è solo un resistore e quindi non calibrato in fabbrica, i valori limite effettivi possono variare. Puoi impostarlo nella funzione map(). (900 limite inferiore 0%; 100 limite superiore 100%)

La seguente funzione readLine() forma una stringa dai singoli caratteri ricevuti tramite l'interfaccia UART. I caratteri vengono sommati qui fino all'inizio di una nuova riga (\n). La funzione è necessaria per la successiva valutazione dei dati.

In setup() vengono richiamati i metodi di avvio delle librerie e l'IO del relè viene configurato come output.

Il loop() inizia eseguendo il handleSensori funzionare ogni secondo. Il ritardo temporale viene qui implementato con un confronto utilizzando la funzione millis(). Ciò significa che loop() non è bloccato.
Successivamente viene valutata la stringa con l'input dal server web, quindi il LED viene impostato sul colore selezionato, il testo viene visualizzato sul display e infine il relè viene impostato sullo stato trasmesso.

Server web:

Ora segue il codice html che visualizza il server web:

<html>
<testa>
<meta set di caratteri="UTF-8">
<titolo>Controllo della casa di Natale dall'AZ</titolo>

<stile>
corpo { famiglia di caratteri:Arial; margine: 20px; sfondo:#f0f0f0; }
#box { imbottitura:20px; sfondo:bianco; raggio di confine:10px; larghezza:300px; }
etichetta { peso del carattere:grassetto; }

/* Commuta l'interruttore */
.interruttore { posizione: relativo; visualizzazione: blocco in linea; larghezza: 50px; altezza: 24px; }
.interruttore input.input { visualizzazione:nessuno; }
.slider {
posizione: assoluto; cursore: puntatore; fantastico: 0; sinistra: 0; giusto: 0; fondo: 0;
colore di sfondo: #ccc; transizione: .4s; raggio di confine: 24px;
}
.slider:prima di {
posizione: assoluto; contenuto: ""; altezza: 18px; larghezza: 18px;
sinistra: 3px; fondo: 3px; colore di sfondo:bianco;
transizione: .4s; raggio di confine: 50%;
}
input.input:controllato + .slider { colore di sfondo: #4CAF50; }
input.input:controllato + .slider:prima di { trasformare: tradurreX(26px); }
</stile>

</testa>

<corpo>
<vari id="scatola">
<h1> Casa di Natale </h1>
<h2> Casa intelligente</h2>

<etichetta>Illuminazione:</etichetta><fratello>
<input.input tipo="colore" id="colore" onchange="inviaColore()"><fratello><fratello>

<etichetta>Visualizzazione:</etichetta><fratello>
<input.input tipo="testo" id="t1" lunghezza massima="16"><fratello><fratello>

<input.input tipo="testo" id="t2" lunghezza massima="16"><fratello><fratello>

<pulsante onclick="inviatesto()">Annunci</pulsante><fratello><fratello>

<etichetta>Albero:</etichetta><fratello>
<etichetta classe="interruttore">
<input.input tipo="casella di controllo" id="attivare/disattivare" onchange="sendToggle()">
<spagnolo classe="cursore"></spagnolo>
</etichetta><fratello><fratello>

<h3>Clima:</h3>
Luminosità: <spagnolo id="v1">--</spagnolo> % <fratello>
Temperatura: <spagnolo id="v2">--</spagnolo> °C <fratello>
Umidità: <spagnolo id="v3">--</spagnolo> %H <fratello>

</vari>

<sceneggiatura>
// ----------------- Carica i valori iniziali -----------------
finestra.finestra.onload = funzione() {
recuperare("/getState")
    .then(r => r.json())
    .then(dati => {
      documento.getElementById("colore").valore = dati.colore;
      documento.getElementById("t1").valore = dati.testo1;
      documento.getElementById("t2").valore = dati.testo2;
      documento.getElementById("attivare/disattivare").checked = data.toggle;
    });
};

// ---- Invia RGB ----
funzione sendColor(){
lascia col = documento.getElementById("colore").valore;
recuperare("/setColor?hex=" + codificaURIComponent(col));
}

// ---- Invia SMS ----
funzione sendText(){
lascia tx1 = documento.getElementById("t1").valore;
lascia tx2 = documento.getElementById("t2").valore;
recuperare("/setText?t1=" +tx1+ "&t2=" +tx2);
}

// ---- Invia interruttore ----
funzione sendToggle(){
lascia st = documento.getElementById("attivare/disattivare").controllato? 1 : 0;
recuperare("/setToggle?state=" + st);
}

// ---- Ottieni valori da ESP ----
setInterval(()=>{
recuperare("/valori")
    .then(risposta => risposta.json())
    .quindi(dati =>{
      documento.getElementById("v1").innerHTML = dati.v1;
      documento.getElementById("v2").innerHTML = dati.v2;
      documento.getElementById("v3").innerHTML = dati.v3;
    });
},1000);
</sceneggiatura>

</corpo>
</html>

Fondamentalmente ogni file html è in uno testa e corpo diviso. La configurazione avviene nella testa. Ciò include anche lo stile degli elementi.

Il corpo contiene anche i singoli elementi HTML come campi di input e pulsanti sceneggiatura Parte che contiene metodi.
Quando si preme un pulsante, viene eseguito un metodo assegnato, che poi trasmette l'input al microcontrollore.

Tuttavia, le funzioni e la struttura esatta dell'HTML non verranno discusse ulteriormente in questa sede.

Codice D1mini

Scarica il programma completo (download alla fine) sul D1mini:

#includere
#includere

Server ESP8266WebServer(80);

// Valori salvati
stringa colorHex = "#ff0000";
stringa testo1 = "";
stringa testo2 = "";
bool toggleState = falso;

stringa dati;
stringa jsonVal = "{\"v1\":-99,\"v2\":-99,\"v3\":-99}";

lungo ultimoMillis;

// ----------------------HTML -----------------------
cost car Pagina_MAIN[] PROGMEM = R"=====(

//Server webHTML//
)=====";

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

vuoto handleRoot() {
server.send_P(200, "testo/html", pagina_MAIN);
}

vuoto handleSetColor() {
colorHex = server.arg("esadecimale");
server.send(200, "testo/semplice", "Va bene");
}

vuoto handleSetText() {
testo1 = server.arg("t1");
testo2 = server.arg("t2");
server.send(200, "testo/semplice", "Va bene");
}

vuoto handleSetToggle() {
toggleState = (server.arg("stato") == "1");
server.send(200, "testo/semplice", "Va bene");
}

vuoto handleValues() {
server.send(200, "applicazione/json", jsonVal);
}

vuoto handleGetState() {
stringa json = "{";
json += "\"colore\":\"" +coloreHex+ "\",";
json += "\"testo1\":\"" + testo1 + "\",";
json += "\"testo2\":\"" + testo2 + "\",";
json += "\"attiva/disattiva\":" + stringa(attiva/disattiva stato? "vero" : "falso");
json += "}";
server.send(200, "applicazione/json", json);
}

stringa readLine(Flusso &porto, non firmato lungo timeout = 1000) {
stringa linea = "";
non firmato lungo inizio = millis();
mentre (millis() - inizio < timeout) {
    mentre (porto.disponibile()) {
      car c = porto.leggere();
      se (c == '\r') continuare;
      se (c == '\n') ritorno linea;
      linea += c;
      se (linea.lunghezza() > 256) ritorno linea;
    }
    rendimento();
}
ritorno linea;
}

vuoto impostazione() {
Seriale.iniziare(9600);

Wi-Fi.softAP("Casa intelligente", "");

server.on("/", handleRoot);
server.on("/setColor", handleSetColor);
server.on("/setText", handleSetText);
server.on("/setToggle", handleSetToggle);
server.on("/valori", handleValues);
server.on("/getState", handleGetState);

server.server.iniziare();
}

vuoto ciclo() {
se(millis()-ultimoMillis >= 500) {
    stringa pacchetto = colorHex + ";" + testo1 + ";" + testo2 + ";" + attiva/disattiva stato + ";";
    Seriale.println(pacchetto);
    ultimoMillis = millis();
}

server.handleClient();
dati = leggiLine(Seriale);
se(data.indexOf("{") == 0) {
    jsonVal = dati;
}
}

Il codice completo può qui essere scaricato.

Spiegazione:

Come nel codice per il Nano, All'inizio si integrano le librerie e si inizializzano oggetti e variabili globali.

Anche il codice html viene caricato in memoria qui. L'intero file html è stato omesso qui per chiarezza.

I seguenti metodi sono le funzioni di callback del server web, con le quali le voci vengono lette e visualizzate in caso di modifica.

La funzione readLine corrisponde sostanzialmente a quella in Nanoprogramma utilizzato. L'unica differenza è che qui viene utilizzata la funzione yield(), che consente l'esecuzione delle funzioni in background. Ciò significa che non ci sono problemi con il server web a causa di processi in background bloccati.

In setup() viene avviato un punto di accesso in modo da potersi connettere direttamente al D1mini e quindi non è necessaria alcuna connessione WiFi.
Successivamente vengono assegnati i metodi di callback e il server web viene avviato.

Il loop() è ancora una volta strutturato in modo analogo al programma di Nano. Qui la stringa ricevuta non viene valutata, ma viene inviata direttamente al server perché è già in formato json.

Dopo che entrambi i microcontrollori sono stati flashati, collega il mini gruppo D1 all'intestazione del pin UART libero sul Nano-Scudo. Assicurati che sia collegato correttamente (puoi usare il pin GND come riferimento nel cablaggio sopra.

Dopo il caricamento, connettiti alla rete aperta "SmartHome". Se ricevi una notifica che la rete non ha accesso a Internet, abilitala Mantieni la connessione per la rete. Una volta connesso alla rete, aprire il browser del dispositivo connesso e inserire l'indirizzo 192.168.4.1. Verrà quindi visualizzata la pagina seguente in cui è possibile controllare la casa intelligente.

Figura 3: schermata dal server web

Conclusione:

Ora che puoi controllare le singole parti del progetto tramite un server web, puoi ancora configurare le automazioni sul Nano programmarlo, ad esempio per utilizzare il pulsante come controllo. Tuttavia, assicurati che nel loop() non vengano utilizzati blocchi (mentre o ritardi) per non interrompere l'elaborazione dei dati da parte del server web.

Con queste automazioni ed eventualmente sensori o moduli aggiuntivi, puoi realizzare ed espandere il tuo piccolo progetto di casa intelligente.

Divertitevi a replicarlo :)

Per i lettori con conoscenze avanzate, vale la pena dare un'occhiata anche al blog hackerare un albero, in cui il kit dell'albero di Natale viene riprogrammato e puoi programmare i tuoi modelli.

Tags: Projekte für anfänger, Smart home, Specials