Cuando me enteré del monitoreo de personas, de la oportunidad de ser parte de este sistema de monitoreo del clima, me emocioné y se hizo una estación meteorológica simple en un arduino nano y un módulo de ethernet.
Ella transmitió temperatura, presión y humedad al sitio. Funcionó mal, a veces se colgó, fue necesario reiniciar. Luego, el sensor de humedad murió y comencé a buscar un dispositivo alternativo. Observé esp8266 durante mucho tiempo, pero sabía muy poco al respecto. Lo que me detuvo fue que el código tenía que estar escrito en un entorno explorador desconocido para mí en un lenguaje desconocido para mí. Ya se ha publicado un dispositivo similar aquí, el dispositivo funcionaba con firmware shareware de Homes Smart, esta solución no me convenía. Más tarde descubrí que esp8266 puede ser amigo con bastante éxito de arduinoIDE. Empecé a buscar mucho en Google y, como resultado, busqué en Google los resultados que me convenían.
Espero que el artículo sea útil. Creo que se puede considerar como una guía general del montaje.
NodeMcu es una especie de placa de depuración para esp8266 (según tengo entendido). Con él conviene hacer prototipos de dispositivos en protoboards. Es conveniente subir el firmware desde el ArduinoIDE, todo sucede automáticamente. Naturalmente, se necesita ArduinoIDE para trabajar con esp8266. Habiendo preparado el entorno de trabajo, inmediatamente dibujé un diagrama, no fue difícil.
El sensor de presión y temperatura bmp180 se conecta vía i2c a SCL(gpio05) y SDA(gpio04).
Sensor de temperatura y humedad dht22 conectado a gpio02
La pantalla 1602 con un adaptador i2c soldado también se monta en scl y cda, en paralelo con el sensor de presión.
Potencia del sensor 3.3v, potencia de la pantalla 5v.
Un fotorresistor está conectado al pin A0, controla el brillo de la pantalla para que por la noche la pantalla no brille demasiado. La retroiluminación funciona con gpio14, que implementa el software PWM. Después de la etapa del transistor, la energía de la luz de fondo va directamente al parche A (ánodo) en la pantalla. está al lado del LED. Del adaptador de pantalla spi, debe quitar el puente que es responsable de la luz de fondo.
Foto prototipo
Fue más difícil con el código.
//arduino 181, ya sea enterrado #incluir
¿Qué puede hacer el dispositivo?
El dispositivo mide la temperatura, la presión (sensor bmp180) y la humedad (sensor dht22), muestra las lecturas en la pantalla y las envía al sitio de monitoreo público.
Cuando lo enciende por primera vez después del firmware, o en ausencia de redes wifi familiares, el dispositivo simula ser un punto de acceso de tipo abierto llamado ESP8266.
En el puerto com, el dispositivo envía esto: 
Debe conectarse desde su teléfono, computadora portátil o tableta a un punto llamado ESP8266 e ir a 192.168.4.1
Esta página se abrirá:
Presionamos el botón Configurar Wifi y llegamos a dicha página.
A continuación, seleccione su red, ingrese la contraseña, haga clic en Guardar. Listo, el dispositivo se reinicia y comienza a funcionar. Primero, la dirección ip y la dirección mac del dispositivo con el prefijo ESP se muestran en la pantalla y en el puerto com, debe usarse como la identificación del sensor al registrarse en el sitio de monitoreo público y después de 15 segundos, las primeras lecturas de sensores.
T1 - temperatura con bmp180
T2 - temperatura con dht22
P - presión atmosférica. Mostrado en mm. rt. Art., para el seguimiento de personas entra no recuerdo en qué unidades, se convierte a mm. rt. Arte. automáticamente.
H - humedad en porcentaje. 
En las líneas T2 y H herejía, porque el sensor dht22 no está conectado
De esta forma, el diseño funcionó durante un par de semanas, mientras pensaba lentamente en el dispositivo terminado.
Decidí ensamblar el dispositivo terminado en un módulo (el mismo está en nodemcu)
Rápidamente se divorció y grabó el tablero.
No tuve que cambiar el código en absoluto. Los números de puerto para los sensores son los mismos, solo necesita conectar un esp8266 desnudo de acuerdo con el esquema estándar para que pueda funcionar y pueda cargar el firmware. Recibí 3.3 voltios usando el estabilizador ams 1117 3.3v.
El dispositivo funciona con un cargador de teléfono de 5v. 2A. Pero un amperio, creo, será suficiente. 
Para el firmware, saqué un conector separado de 3 pines con contactos RX, TX y GND.
Flasheé el dispositivo terminado usando el adaptador usb - uart. Su ventaja es que tiene un interruptor de 5v-3.3v, aunque los expertos dicen que este interruptor solo funciona para la alimentación, y los niveles de rx y tx no cambian. Pero me funcionó todo sin conversión de nivel, probablemente porque el esp8266 es tolerante a 5v en rx tx, aunque funciona desde 3.3.
También en la placa terminada había un interruptor para ingresar al modo de firmware (control deslizante rojo, el control deslizante inferior para ingresar al modo de firmware. Conecté el control deslizante superior a gpio12, por si acaso, es posible cambiar los modos de visualización para el futuro, pero por ahora no se usa. No puedes ser inteligente, y solo pon un puente entre gpio0 y GND) 
Para el firmware, debe conectar el convertidor usb-uart de esta manera:
esp rx - uart tx
esp tx - uart rx
esp gnd - uart gnd
Luego, conecte gpio0 a tierra usando el control deslizante inferior del interruptor, presione el botón "Reiniciar" en la placa (ubicado en la parte superior), en el arduinoIDE, seleccione el puerto com deseado, la velocidad de descarga (115200 para la mayoría de las placas esp8266) y presione el botón Botón "Descargar".
Una vez completada la descarga, el dispositivo comenzará a funcionar, el interruptor de firmware debe volver a la posición APAGADO; de lo contrario, el dispositivo ingresará nuevamente al modo de firmware en el próximo reinicio o apagado.
Retirar el sensor dht22 muerto. Síntomas: muestra constantemente una humedad de 99.9, en clima seco puede mostrar menos. Murió en el otoño de 2016, después de haber trabajado correctamente durante toda la primavera y el verano. Era una semana de lluvias constantes, y en mi correo electrónico me cayó una carta de la vigilancia del pueblo, diciendo que su sensor marca lo mismo durante varios días seguidos. No cambié el sensor, simplemente lo oculté del dominio público hasta hace poco.
Creo que un cuerpo encogido es una posible razón para morir. Como base, se utilizó un huevo de Kinder Sorpresa. Se desarrolló una nueva carcasa más espaciosa y tecnológicamente avanzada a partir de una caja de enchufe y un tapón de tubería de alcantarillado. Aquí están ambos edificios uno al lado del otro:
No rehice la placa del sensor, solo reemplacé el dht22 muerto por uno vivo, lo cubrí con zaponlak y lo arreglé con moco térmico en la parte superior de la caja de la calle.
Así es como se ve la placa del sensor. Incluso puedes dibujar con un marcador.
esquema y apariencia
Arreglé los sensores en la ventana, el cable condujo a la habitación. La comida para llevar se podría haber hecho más grande y quitado de la unidad externa del aire acondicionado, pero esto es problemático. 
Metí las entrañas en un recinto de megatecnología desde una caja de conexiones para el cableado. No me molesté en sujetar, usé mocos térmicos. 
ensamblado 
Prueba de humedad superada con éxito. El sensor está vivo. 
Fue una experiencia útil para mí, finalmente sentí el esp8266 y obtuve un dispositivo de trabajo estable que me fue útil.
Espero que este artículo sea útil para alguien. Si tienes alguna dificultad o duda, escribe en un personal, te responderé.
Buenos días, lectores y vengan aquí. soy suscriptor del canal de youtube AlexGyver y viendo un video sobre "Monitoreo de plancha de PC",
Decidí repetir este producto casero, porque. Lo encontré bastante interesante, y siempre quise mostrar el estado del sistema de una manera difícil, en una pantalla adicional y no en un monitor de computadora. No quería hacer un árbol de Navidad con una computadora, así que decidí no instalar retroiluminación RGB, y también decidí abandonar los reobas caseros, porque. mi madre Gigabyte sabe perfectamente cómo controlar la velocidad del ventilador sin intermediarios usando BOIS.
Elegí y ordené los componentes más baratos propuestos por el autor:
Todo esto se ordena a un vendedor que vendría junto, en un solo paquete. Y un pequeño truco: si pone todo en la canasta, de un vendedor que tiene una tarifa de envío, y luego paga una vez, la tarifa de envío se cobrará 1 vez. (Y no para cada uno de los 3 productos).
4. No pedí un cable mini USB y lo soldé directamente al Arduino y lo conecté con cables (del punto 2) al conector USB interno. Pero no puedes sufrir y pide https://goo.gl/LA7sb3 es más fácil
Y empezó a esperar. Llegó todo bastante rápido, en 15 días. También hay un botón en el esquema, cuando está cerrado, se cambian las pantallas con información sobre el estado del sistema. Primero tomé esto: 
pero la idea resultó no ser muy buena, porque. no había nada para arreglarlo en el panel frontal de la computadora. Por lo tanto, en una tienda de electrónica local, se eligió un botón sin pestillo, con un accesorio conveniente para el estuche, así como un interruptor de palanca para apagar este "milagro" por la noche. Porque todo lo que está conectado al puerto USB de mi computadora está constantemente encendido y tiende a brillar y parpadear, apagándose solo al desconectar la computadora del tomacorriente.
En general, pasé varias horas montando este milagro del progreso tecnológico, cortando un lugar para la pantalla en la parte frontal de la computadora y taladrando agujeros para el botón y el interruptor de palanca. Además, para un trabajo completo, todo esto tenía que soldarse de acuerdo con el esquema y ejecutar un programa residente para monitorear los recursos de la computadora. Esto es lo que sucedió: 
Bueno, resultó bastante bien, casi como yo quería. Queda por eliminar pequeños problemas en el software que transmite temperaturas. Por alguna razón, se transmiten al máximo desde: estera del sensor. CPU, GPU, placas base, lo que dificulta monitorear la computadora en un estado tranquilo cuando las temperaturas inactivas no son altas.
Si alguien no puede descargar el código fuente de la página del sitio web de AlexGyver, aquí hay una nueva carga en mi sitio web: .
Después de hurgar en el programa, encontré muchas cosas que no me convenían y, en general, no funcionaban correctamente. Después de pasar un par de tardes, con la ayuda de amigos, descubrí un poco tanto en el código de boceto de Arduino como en el código de OpenHardwareMonitor, que en realidad transfiere los parámetros de salida a la pantalla. E hice cambios que me satisficieron.
Cambios en el programa OpenHardwareMonitor:
Cambios en el boceto para Arduino:
Se puede descargar un archivo con todos los cambios y fuentes aquí (como descubrimos empíricamente, los cambios en OpenHardwareMonitor funcionan bien en las placas base Gigabyte, como la mía, y lo más probable es que haya errores en las madres de otros fabricantes).
¡Todos los inviernos y gatos! 
¡Experimentos exitosos!
Seguimos desarrollando nuestra estación meteorológica.
Antes de pasar a la actualización, quiero aclarar un poco.
Uno de nuestros colegas me escribió preguntando por qué se introdujo el temporizador de vigilancia.
El temporizador de vigilancia se establece en caso de emergencia. Como muestra la práctica, el ENC28J60 no extrae más de (si la memoria no falla) 4 conexiones simultáneas. Teniendo en cuenta cuántas conexiones de servicio se producen constantemente para mantener la red en sí, y solo el tráfico restante creado por todo tipo de juguetes domésticos (por ejemplo, los televisores modernos escanean los hosts disponibles en la red y abren sus puertos), el diseño simplemente entra en un estado de estupor. . ENC28J60 no sabe cómo trabajar de forma independiente con protocolos de red y todo está implementado en bibliotecas. Tal vez sean solo ellos.
Revisé todas las bibliotecas disponibles y diferentes módulos (de repente matrimonio), pero no logré lograr un trabajo estable durante mucho tiempo. El período máximo fue de unas 3-4 semanas.
Es por esto que el "perro" gira allí y, en cuyo caso, tira del controlador. Después de eso el problema se fue.
Tampoco niego que hay ciertos matices o problemas en la red de mi casa. Pero como el problema era mío, puede surgir con otra persona. Solo he encontrado esta solución hasta ahora.
Que yo sepa, los chips Wiznet (W5100 y superiores) no tienen esto, o simplemente no lo buscaron bien.
Pasemos a la actualización.
Lo más importante es que nos estamos alejando del chip. ENC28J60 E ir a W5100. Traté de implementar todo en un chip antiguo, pero no hay suficiente memoria de microcontrolador debido a bibliotecas muy grandes para ENC28J60. Al usar un nuevo chip, estándar bibliotecas del desarrollador y todos los cambios realizados, queda aún más 20% memoria libre del microcontrolador ATMega328. ¡Y estos son bollos nuevos!
Esta versión (llamémosla la segunda) agrega la capacidad de transmitir lecturas de sensores de forma inalámbrica usando la frecuencia 433 MHz. Tomé los módulos mismos de los chinos, marcando XY-MK-5V. Quiero señalar que la calidad de transmisión está lejos de ser perfecta. Puede haber pérdida de señal, ruido, no posibilidad de transmisión simultánea, etc., etc. Pero su precio (menos de $ 1 por juego) compensa estas deficiencias. Te diré un secreto que son estos módulos (más baratos) que se encuentran en muchas estaciones meteorológicas de marca para uso doméstico. Vaya, ¿inesperado?
Comencemos con la estación base.
nos mudamos a Arduino UNO y Escudo Ethernet(primera versión) basada en el chip W5100. Esto es un sándwich y no tiene sentido describirlo. Describiré solo los contactos involucrados adicionalmente para los módulos. XY-MK-5V.
El módulo transmisor usa energía 5V, TIERRA(donde sin madre entonces) y D2 pin en el controlador. Editar contacto D2 (DATOS) puedes usar la funcion vw_set_tx_pin de la biblioteca vw.
A diferencia del boceto anterior, este utiliza dos bibliotecas adicionales:
#incluir
El boceto en sí
Texto oculto
#incluir
#incluir #incluir #incluir #incluir #incluir #incluir #incluir #define DHTTYPE DHT22 #define DHTPIN 5 DHT dht(DHTPIN, DHTTYPE); byte mac = (0x54, 0x34, 0x31, 0x31, 0x31, 0x31); servidor de caracteres = "narodmon.ru"; puerto int = 8283; Dirección IP ip(192,168,0,201); Cliente EthernetClient; BMP085 dps = BMP085(); largo Temperatura = 0, Presión = 0; flotante H, dP, dPt; bool intervalo = verdadero; EasyTransferVirtualWireET; struct SEND_DATA_STRUCTURE( byte ID; // Device ID int Temperature; // Temperatura float Pressure; // Presión float Humidity; // Humidity float dewPoint; // Punto de rocío/escarcha); transmisión SEND_DATA_STRUCTURE; void setup() ( // Inicializa el temporizador Watchdog wdt_disable(); delay(8000); wdt_enable(WDTO_8S); // Inicializa la consola Serial.begin(9600); // Inicializa el sensor DHT dht.begin(); // Inicializa el el módulo de 433 MHz ET.begin(detalles(emisión)); vw_set_ptt_inverted(true); vw_set_tx_pin(2); vw_setup(2000); // Inicie la red, si no esperamos los datos del servidor DHCP, entonces // asignarnos una dirección nosotros mismos if (Ethernet.begin(mac) == 0) Ethernet.begin(mac, ip); // Inicializar 1-Wire Wire.begin(); delay(200); // Inicializar BMP180 con ajuste de altura // dps.init (MODE_STANDARD, 3200, true); // Inicializa BMP180 dps.init(); Serial.println(Ethernet.localIP()); // Envía los primeros datos inmediatamente después de encender el dispositivo send_info(true ); ) // función punto de rocío NOAA // referencia (1) : http://wahiduddin.net/calc/density_algorithms.htm // referencia (2) : http://www.colorado.edu/geography/weather_station/Geog_site /acerca de.htm punto de rocío doble (doble centígrado, doble humedad) ( // (1) Presión de vapor de saturación = ESGG(T) doble RATIO = 373,15 / (273,15 + centígrado); doble RHS = -7.90298 * (RELACIÓN - 1); RHS += 5.02808 * log10(RELACIÓN); RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RELACIÓN))) - 1) ; RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RELACIÓN - 1))) - 1); lado derecho += log10(1013.246); // el factor -3 es para ajustar unidades - Presión de vapor SVP * humedad doble VP = pow(10, RHS - 3) * humedad; // (2) PUNTO DE ROCÍO = F(Presión de vapor) doble T = log(VP/0.61078); // retorno de var temporal (241.88 * T) / (17.558 - T); ) void send_info(bool eth) ( bool fail = true; while(fail) ( // Tratando de leer datos del sensor de humedad DHT hasta que // obtengamos el resultado. En el 90% de los casos todo funciona bien, pero necesitamos 100 % if((H = dht.readHumidity()) >= 0) ( // Obtiene la humedad y la temperatura del sensor BMP180 dps.getPressure(&Pressure); dps.getTemperature(&Temperature); // Calcula el punto de rocío si el la temperatura está afuera por encima de 0 grados Celsius // y espera un resultado por encima de 0, de lo contrario, emite 0. Esto es necesario // para no ser engañoso en la temporada de invierno. // dP = Temperatura>0?((dPt=punto de rocío(Temperatura*0.1, H))<0?0:dPt):0; dP = dewPoint(Temperature*0.1, H); // Отправляем данные в эфир 433 мГц broadcast.ID = 1; broadcast.Temperature = floor(Temperature*0.1); broadcast.Pressure = floor(Pressure/133.3*10)/10; broadcast.Humidity = floor(H*10)/10; broadcast.dewPoint = floor(dP*10)/10; ET.sendData(); delay(250); if(eth) { // Подключаемся к серверу "Народный мониторинг" if(client.connect(server, port)) { // Начинаем передачу данных // адрес_устройства_в_проекте, имя_устройства, GPS широта, GPS долгота client.print(F("#fe-31-31-0e-5a-3b#Arduino Uno#71.344699#27.200014\n")); // Температура client.print(F("#T0#")); client.print(Temperature*0.1); client.print(F("#Температура\n")); // Давление client.print("#P1#"); client.print(Pressure/133.3); client.print(F("#Давление\n")); // Влажность client.print("#H1#"); client.print(H); client.print(F("#Влажность\n")); // Точка росы\инея client.print("#T1#"); client.print(dP); client.print((dP <= 0)? F("#Точка инея\n"):F("#Точка росы\n")); //client.print(F("#Точка росы\n")); // Отправляем конец телеграммы client.print("##"); // Даем время отработать Ethernet модулю и разрываем соединение delay(250); client.stop(); } } // Останавливаем цикл, если передача завершена fail = !fail; break; } delay(250); } } void loop() { // Каждые 4 секунды сбрасываем сторожевой таймер микроконтроллера // Каждые 6 минут отправляем данные на "Народный мониторинг" // Каждые 30 секунд отсылаем данные в эфир 433 if(!(millis()%1000)) wdt_reset(); if(!(millis()%360000)) send_info(true); if(!(millis()%30000)) send_info(false); }
Se debe agregar una antena a los propios módulos. Para 433 MHz alambre de cobre normal es suficiente 17cm. Sin antena, puede olvidarse del funcionamiento normal.
Pasando a la parte más importante de esta actualización: la estación inalámbrica local
Para implementarlo (en mi rodilla), usé un análogo arduino nano(En la base ATMega328) y TFT mostrar en un chip ST7735S con permiso 128x160
Texto oculto
Pinout pantalla -> controlador
============================= LED | SCK 3.3V | SCK(13) SDA | MOSI(11) A0 | REINICIO DE CC(9) | RST(8)CS | CS (10) TIERRA | TIERRA VCC | 5V ============================El módulo receptor se conecta de la misma forma que el transmisor, sólo DATOS al pin D7.
Un par de fotos de como queda:
Texto oculto
Bosquejo del receptor
Texto oculto
#incluir
#incluir #incluir #incluir entero x, y; int w = 128, h = 160; tamaño pequeño; // 433 EasyTransferVirtualWire ET; struct SEND_DATA_STRUCTURE( byte ID; // Device ID int Temperature; // Temperatura float Pressure; // Presión float Humidity; // Humidity float dewPoint; // Punto de rocío/escarcha); transmisión SEND_DATA_STRUCTURE; int Registro_Temperatura = -1; flotar Log_Pressure = -1; flotar Log_Humidity = -1; flotante Log_dewPoint = -1; // TFT #define cs 10 #define dc 9 #define rst 8 char Temperatura, presión, humedad, punto de rocío; información de cadena; TFT TFTscreen = TFT(cs, dc, rst); void setup()( Serial.begin(9600); // Inicializa el módulo de 433MHz ET.begin(detalles(broadcast)); vw_set_ptt_inverted(true); vw_set_rx_pin(7); vw_setup(2000); vw_rx_start(); // Inicializa y configuración de visualización inicial TFTscreen.begin(); TFTscreen.setRotation(2); TFTscreen.background(0, 0, 0); // Dibujar elementos estáticos // 1. Visítenos TFTscreen.stroke(255, 255, 255); TFTscreen .setTextSize(1); TFTscreen.text(" ", 10, 10); // 2. Descripción de las lecturas de los sensores TFTscreen.text("mmHg", w/2+5, 80); TFTscreen.text ("% ", w/2+5, 100); TFTscreen.text("C", w/2+5, 120); emisión.Temperatura = 0; emisión.Presión = 0; emisión.Humedad = 0; emisión .punto de rocío = 0; TFTPrint(); ) void loop()( if(ET.receiveData())( if(broadcast.ID == 1) TFTPrint(); /* Serial.println(broadcast.Temperature); Serial.println(broadcast .Pressure); Serial.println(broadcast.Humedad); Serial.println(broadcast.dewPoint); Serial.println(); */ ) ) void changes(int size, int x , int y, bool up, bool clear = false) ( if(clear) TFTscreen.stroke(0, 0, 0); else (cambios(tamaño, x, y, !arriba, verdadero); TFTscreen.stroke((arriba)?0:255, 0, (arriba)?255:0); ) if((tamaño%2) == 0 )tamaño++; while(tamaño > 0) (TFTscreen.line(x, y, x+(tamaño--), y); ++x, (arriba)?--y:++y, --tamaño; ) /* while( tamaño > 0) (TFTscreen.line(x, y, (arriba)?x+tamaño-1:x, (arriba)?y:y+tamaño-1); ++x, ++y, --tamaño; ) */ ) int x_center(int w, int longitud, int tamaño) ( return floor((w-longitud*(tamaño*5)+tamaño*2)/2); ) int x_alignment_right(int w, int longitud, int tamaño) ( return ceil(w-longitud*(tamaño*5)+tamaño*2); ) void TFTPrint() ( tamaño = 3; // ================= ================================================= ============== // Mostrar lecturas de temperatura // ============================ = ================================================= == if(broadcast.Temperature != Log_Temperature) ( TFTscreen.setTextSize(size); // Sobrescribir datos obsoletos String info = String(Log_Temperature); info.concat(" C"); if(Log_Temperature > 0) info = " +"+info; info.toCharArray(Temperatura, info.longitud()+1); TFTscreen.stroke(0, 0, 0); TFTscreen.text(Temperatura, x_center(w, info.longitud()+1 , tamaño ), 35); // Salida de nuevas lecturas i información = Cadena (emisión. la temperatura); info.concat("C"); if(emisión.Temperatura > 0) info = "+"+info; info.toCharArray(Temperatura, info.longitud()+1); // Cambia el color del valor de la temperatura dependiendo de la temperatura misma int r, g = 0, b; if(emisión.Temperatura > 0) ( r = mapa(emisión.Temperatura, 0, 40, 255, 150); // Rojo b = mapa(emisión.Temperatura, 0, 40, 30, 0); // Cambiar tono para un cruce por cero más visual) else ( r = map(broadcast.Temperature, -40, 0, 0, 30); // Cambia el tinte para un cruce por cero más visual b = map(broadcast.Temperature, -40, 0, 150 , 255); // Azul ) TFTscreen.stroke(b, g, r); // ATENCIÓN: las posiciones de color están invertidas en la biblioteca, ¡BGR usa el lugar RGB! TFTscreen.text(Temperature, x_center(w, info.length()+1, size), 35); ) tamaño = 1; // ============================================== = ================================== // Visualización de lecturas de presión // ======== ================================================= ======================== if(broadcast.Pressure != Log_Pressure) ( TFTscreen.setTextSize(size); // Sobrescribir datos obsoletos info = String(Log_Pressure ); info.toCharArray(Presión, info.longitud()); TFTscreen.stroke(0, 0, 0); TFTscreen.text(Presión, x_alignment_right(w/2-5, info.length(), size), 80 ); // Salida de nuevas lecturas info = String(broadcast.Pressure); info.toCharArray(Pressure, info.length()); TFTscreen.stroke(255, 255, 255); TFTscreen.text(Pressure, x_alignment_right(w/ 2-5, info.longitud(), tamaño), 80); cambios(10, 106, 85, (emisión.Presión > Log_Pressure)?verdadero:falso); ) más (cambios(10, 106, 85, verdadero, verdadero); cambios (10, 106, 85, falso, verdadero); ) // =============================== =============================================== = / / Lecturas de humedad de salida // ================== ================================================= ============= if(broadcast.Humidity != Log_Humidity) ( TFTscreen.setTextSize(size); // Sobrescribir datos obsoletos info = String(Log_Humidity); info.toCharArray(Humedad, info.longitud()); Pantalla TFT.stroke(0, 0, 0); TFTscreen.text(Humedad, x_alignment_right(w/2-5, info.length(), size), 100); // Salida de información de nuevas lecturas = String(broadcast.Humidity); info.toCharArray(Humedad, info.longitud()); TFTscreen.stroke(255, 255, 255); TFTscreen.text(Humedad, x_alignment_right(w/2-5, info.length(), size), 100); cambios (10, 106, 105, (emisión. Humedad > Log_Humidity)? verdadero: falso); ) else ( cambios(10, 106, 105, verdadero, verdadero); cambios(10, 106, 105, falso, verdadero); ) // ================== ================================================= ============= // Mostrar punto de rocío\escarcha // ============================ ================================================== === if(emisión.puntorocío! = Log_dewPoint) ( TFTscreen.setTextSize(size); // Sobrescribir datos obsoletos info = String(Log_dewPoint); info.toCharArray(dewPoint, info.length()); TFTscreen.stroke(0, 0, 0); TFTscreen.text (dewPoint, x_alignment_right(w/2-5, info.length(), size), 120); // Mostrar nuevas lecturas info = String(broadcast.dewPoint); info.toCharArray(dewPoint, info.length()); TFTscreen.stroke(255, 255, 255);TFTscreen.text(dewPoint, x_alignment_right(w/2-5, info.length(), size), 120);changes(10, 106, 125, (broadcast.dewPoint > Log_dewPoint)?true:false); ) else ( changes(10, 106, 125, true, true); changes(10, 106, 125, false, true); ) // Actualizar los valores en los registros para más adelante comparación Log_Temperature = broadcast.Temperature; Log_Pressure = emisión.Presión; Log_Humidity = emisión.Humedad; log_dewPoint = broadcast.dewPoint; )
Las lecturas se muestran de forma bastante compacta, pero como muestra la práctica (y el consejo de mis camaradas): "el sabor y el color, incluso la esposa no es una amiga". Escuché un montón de consejos y sugerencias, pero se contradicen entre sí. Así que hazlo a tu gusto.
¡Me pareció que el diseño es la parte del proyecto que lleva la mayor parte del tiempo!
Texto oculto
Parte de los datos se fabrica para mostrar algunos elementos de diseño.
Los artefactos en la pantalla son polvo y otra suciedad acumulada durante mucho tiempo, la pantalla estuvo en... en algún lugar,... bueno, ¡no recuerdo de dónde lo saqué! ¡Déjame en paz!
El boceto tiene funciones de posicionamiento. Son bastante primitivos, pero te permiten lograr ciertos efectos.
El primero centra el texto y el segundo lo alinea a la derecha de la zona especificada. Todos los cálculos se realizan en relación con el tamaño del texto dado, en función de la expresión 1 tamaño = 1PX x 1PX segmento de fuente
La pantalla también muestra los elementos correspondientes a un aumento o disminución de uno u otro valor de lectura. Se muestran como triángulos. Pero en el código de función cambios hay una pantalla alternativa en forma de triángulos girados 45 grados. Si la lectura sube, el elemento es rojo; de lo contrario, es azul.
Por cierto, el color y el tono de la temperatura principal cambian según la temperatura misma. Una decisión bastante controvertida, pero en mi opinión, visualmente cómoda. Luché con eso por un tiempo y me di cuenta de que los valores en la función carrera, el objeto de visualización TFT, aparecen en el orden incorrecto. BGR lugar RGB. Esto es un error del desarrollador, bueno, o no entiendo algo.
PD: Todo es bastante interesante, pero en mi opinión merece un mayor desarrollo. Cosa que haremos en un rato.
Tenemos un servidor Zabbix implementado en nuestra organización para monitorear el estado de los servidores y las estaciones de trabajo. Debido a las peculiaridades del proceso técnico, el equipo se "mancha" en varias salas y se distribuye por el territorio de la empresa. Naturalmente, junto con los parámetros principales de las computadoras (funcionando/no funcionando), también quiero controlar el microclima en las salas de servidores. Al mismo tiempo, como de costumbre, las posibilidades son muy limitadas, y "eliminar" fondos significativos para sistemas complejos de monitoreo de temperatura (también incluyo tableros de control con sensores térmicos para UPS en rack de APC) es una búsqueda separada.
En la sala de servidores principal, todo es simple: se instala una placa de este tipo (comprada hace mucho tiempo por el predecesor junto con el equipo principal), se conecta un sensor térmico APC, se inicia un agente en Zabbix, todo funciona a través de SNMP . Aburrido :) Tampoco hay fondos para monitorear equipos de hardware remotos - ver arriba. Por lo tanto, se decidió ser inteligente, ahorrar el presupuesto y, al mismo tiempo, impulsar una nueva habilidad mediante la construcción de una solución "rodilla" simple y económica que, sin embargo, encaja en la infraestructura de monitoreo existente de Zabbix.
Componentes requeridos:
El montaje del dispositivo no es difícil. El módulo de red se coloca en la placa principal con un "sándwich", el sensor de temperatura se suelda a sus pines. Conexión del sensor: rojo +5 V, negro - tierra, amarillo - datos; entre +5V y Data soldamos una resistencia pull-up de 4,7 kOhm.
El pin de datos se selecciona en función de los pines utilizados por el módulo de red (D10 - SS; D11 - MOSI; D12 - MISO; D13 - SCK; D2 - IRQ).
Un rastrillo: en el prototipo del dispositivo, me encontré con un conflicto: los datos de temperatura se dieron al azar, "en dos a un tercio". La razón resultó ser que conecté un sensor térmico al pin 2 que, como más tarde descubrí en Internet, es utilizado por el módulo de red para generar una interrupción cuando llega un paquete. Reorganizado el 4: funcionó como un reloj.
Después de ensamblar el hardware, pasamos al software.
El dispositivo funcionará en la red y simulará ser un agente zabbix, para esto necesita una dirección MAC e IP. Decidimos cómo es más conveniente: codificar durante la programación, generar un MAC desde la dirección del sensor de temperatura y recibir IP a través de DHCP, etc. Fui de la manera más simple y codifiqué ambos parámetros.
El protocolo de intercambio con el servidor zabbix se describe en la documentación. Nuestro dispositivo responderá a dos comandos: agente.ping y env.temp(aquí hay espacio para una mayor creatividad, puede vincular cualquiera de los módulos de expansión disponibles para arduino, incluso un sensor de humedad, incluso luz, lo que su corazón desee). Jurará responder a todos los demás comandos con una respuesta estándar comprensible para el servidor zabbix.
Para aquellos que están comenzando desde cero (como yo), la programación de Arduino se realiza utilizando el IDE de Arduino, cuya instalación y configuración es elemental. Los componentes requieren para funcionar las bibliotecas UIPEthernet y OneWire, que se instalan y conectan al proyecto a través del menú Sketch - Incluir biblioteca - Administrar bibliotecas...
Si tiene otros componentes (por ejemplo, un módulo de red que no está en enc28j60, sino en un chip diferente), ¡se necesitarán otras bibliotecas!
El código para trabajar con el módulo de red y con el sensor de temperatura es típico, de Internet, con algunas suposiciones y simplificaciones.
Después de subir el código al controlador y conectar el cable ethernet, verificamos desde la consola:
$ zabbix_get -s 192.168.4.5 -k agente.ping 1 $ zabbix_get -s 192.168.4.5 -k env.temp 23.12 $ zabbix_get -s 192.168.4.5 -k bla-blah ZBX_NOTSUPPORTED
Rastrillo: la versión compilada de zabbix_get para Windows publicada en zabbix.com está desactualizada y usa un protocolo diferente (con el encabezado ZBXD\x01 en la solicitud del servidor). La versión de Linux está actualizada y el protocolo corresponde al código dado.
Todo funciona según lo previsto. En el panel de administración de zabbix, cree un nuevo host con la IP seleccionada, contiene dos claves, Numérico (sin firmar) agent.ping y Numérico (flotante) env.temp, disfrute el trabajo. Gráficos, disparadores: todo es como de costumbre.
Fuente de alimentación del dispositivo - a través de USB nativo. Carcasa - opcional: una caja de plástico adecuada, termorretráctil, cinta aislante azul.
Resolución del sensor: aproximadamente 0,06 (más precisamente, 1/16) ° С, precisión: cuando se sumerge en nieve derretida, mostró 0,19 ° С (tal vez habría caído más bajo, pero había poca nieve y todo se derritió rápidamente). Creo que para un dispositivo que vale $ 10 y los propósitos descritos, más que suficiente.
Bosquejo
#incluir
Saludos a todos, hoy les quiero hablar de una pequeña subrutina o utilidad, lo que les sea más conveniente, llamada "Port Monitor". Si ya está familiarizado con el IDE de Arduino, lo ha encontrado más de una vez y ha adivinado lo que se discutirá. Pero tómese su tiempo para irse, definitivamente tendrá algo para leer, ya que iremos desde lo básico hasta un análisis completo de su trabajo.
Y así, el "Port Monitor" es una pequeña subrutina Arduino IDE diseñada para recibir y transmitir datos desde Arduino. Debido al hecho de que Arduino IDE no tiene ningún medio para depurar bocetos, esta es la única forma de verificar si todo funciona correctamente y como debería.
La subrutina consta de una forma, al inicio, el IDE de Arduino le pasa el número del puerto COM con el que debe funcionar, luego de lo cual intenta conectarse a él y, si tiene éxito, comienza a escuchar y mostrar toda la información recibida.
El formulario Port Monitor en sí se puede dividir en tres partes: superior, central y más bajo.
En general, el formulario no es complicado, hay pocos elementos en él, es difícil confundirse. Esto concluye la descripción y comienza un análisis detallado.
Empezaremos con el Arduino.
Para transferir datos del Arduino al "Port Monitor", es necesario inicializar la clase Serial en la función de configuración () llamando a su método de inicio, pasando la velocidad y la configuración del puerto COM en el camino.
Sintaxis.
Serial.begin(velocidad, configuración);
¿Cuál es el bit de inicio, el bit de información, el bit de paridad, por qué la velocidad se mide en baudios? Se lo diré en otro artículo; de lo contrario, no será fácil digerir una cantidad tan grande de información y el artículo resultará ser no seas pequeño. Por ahora, usaremos la configuración estándar, donde la velocidad es de 9600 baudios por segundo, y el Arduino seleccionará automáticamente la configuración.
En total, obtuvimos lo siguiente:
Void setup() ( // Inicializar (iniciar) la clase Serial llamando a su método de inicio, especificando una velocidad de 9600 baudios por segundo. Serial.begin(9600); )
Una vez que todo esté listo, puede enviar datos utilizando los métodos print e println de la misma clase Serial.
Void loop() ( // Enviar "¡Hola mundo!". Serial.print("¡Hola mundo!"); // Enviar "¡Hola mundo!" "); // Dormir durante un segundo. delay(1000); )
Así, en el monitor del puerto, veremos una línea formada por dos "Hello World!" cada segundo ( ver foto arriba).
La clase Serial contiene otros métodos para trabajar con el monitor de puerto, pero en general los métodos print e println son suficientes en la mayoría de los casos.
Ahora intentaremos enviar los comandos desde el monitor del puerto al Arduino y usarlos, por ejemplo, para encender o apagar el LED.
La misma clase Serial y su método nos ayudarán con esto. leerCadena.
Y así al mando ALTO» encenderemos el led, y al mando « BAJO"Lo apagaremos.
Para enviar un comando, debe escribir texto en el campo ubicado en la parte superior del formulario y hacer clic en el botón "Enviar". Recibiremos comandos usando el método readString mencionado.
En total, deberías obtener lo siguiente.
Void setup() ( Serial.begin(9600); pinMode(13, OUTPUT); ) void loop() ( // Obtener comandos para encender/apagar el LED en el puerto 13. String str = Serial.readString(); / / Si el comando es "ALTO", enciende el LED si (str == "ALTO") digitalWrite (13, ALTO); // Si el comando es "BAJO", apaga el LED si (str == "BAJO") digitalWrite(13, LOW); // Dormir por 1 segundo. delay(1000); )
Entonces, sin mucho tormento, puede crear la enésima cantidad de comandos y procesarlos en Arduino.
Finalmente, hablaremos sobre la forma en que se intercambia la información entre el “Port Monitor” y el Arduino. No importa qué datos pase del Arduino al monitor de puerto, todo se convierte a una cadena de formato ASCII ( ver tabla), lo mismo ocurre al enviar datos desde el monitor del puerto al Arduino. Aquellos. cuando envía el número diez, en realidad no está enviando un número, sino una cadena que consta de dos caracteres, uno y cero.
Por ejemplo, al enviar un byte igual a 128, el monitor de puerto en realidad recibirá tres bytes.
Al ejecutar el método println, obtendremos 5 bytes en total. Donde los primeros tres serán descritos anteriormente, y los dos adicionales son los bytes CR (13) y LF (10), es decir, una nueva línea.
Después de mirar la tabla de caracteres ASCII, muchos notarán que contiene solo caracteres latinos, como resultado de lo cual, al enviar, por ejemplo, "¡Hola mundo!", En el monitor del puerto, obtendremos algún tipo de krakozyabry. Aprovechando esta oportunidad, quiero anunciar, escrito por los autores del portal, que comprende no solo las inscripciones en ruso, sino también en otros idiomas.
Y ahora, después de leer todo lo que escribí aquí, finalmente, puede decir qué es "Postfix", la lista desplegable en la parte inferior del monitor de puerto.
Un sufijo es un byte o bytes, según la opción que elija, que se agregarán a los datos que ingresó en el campo de envío.
Por ejemplo, escribiendo el número 128 en el campo de envío y haciendo clic en el botón "Enviar", obtendremos lo siguiente:
Eso es todo. Escriba en los comentarios lo que no entiende, y en nuevos artículos intentaremos describirlo con más detalle.
Bueno, el próximo artículo será sobre cómo escribir su propio monitor de puerto en Delphi.
Buena suerte y buena suerte para ti.
Habilite javascript para que funcionen los comentarios.
