SmartHome im Weihnachtshaus - AZ-Delivery

0 comentario

El kit Casa de Navidad tiene el Nano El microcontrolador solo tiene funciones limitadas, como encender la luz usando el botón al lado de la puerta.

En esta publicación de blog, el conjunto se transformará en una pequeña casa inteligente con función WiFi con aspecto navideño utilizando un mini microcontrolador D1.

Ferretería

Para la implementación necesita:

Kit Casa de Navidad

D1miniESP8266 (también son posibles otras versiones)

Módulo de sensor DHT22

Kit de árbol de Navidad LED (también son posibles otras versiones)

Conecte el convertidor de nivel al D1mini utilizando los cables de silicona de la siguiente manera:

Figura 1: Cableado del D1mini

Para el lado derecho puedes utilizar una regleta de enchufes D1mini. Si dispone de las herramientas adecuadas, una conexión engarzada es, por supuesto, la opción profesional.

Después de ensamblar el kit de la Casa de Navidad según las instrucciones, abra el panel del techo en el costado de la caja de la batería.

Ahora conecte el relé y el DHT22 a las siguientes conexiones en el Nano-Escudos puestos.

DHT22	Escudo	relevo	Escudo
+	V11	-	G7
FUERA	T11	+	(V 7)
-	G11	S	T7

Los módulos del kit ya instalados permanecen en las conexiones descritas en las instrucciones.

La tira de LED WS2812 no se utiliza en este blog, sino que el árbol de Navidad LED se controla a través del relé. Esto también se puede utilizar ajustando la cantidad de LED.

Conecte el árbol de LED de la siguiente manera:

árbol	relevo	Escudo
VCC		v
Tierra	NO
	COM	GRAMO

Figura 2: Conexiones para fuente de alimentación de 5V

Nota:

Si suministra el relé y el árbol de Navidad al proyecto a través de una fuente de voltaje externa (por ejemplo, una batería en la parte posterior), los componentes adicionales pueden hacer que el regulador de baja caída se caliente significativamente si hay un alto requerimiento de corriente. Esto puede provocar potencialmente daños. Si el requisito actual es superior a 500 mA, utilice una fuente de voltaje independiente o un convertidor reductor.

Los relés y el sensor DHT22 ahora se pueden fijar en casa, por ejemplo, con cinta adhesiva de doble cara.

Continúe dejando abierta la parte trasera del techo para los siguientes pasos.

programas

desde el Nano no tiene una interfaz WLAN, se requiere el D1 mini. La única tarea de esta persona es poner a disposición el servidor web para el control. Luego la información se envía a la interfaz UART. Nano, que asume todo el control de los componentes.

Dado que los dos microcontroladores intercambian datos a través de la interfaz UART, la conexión debe separarse para flashear un microcontrolador.

Preparando el IDE de Arduino

Si es la primera vez que trabaja con microcontroladores, aún necesitará descargar el controlador adecuado para poder transferir el programa a la placa.

Puede descargar el archivo de instalación del controlador apropiado aquí descargar.

Para el D1 mini necesitas un paquete adicional. Para instalarlo, copie el siguiente enlace en el IDE de Arduino en: Archivo->Preferencias->URL del administrador de placas adicionales:

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

e instale el paquete ESP32 en la administración de la placa Arduino IDE.

Además, se requieren bibliotecas para poder controlar la pantalla LCD, el módulo LED y el sensor DHT22:

Adafruit_NeoPixel

Cristal líquido_I2C

DHT_sensor_library

Puedes instalar las bibliotecas usando la gestión de bibliotecas integrada en el IDE de Arduino o descargarlas como .zip usando el enlace de Github y dirigirte a
Bosquejar > incluir biblioteca > Agregar biblioteca .zip…

incorporar.

Código Nano

Descarga el siguiente programa 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);
}

El código completo puede aquí ser descargado.

Explicación:

Al principio, se integran las bibliotecas y se crean macros para los nombres de los pines de los módulos conectados.

A esto le sigue la inicialización de las variables globales y los objetos de las bibliotecas.

El siguiente método lee los valores del sensor y genera una cadena json a partir de ellos, que luego se envía al D1mini a través de la interfaz serie (UART) para que los valores climáticos se puedan mostrar en el sitio web. Dado que el LDR es sólo una resistencia y, por lo tanto, no está calibrado en fábrica, los valores límite reales pueden variar. Puede configurar esto en la función map(). (900 por debajo del límite 0%; 100 límite superior 100%)

La siguiente función readLine() forma una cadena a partir de los caracteres individuales recibidos a través de la interfaz UART. Los caracteres se suman aquí hasta que comienza una nueva línea (\n). La función es necesaria para una posterior evaluación de datos.

En setup() se llaman los métodos de inicio de las bibliotecas y se configura la IO del relé como salida.

El loop() comienza ejecutando el manejarSensores funcionar cada segundo. El retraso de tiempo se implementa aquí con una comparación usando la función millis(). Esto significa que el loop() no está bloqueado.
Luego se evalúa la cadena con la entrada del servidor web y luego el LED se configura en el color seleccionado, el texto se muestra en la pantalla y finalmente el relé se configura en el estado transmitido.

Servidor web:

Ahora sigue el código html que muestra el servidor web:

<HTML>
<cabeza>
<meta juego de caracteres ="UTF-8">
<título>Control de la casa de Navidad AZ</título>

<estilo>
cuerpo { familia de fuentes:Arial; margen: 20px; fondo:#f0f0f0; }
#box { relleno:20px; fondo:blanco; radio-frontera:10px; ancho:300px; }
etiqueta { peso de fuente:negrita; }

/* Conmutador de palanca */
.cambiar { posición: relativo; mostrar: bloque en línea; ancho: 50px; altura: 24px; }
.cambiar entrada.entrada { mostrar:ninguno; }
.control deslizante {
posición: absoluto; cursor: puntero; genial: 0; izquierda: 0; correcto: 0; abajo: 0;
color de fondo: #ccc; transición: .4s; radio-frontera: 24px;
}
.control deslizante:antes {
posición: absoluto; contenido: ""; altura: 18px; ancho: 18px;
izquierda: 3px; abajo: 3px; color de fondo:blanco;
transición: .4s; radio-frontera: 50%;
}
entrada.entrada:comprobado + .control deslizante { color de fondo: #4CAF50; }
entrada.entrada:comprobado + .control deslizante:antes { transformar: traducirX(26 píxeles); }
</estilo>

</cabeza>

<cuerpo>
<varios identificación ="caja">
<h1> Casa de Navidad </h1>
<h2> hogar inteligente</h2>

<etiqueta>Iluminación:</etiqueta><hermano>
<entrada.entrada tipo ="colores" identificación ="colores" en cambio ="enviarColor()"><hermano><hermano>

<etiqueta>Pantalla:</etiqueta><hermano>
<entrada.entrada tipo ="texto" identificación ="t1" longitud máxima ="16"><hermano><hermano>

<entrada.entrada tipo ="texto" identificación ="t2" longitud máxima ="16"><hermano><hermano>

<botón al hacer clic="enviarTexto()">Anuncios</botón><hermano><hermano>

<etiqueta>Árbol:</etiqueta><hermano>
<etiqueta clase ="interruptor">
<entrada.entrada tipo ="casilla de verificación" identificación ="alternar" en cambio ="enviarAlternar()">
<español clase ="control deslizante"></español>
</etiqueta><hermano><hermano>

<h3>Clima:</h3>
Brillo: <español identificación ="v1">--</español> % <hermano>
Temperatura: <español identificación ="v2">--</español> °C <hermano>
Humedad: <español identificación ="v3">--</español> %H <hermano>

</varios>

<guión>
// ----------------- Cargar valores iniciales -----------------
ventana.ventana.cargar = función() {
buscar ("/getState")
    .entonces(r => r.json())
    .entonces(datos => {
      documento.getElementById("colores").valor = datos.color;
      documento.getElementById("t1").valor = datos.texto1;
      documento.getElementById("t2").valor = datos.texto2;
      documento.getElementById("alternar").marcado = datos.toggle;
    });
};

// ---- Enviar RGB ----
función enviarColor(){
dejar columna = documento.getElementById("colores").valor;
buscar ("/setColor?hex=" + codificarURIComponente(columna));
}

// ---- Enviar mensajes de texto ----
función enviarTexto(){
dejar tx1 = documento.getElementById("t1").valor;
dejar tx2 = documento.getElementById("t2").valor;
buscar ("/setText?t1=" +tx1+ "&t2=" +tx2);
}

// ---- Enviar interruptor ----
función enviarAlternar(){
dejar punto = documento.getElementById("alternar").comprobado? 1 : 0;
buscar ("/setToggle?estado=" + st);
}

// ---- Obtener valores de ESP ----
establecerIntervalo(()=>{
buscar ("/valores")
    .entonces(respuesta => respuesta.json())
    .entonces(datos =>{
      documento.getElementById("v1").innerHTML = datos.v1;
      documento.getElementById("v2").innerHTML = datos.v2;
      documento.getElementById("v3").innerHTML = datos.v3;
    });
},1000);
</guión>

</cuerpo>
</HTML>

Básicamente, cada archivo html está en uno. cabeza y cuerpo dividido. La configuración tiene lugar en la cabeza. Esto también incluye el estilo de los elementos.

El cuerpo también contiene los elementos HTML individuales, como campos de entrada y botones. guión Parte que contiene métodos.
Cuando presiona un botón, se ejecuta un método asignado, que luego transmite la entrada al microcontrolador.

Sin embargo, las funciones y estructura HTML exactas no se discutirán más aquí.

código D1mini

Descarga el programa completo (descarga al final) en el 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;
  }
}

El código completo puede aquí ser descargado.

Explicación:

Como en el código del Nano, Al principio se integran las bibliotecas y se inicializan los objetos y variables globales.

El código html también se carga aquí en la memoria. El archivo html completo se ha omitido aquí para mayor claridad.

Los siguientes métodos son las funciones de devolución de llamada del servidor web, con las que se leen las entradas y se muestran cuando se realiza un cambio.

La función readLine básicamente corresponde a la de Nanoprograma utilizado. La única diferencia es que aquí se utiliza la función yield(), que permite que las funciones se ejecuten en segundo plano. Esto significa que no hay problemas con el servidor web debido a procesos en segundo plano bloqueados.

Se inicia un punto de acceso en setup() para que pueda conectarse directamente al D1mini y no sea necesaria una conexión WiFi.
Luego se asignan los métodos de devolución de llamada y se inicia el servidor web.

El bucle() vuelve a estar estructurado de forma análoga al programa del Nano. Aquí la cadena recibida no se evalúa, sino que se envía directamente al servidor porque ya está en formato json.

Después de que ambos microcontroladores hayan sido actualizados, conecte el mini conjunto D1 al conector de clavija UART libre en el Nano-Escudo. Asegúrese de que esté conectado correctamente (puede utilizar el pin GND como referencia en el cableado anterior).

Después de cargar, conéctese a la red abierta "SmartHome". Si recibe una notificación de que la red no tiene acceso a Internet, habilítela Mantener la conexión para la red. Una vez conectado a la red, abra el navegador en el dispositivo conectado e ingrese la dirección 192.168.4.1. A continuación se mostrará la siguiente página donde podrá controlar la casa inteligente.

Figura 3: Captura de pantalla del servidor web

Conclusión:

Ahora que puedes controlar las partes individuales del proyecto a través de un servidor web, aún puedes configurar automatizaciones en el Nano prográmelo, por ejemplo, para utilizar el botón como control. Sin embargo, asegúrese de que no se utilicen bloques (mientras o retraso) en el bucle() para no interrumpir el procesamiento de los datos por parte del servidor web.

Con estas automatizaciones y posiblemente sensores o módulos adicionales, puedes implementar y ampliar tu propio pequeño proyecto de hogar inteligente.

Diviértete replicándolo :)

Para lectores con conocimientos avanzados, también merece la pena echar un vistazo al blog. hackear un árbol, en el que se reprograma el kit del árbol de Navidad y puedes programar tus propios patrones.

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