SmartHome im Weihnachtshaus - AZ-Delivery

0 commentaire

Le kit Maison de Noël contient le Nano Le microcontrôleur n'a que des fonctions limitées, comme allumer la lumière à l'aide du bouton situé à côté de la porte.

Dans ce billet de blog, l'ensemble doit être transformé en une petite maison intelligente avec fonction WiFi au look de Noël grâce à un mini microcontrôleur D1.

Matériel

Pour la mise en œuvre, vous avez besoin de :

Kit maison de Noël

D1mini ESP8266 (d'autres versions également possibles)

Convertisseur de niveau

Kit sapin de Noël LED (d'autres versions également possibles)

Connectez le convertisseur de niveau au D1mini à l'aide des câbles en silicone comme suit :

Figure 1 : Câblage du D1mini

Pour le côté droit, vous pouvez utiliser une multiprise D1mini. Si vous disposez des outils appropriés, une connexion sertie est bien entendu l’option professionnelle.

Après avoir assemblé le kit Maison de Noël selon les instructions, ouvrez le panneau de toit sur le côté du boîtier de batterie.

Connectez maintenant le relais et le DHT22 aux connexions suivantes sur le Nano- Boucliers en place.

DHT22	Bouclier	relais	Bouclier
+	V11	-	G7
SORTI	S11	+	(V 7)
-	G11	S	S7

Les modules déjà installés du kit restent au niveau des connexions décrites dans les instructions.

La bande LED WS2812 n'est pas utilisée dans ce blog, mais le sapin de Noël LED est contrôlé via le relais. Cela peut également être utilisé en ajustant le nombre de LED.

Connectez l'arbre LED comme suit :

arbre	relais	Bouclier
VCC		v
GND	NON
	COM	G

Figure 2 : Connexions pour l'alimentation 5 V

Remarque :

Si vous alimentez le projet avec le relais et l'arbre de Noël via une source de tension externe (par exemple une batterie à l'arrière), les composants supplémentaires peuvent provoquer un échauffement important du régulateur à faible chute en cas de besoin de courant élevé. Cela peut potentiellement entraîner des dommages. Si le besoin en courant est supérieur à 500 mA, utilisez une source de tension distincte ou un convertisseur abaisseur.

Les relais et le capteur DHT22 peuvent désormais être fixés dans la maison avec du ruban adhésif double face par exemple.

Continuez à laisser la partie arrière du toit ouverte pour les étapes suivantes.

Logiciel

Depuis le Nano n'a pas d'interface WLAN, le D1 mini est requis. La seule tâche de cette personne est de fournir le serveur web pour le contrôle. Les informations sont ensuite envoyées à l'interface UART Nano, qui prend en charge l’intégralité du contrôle des composants.

Étant donné que les deux microcontrôleurs échangent des données via l'interface UART, la connexion doit être séparée pour flasher un microcontrôleur.

Préparation de l'IDE Arduino

Si vous utilisez des microcontrôleurs pour la première fois, vous devrez toujours télécharger le pilote approprié afin de pouvoir transférer le programme sur la carte.

Vous pouvez télécharger le fichier d'installation du pilote approprié ici télécharger.

Pour le D1 mini, vous avez besoin d’un package supplémentaire. Pour l'installer, copiez le lien suivant dans l'IDE Arduino sous : Fichier->Préférences->URL du gestionnaire de cartes supplémentaires :

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

et installez le package ESP32 dans la gestion de la carte Arduino IDE.

De plus, des bibliothèques sont nécessaires pour pouvoir contrôler l'écran LCD, le module LED et le capteur DHT22 :

Adafruit_NeoPixel

LiquidCrystal_I2C

Bibliothèque_sensor_DHT

Vous pouvez installer les bibliothèques à l'aide de la gestion des bibliothèques intégrée à l'IDE Arduino ou les télécharger au format .zip en utilisant le lien de Github et accéder à
Sketch > inclure la bibliothèque > Ajouter une bibliothèque .zip…

incorporer.

Coder Nano

Téléchargez le programme suivant Nano:

#include <Wire.h>
#include <Adafruit_NeoPixel.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"

#define LED           A0
#define BUTTON        2
#define LDR           A3
#define RELAY         7
#define DHTPIN        11

#define NUMPIXELS     4
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321

long lastMillis;

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

void handleSensors() {
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();

  float b = map(analogRead(LDR), 900, 100, 0, 100);
  //Sensorwerte Auslesen
  String json = "{";
  json += "\"v1\":" + String(b) + ",";
  json += "\"v2\":" + String(t) + ",";
  json += "\"v3\":" + String(h) + "";
  json += "}";

  Serial.println(json);
}

String readLine(Stream &port, unsigned long timeout = 1000) {
  String line = "";
  unsigned long start = millis();
  while (millis() - start < timeout) {
    while (port.available()) {
      char c = port.read();
      if (c == '\r') continue;
      if (c == '\n') return line;
      line += c;
      if (line.length() > 256) return line;
    }
  }
  return line;
}

void setup() {
  Serial.begin(9600);
  dht.begin();
  lcd.begin(16, 2);
  lcd.clear();
  lcd.backlight();
  pinMode(RELAY, OUTPUT);
  strip.begin();
}

void loop() {
  if(millis()-lastMillis >= 1000) { //every second
    handleSensors();
    lastMillis = millis();
  }

  String line = readLine(Serial);
  int idx1 = line.indexOf(';');
  int idx2 = line.indexOf(';', idx1 + 1);
  int idx3 = line.indexOf(';', idx2 + 1);
  int idx4 = line.indexOf(';', idx3 + 1);

  if (idx1 < 0 || idx2 < 0 || idx3 < 0 || idx4 < 0) return;

  String recvHexColor = line.substring(1, idx1);//.toInt();
  String recvText1    = line.substring(idx1 + 1, idx2);
  String recvText2    = line.substring(idx2 + 1, idx3);
  boolean relay = line.substring(idx3 + 1, idx4).toInt() == 1;

  unsigned long colorInt = strtoul(recvHexColor.c_str(), NULL, 16);

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

  lcd.setCursor(0, 0);
  lcd.print(recvText1);
  lcd.setCursor(0, 1);
  lcd.print(recvText2);

  digitalWrite(RELAY, relay);
}

Le code complet peut ici être téléchargé.

Explication :

Au début, les bibliothèques sont intégrées et des macros sont créées pour les noms de broches des modules connectés.

Vient ensuite l'initialisation des variables globales et des objets des bibliothèques.

La méthode suivante lit les valeurs des capteurs et génère une chaîne json à partir d'elles, qui est ensuite envoyée au D1mini via l'interface série (UART) afin que les valeurs climatiques puissent être affichées sur le site Web. Étant donné que le LDR n'est qu'une résistance et n'est donc pas calibré en usine, les valeurs limites réelles peuvent varier. Vous pouvez définir cela dans la fonction map(). (900 en dessous de la limite 0 % ; 100 limite supérieure à 100 %)

La fonction readLine() suivante forme une chaîne à partir des caractères individuels reçus via l'interface UART. Les caractères sont additionnés ici jusqu'à ce qu'une nouvelle ligne (\n) commence. La fonction est requise pour une évaluation ultérieure des données.

Dans setup(), les méthodes de démarrage des bibliothèques sont appelées et les IO du relais sont configurées en sortie.

La boucle() commence par exécuter le PoignéeCapteurs fonctionner chaque seconde. Le délai est ici implémenté avec une comparaison utilisant la fonction millis(). Cela signifie que la boucle() n'est pas bloquée.
La chaîne avec l'entrée du serveur Web est ensuite évaluée et la LED est ensuite réglée sur la couleur sélectionnée, le texte s'affiche sur l'écran et enfin le relais est réglé sur l'état transmis.

Serveur Web :

Suit maintenant le code html qui affiche le serveur web :

<HTML>
<tête>
<méta jeu de caractères ="UTF-8">
<titre>Contrôle de la maison de Noël AZ</titre>

<style>
corps { famille de polices:Arial; marge: 20px; fond:#f0f0f0; }
#box { rembourrage:20px; fond:blanc; rayon de frontière:10px; largeur:300px; }
étiquette { poids de la police:gras; }

/* Interrupteur à bascule */
.switch { poste: relatif; afficher: bloc en ligne ; largeur: 50px; hauteur: 24px; }
.switch entrée.entrée { afficher:aucun; }
.slider {
poste: absolu; curseur: pointeur; super: 0; à gauche: 0; à droite: 0; en bas: 0;
couleur d'arrière-plan: #ccc; transition: .4s; rayon de frontière: 24px;
}
.slider:avant {
poste: absolu; contenu: ""; hauteur: 18px; largeur: 18px;
à gauche: 3px; en bas: 3px; couleur d'arrière-plan:blanc;
transition: .4s; rayon de frontière: 50%;
}
entrée.entrée:vérifié + .slider { couleur d'arrière-plan: #4CAF50; }
entrée.entrée:vérifié + .slider:avant { transformer: traduireX(26px); }
</style>

</tête>

<corps>
<divers identifiant="boîte">
<h1> Maison de Noël </h1>
<h2> Maison intelligente</h2>

<étiquette>Éclairage :</étiquette><br>
<entrée.entrée tapez="couleur" identifiant="couleur" onchange="envoyerCouleur()"><br><br>

<étiquette>Affichage :</étiquette><br>
<entrée.entrée tapez="texte" identifiant="t1" longueur maximale ="16"><br><br>

<entrée.entrée tapez="texte" identifiant="t2" longueur maximale ="16"><br><br>

<bouton onclick="envoyerTexte()">Annonces</bouton><br><br>

<étiquette>Arbre :</étiquette><br>
<étiquette classe="commutateur">
<entrée.entrée tapez="case à cocher" identifiant="basculer" onchange="envoyerToggle()">
<Espagnol classe="curseur"></Espagnol>
</étiquette><br><br>

<h3>Climat :</h3>
Luminosité : <Espagnol identifiant="v1">--</Espagnol> % <br>
Température : <Espagnol identifiant="v2">--</Espagnol> °C <br>
Humidité : <Espagnol identifiant="v3">--</Espagnol> %H <br>

</divers>

<scénario>
// ----------------- Charger les valeurs initiales -----------------
fenêtre.fenêtre.onload = fonction() {
récupérer ("/getState")
    .then(r => r.json())
    .then(données => {
      documents.getElementById("couleur").value = data.color;
      documents.getElementById("t1").value = data.text1;
      documents.getElementById("t2").value = data.text2;
      documents.getElementById("basculer").checked = data.toggle;
    });
};

// ---- Envoyer RVB ----
fonction envoyerCouleur(){
laisser col = documents.getElementById("couleur").valeur;
récupérer ("/setColor?hex=" + encodeURIComponent(col));
}

// ---- Envoyer des SMS ----
fonction envoyerTexte(){
laisser TX1 = documents.getElementById("t1").valeur;
laisser tx2 = documents.getElementById("t2").valeur;
récupérer ("/setText?t1=" +tx1+ "&t2=" +tx2);
}

// ---- Envoyer le commutateur ----
fonction envoyerToggle(){
laisser m = documents.getElementById("basculer").vérifié ? 1 : 0;
récupérer ("/setToggle?state=" + m);
}

// ---- Récupérer les valeurs d'ESP ----
setInterval(()=>{
récupérer ("/valeurs")
    .then(réponse => réponse.json())
    .then(données =>{
      documents.getElementById("v1").innerHTML = data.v1;
      documents.getElementById("v2").innerHTML = data.v2;
      documents.getElementById("v3").innerHTML = data.v3;
    });
},1000);
</scénario>

</corps>
</HTML>

Fondamentalement, chaque fichier HTML est en un seul tête et corps divisé. La configuration s'effectue dans la tête. Cela inclut également le style des éléments.

Le corps contient également les éléments HTML individuels tels que les champs de saisie et les boutons. scénario Partie qui contient les méthodes.
Lorsque vous appuyez sur un bouton, une méthode assignée est exécutée, qui transmet ensuite l'entrée au microcontrôleur.

Cependant, les fonctions et la structure exactes du HTML ne seront pas abordées davantage ici.

Code mini D1

Téléchargez le programme complet (téléchargement à la fin) sur le D1mini :

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

ESP8266WebServer server(80);

// Gespeicherte Werte
String colorHex = "#ff0000";
String text1 = "";
String text2 = "";
bool toggleState = false;

String data;
String jsonVal = "{\"v1\":-99,\"v2\":-99,\"v3\":-99}";

long lastMillis;

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

//Webserver html//
)=====";

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

void handleRoot() {
  server.send_P(200, "text/html", MAIN_page);
}

void handleSetColor() {
  colorHex = server.arg("hex");
  server.send(200, "text/plain", "OK");
}

void handleSetText() {
  text1 = server.arg("t1");
  text2 = server.arg("t2");
  server.send(200, "text/plain", "OK");
}

void handleSetToggle() {
  toggleState = (server.arg("state") == "1");
  server.send(200, "text/plain", "OK");
}

void handleValues() {
  server.send(200, "application/json", jsonVal);
}

void handleGetState() {
  String json = "{";
  json += "\"color\":\"" + colorHex + "\",";
  json += "\"text1\":\"" + text1 + "\",";
  json += "\"text2\":\"" + text2 + "\",";
  json += "\"toggle\":" + String(toggleState ? "true" : "false");
  json += "}";
  server.send(200, "application/json", json);
}

String readLine(Stream &port, unsigned long timeout = 1000) {
  String line = "";
  unsigned long start = millis();
  while (millis() - start < timeout) {
    while (port.available()) {
      char c = port.read();
      if (c == '\r') continue;
      if (c == '\n') return line;
      line += c;
      if (line.length() > 256) return line;
    }
    yield();
  }
  return line;
}

void setup() {
  Serial.begin(9600);

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

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

  server.begin();
}

void loop() {
  if(millis()-lastMillis >= 500) {
    String paket = colorHex + ";" + text1 + ";" + text2 + ";" + toggleState + ";";
    Serial.println(paket);
    lastMillis = millis();
  }

  server.handleClient();
  data = readLine(Serial);
  if(data.indexOf("{") == 0) {
    jsonVal = data;
  }
}

Le code complet peut ici être téléchargé.

Explication :

Comme dans le code du Nano, Au début, les bibliothèques sont intégrées et les objets et variables globales sont initialisés.

Le code HTML est également chargé en mémoire ici. L'intégralité du fichier HTML a été omis ici pour plus de clarté.

Les méthodes suivantes sont les fonctions de rappel du serveur Web, avec lesquelles les entrées sont lues et affichées lorsqu'une modification est effectuée.

La fonction readLine correspond essentiellement à celle de Nanoprogramme utilisé. La seule différence est que la fonction rendement() est utilisée ici, ce qui permet d'exécuter des fonctions en arrière-plan. Cela signifie qu'il n'y a aucun problème avec le serveur Web en raison de processus en arrière-plan bloqués.

Un point d'accès est démarré dans setup() afin que vous puissiez vous connecter directement au D1mini et qu'aucune connexion WiFi n'est donc nécessaire.
Les méthodes de rappel sont ensuite attribuées et le serveur Web est démarré.

Le loop() est à nouveau structuré de manière analogue au programme du Nano. Ici la chaîne reçue n'est pas évaluée, mais est envoyée directement au serveur car elle est déjà au format json.

Une fois les deux microcontrôleurs flashés, branchez le mini-assemblage D1 dans l'en-tête de broche UART libre sur le Nano-Bouclier. Assurez-vous qu'il est correctement connecté (vous pouvez utiliser la broche GND comme référence dans le câblage ci-dessus.

Après le téléchargement, connectez-vous au réseau ouvert « SmartHome ». Si vous recevez une notification indiquant que le réseau n'a pas accès à Internet, activez-le Maintenir la connexion pour le réseau. Une fois connecté au réseau, ouvrez le navigateur sur l'appareil connecté et saisissez l'adresse 192.168.4.1. La page suivante s'affichera alors où vous pourrez contrôler la maison intelligente.

Figure 3 : Capture d'écran du serveur Web

Conclusion :

Maintenant que vous pouvez contrôler les différentes parties du projet via un serveur Web, vous pouvez toujours configurer des automatisations sur le Nano programmez-le, par exemple pour utiliser le bouton comme contrôle. Assurez-vous cependant qu'aucun bloc (while ou delay) n'est utilisé dans la boucle() afin de ne pas interrompre le traitement des données par le serveur Web.

Avec ces automatisations et éventuellement des capteurs ou modules supplémentaires, vous pouvez mettre en œuvre et étendre votre propre petit projet de maison intelligente.

Amusez-vous à le reproduire :)

Pour les lecteurs ayant des connaissances avancées, cela vaut également la peine de jeter un œil au blog pirater un arbre, dans lequel le kit sapin de Noël est reprogrammé et vous pouvez programmer vos propres motifs.

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