estación climática con Arduino y pantalla ILI9486 – Capítulo 2

estación climática con Arduino y pantalla ILI9486

Arlex

Diseñador de tarjetas Pcb en las modalidades SMD, THT y combinaciones en una capa o dos capas, Diseñador de circuitos electrónicos análogos o digitales, Programador en sistemas computacionales y arquitectura electrónica, con diplomados en informática, electrónica digital, electrónica análoga, programador en lenguaje CC++ y programador HTML-SCC.

09/04/2023

Construye una estación climática con Arduino y pantalla ILI9486

Bienvenido al código de estación climática. Este es un proyecto que utiliza un conjunto de sensores para medir diferentes variables climáticas, como la temperatura, la humedad y la presión atmosférica. El objetivo es recopilar datos precisos y en tiempo real para monitorear las condiciones climáticas locales.

En este proyecto, utilizaremos un microcontrolador para recopilar y procesar los datos de los sensores, y luego enviarlos a una plataforma en línea para su almacenamiento y visualización.

En los siguientes pasos, explicaré detalladamente cada sección del código, desde la inicialización de los sensores hasta el envío de datos a la plataforma en línea. Cubriremos los aspectos más importantes del código, incluyendo la configuración del hardware, la lectura de los sensores, el procesamiento de datos y la transmisión de los datos a través de internet.

Este proyecto es una excelente manera de aprender cómo utilizar sensores y microcontroladores para recopilar datos, así como también una introducción al Internet de las cosas (IoT). ¡Comencemos!

INCLUSIÓN DE LAS LIBRERÍAS.

#include <Adafruit_GFX.h>       // Biblioteca para gráficos generales (necesaria para la biblioteca Adafruit_ILI9341)
  #include <MCUFRIEND_kbv.h>      // Incluimos la biblioteca "MCUFRIEND_kbv.h" para controlar una pantalla LCD TFT con controlador ILI9341
  MCUFRIEND_kbv tft;              // se Crea una instancia de la librería MCUFRIEND_kbv
  #include <SFE_BMP180.h>         // Incluimos la biblioteca "SFE_BMP180.h" para interactuar con el sensor de presión y temperatura BMP180
  #include <Wire.h>               // Incluimos la biblioteca "Wire.h" para permitir la comunicación I2C entre dispositivos conectado
  #include <DHT.h>                // Incluimos la biblioteca "DHT.h" para interactuar con los sensores de humedad y temperatura
  #include <SPI.h>                // Incluimos la biblioteca "SPI.h" para permitir la comunicación con dispositivos periféricos 
                                  // utilizando el protocolo de comunicación serie (SPI)
 

Este bloque de código contiene varias líneas que se refieren a la inclusión de diferentes bibliotecas en nuestro proyecto. Una biblioteca es un conjunto de funciones predefinidas que se pueden utilizar para llevar a cabo diferentes tareas en un proyecto.

En la primera línea, se incluye la biblioteca «Adafruit_GFX.h», que es una biblioteca para gráficos generales. Es necesaria para la biblioteca «Adafruit_ILI9486», que se utiliza para controlar una pantalla LCD TFT con controlador ILI9486.

La segunda línea incluye la biblioteca «MCUFRIEND_kbv.h», que nos permite controlar una pantalla LCD TFT con controlador ILI9486. En la tercera línea, se crea una instancia de la biblioteca MCUFRIEND_kbv.

La cuarta línea incluye la biblioteca «SFE_BMP180.h», que nos permite interactuar con el sensor de presión y temperatura BMP180. La quinta línea incluye la biblioteca «Wire.h», que permite la comunicación I2C entre dispositivos conectados.

//==============asignar nombres legibles por humanos a algunos valores comunes de color de 16 bits========================================================//

  #define BLACK    0x0000
  #define BLUE     0x001F
  #define RED      0xF800
  #define GREEN    0x07E0
  #define CYAN     0x07FF
  #define MAGENTA  0xF81F
  #define YELLOW   0xFFE0
  #define WHITE    0xFFFF
  #define GRAY     0xC618
  #define DARKGRAY 0x6B0C

Este bloque de código asigna nombres legibles por humanos a algunos valores comunes de color de 16 bits. En otras palabras, estamos definiendo ciertos colores y asignándoles un nombre que sea fácil de entender.

Por ejemplo, la línea #define BLACK 0x0000 asigna el valor hexadecimal 0x0000 al nombre «BLACK», lo que significa que podemos usar el nombre «BLACK» en lugar de 0x0000 en el resto del código. Lo mismo ocurre con los otros colores, como «BLUE», «RED», «GREEN», «CYAN», «MAGENTA», «YELLOW», «WHITE», «GRAY» y «DARKGRAY».

Estos nombres de color se pueden utilizar más adelante en el código para dibujar formas o escribir texto en la pantalla LCD TFT. Al asignar nombres legibles por humanos a los valores de color, el código se vuelve más fácil de leer y entender para cualquier persona que esté trabajando en el proyecto.

//============Definición de una macro para obtener el valor mínimo entre dos números======================================================================//
//======se usan para evitar conflictos de nombres entre diferentes bibliotecas o partes de un programa====================================================//

  #ifndef min                           // Si no está definido el nombre "min", definimos una macro que toma dos valores y devuelve el valor mínimo entre ellos.
  #define min(a,b) (((a)<(b))?(a):(b))  // La macro se define utilizando el operador ternario para comparar los dos valores y devolver el valor más pequeño.
  #endif                                // Finalmente, se cierra la directiva "#ifndef" con "#endif".

Este bloque de código define una macro que se utiliza para obtener el valor mínimo entre dos números. La macro se define utilizando la sintaxis de las directivas de preprocesador de C++.

La macro se llama «min» y toma dos argumentos: «a» y «b», que representan los dos valores que se comparan. Luego, se utiliza el operador ternario «?:» para comparar los dos valores y devolver el valor más pequeño.

La directiva «#ifndef» se utiliza para evitar conflictos de nombres entre diferentes bibliotecas o partes de un programa. En este caso, se comprueba si el nombre «min» ya está definido en el programa. Si no lo está, se define la macro para que pueda ser utilizada más adelante. Si el nombre «min» ya está definido, la directiva «#ifndef» se saltará y el programa continuará sin definir la macro.

Esta macro es útil para comparar valores en el código que se utiliza para controlar la pantalla LCD TFT basada en la ILI9486.

//=============Definir los pines para la pantalla (ADMEGA 328P)=============================================================================================//

  #define LCD_RESET A4  //Alternativamente, se puede conectar simplemente al pin de reinicio de Arduino
  #define LCD_CS A3     //El chip select se conecta a la entrada analógica 3
  #define LCD_CD A2     //command/data va a analógico 2
  #define LCD_WR A1     //la escritura en el LCD va al pin analógico 1
  #define LCD_RD A0     //lcd read va a analógico 0

Este bloque de código define los pines que se utilizarán para la pantalla LCD TFT basada en la ILI9486 en un Arduino Mega 328P.

Se definen cinco pines en total:

LCD_RESET: Este pin se utiliza para reiniciar la pantalla. Se conecta al pin A4 del Arduino.

LCD_CS: Este pin se utiliza para seleccionar el chip de la pantalla. Se conecta al pin A3 del Arduino.

LCD_CD: Este pin se utiliza para seleccionar si los datos que se están enviando a la pantalla son comandos o datos. Se conecta al pin A2 del Arduino.

LCD_WR: Este pin se utiliza para escribir datos en la pantalla. Se conecta al pin A1 del Arduino.

LCD_RD: Este pin se utiliza para leer datos de la pantalla. Se conecta al pin A0 del Arduino.

Es importante que se conecten los pines de manera adecuada para que la pantalla y el Arduino puedan comunicarse correctamente. Los pines que se utilizan pueden variar dependiendo del modelo de Arduino o de la pantalla TFT que se esté utilizando.

//==================DEFINE EL PIN DATOS TEMP Y HUMEDAD======================================================================================================//

  #define  degC false       //define una constante llamada "degC" con valor "false", lo que indica que la unidad de temperatura utilizada en el programa es Fahrenheit en lugar de Celsius.
  #define  degF true        //Definición de constante booleana para la unidad de temperatura Fahrenheit
  #define DHTPIN 22         //Pin digital conectado al sensor DHT
  #define DHTTYPE DHT11     //sensor DHT utilizado en el código como DHT11                         
  DHT dht(DHTPIN, DHTTYPE); //Crear un objeto de sensor DHT

Este bloque de código está definiendo algunas constantes y variables que se utilizarán para interactuar con un sensor de temperatura y humedad.

Primero, se definen dos constantes booleanas: «degC» y «degF», que se utilizan para indicar si la unidad de temperatura utilizada es Celsius o Fahrenheit. En este caso, la constante «degC» se establece en «false», lo que indica que se utilizarán grados Fahrenheit.

Luego, se definen dos constantes numéricas: «DHTPIN» y «DHTTYPE». «DHTPIN» es el número del pin digital de Arduino al que está conectado el sensor de temperatura y humedad DHT. En este caso, se establece en 22. «DHTTYPE» es el tipo de sensor DHT que se está utilizando. En este caso, se establece en DHT11.

Por último, se crea un objeto de sensor DHT llamado «dht», que utiliza los valores de «DHTPIN» y «DHTTYPE» para inicializar el sensor.

//==================SE DEFINE LOS PINES SDA Y SCL  COMO ENTRADA DE DATOS BMP180==============================================================================//

  SFE_BMP180 bmp180;        //Declaración del objeto BMP180

//==================VARIABLE PARA IDENTIFICACION DE ICONOS EN LA PANTALLA TFT================================================================================//

  uint16_t g_identifier;          //condicion para enrutar los iconos desde las pestañas

//==================VARIABLES PARA LOS SENSORES DHT11 Y SENSOR BMP180========================================================================================//

  float LDR;                        //condicion para lectura del sensor LDR
  double PresionNivelMar=1013.25; //presion sobre el nibel del mar en mbar

El primer bloque se refiere a la definición de los pines SDA y SCL para la comunicación I2C con el sensor BMP180. SDA es el pin de datos y SCL es el pin de reloj. Estos pines se definen como entradas de datos en el código.

El segundo bloque se refiere a la variable g_identifier, que se utiliza para identificar los diferentes iconos que se muestran en la pantalla TFT. Esta variable se utiliza para enrutar los iconos desde las pestañas.

El tercer bloque define las variables para los sensores DHT11 y BMP180. La variable LDR se utiliza para la lectura del sensor LDR, mientras que la variable PresionNivelMar se utiliza para almacenar la presión sobre el nivel del mar en mbar.

//==================SE INICIA LA PANTALLA Y CONFIGURACION ===================================================================================================//

  void setup() {                        //Configuración inicial del programa y la pantalla TFT
    
  
  dht.begin();                        //Inicialización del sensor DHT.
  Serial.begin(9600);                 //Inicio de la comunicación serial a 9600 baudios
  tft.fillScreen(BLACK);              // Limpiar la pantalla y mostrar la imagen
  g_identifier = tft.readID();        //Identificación de pantalla con g_identifier
  uint32_t when = millis();           //Medición del tiempo de inicio de la comunicación serial
  Serial.print("Serial took " + String((millis()- when)) +"ms to start");   //Medición del tiempo de inicio de la comunicación serial
  uint32_t ID = tft.readID();         //Lectura de identificación de pantalla
  Serial.print("ID = 0x");            //Impresión de la identificación de la pantalla en formato hexadecimal
  Serial.print(ID, HEX);              //imprime en la consola serie el valor de la variable ID en formato hexadecimal
  if (ID == 0xD3D3) ID = 0x9481;      // Corrección para ciertas pantallas
  tft.begin(ID);                      //Configuración de la pantalla TFT
  Serial.println("DHT11 test!");      //Prueba del sensor DHT11
  tft.fillScreen(BLACK);              // Limpiar la pantalla y mostrar la imagen
  tft.setRotation(0);                 // establece posicion vertical con pines hacia abajo
  tft.fillRect(0, 0, 230, 40, BLUE);  // rectangulo azul a modo de fondo de encabezado 
  tft.setTextColor(WHITE);            // color de texto en blanco
  tft.setTextSize(2);                 // escala de texto en 2
  tft.setCursor(13,15);               // ubica cursor 
  tft.print("ESTACION CLIMATICA");    // imprime texto
  tft.setCursor(0,60);                // ubica cursor
  tft.setTextSize(2);                 // escala de texto en 2
  tft.print("  TEMPERATURA");         // imprime texto 
  tft.setCursor(195,60);              // ubica cursor
  tft.setTextSize(2);                 // escala de texto en 2
  tft.print("HUMEDAD");               // imprime texto
  tft.setCursor(0,285);               // ubica cursor
  tft.setTextSize(2);                 // escala de texto en 2
  tft.print(" RAYOS UV");             // imprime texto
  tft.setCursor(95,285);              // ubica cursor
  tft.print("    HPA");               // imprime texto
  tft.setCursor(165,285);             // ubica cursor
  tft.print("   ALTIMETRO");          // imprime texto
 
//======================INICIO DEL SENSOR BMP180 Y COMPROBACION DE ERRORES======================================================================================//
  
  if (bmp180.begin())                                 //Verificación de inicio exitoso del sensor BMP180
  Serial.println("BMP180 iniciado correctamenten");   //Mensaje de confirmación de inicio del BMP180
  else                                                //si la condición en el if no se cumple, se ejecutará el bloque de código dentro del else.
  {
  Serial.println("Error al iniciar el BMP180");       //Mensaje de error al iniciar el BMP180
  while(1);                                           // bucle infinito
  } 
  }

Este bloque de código se encarga de realizar la configuración inicial del programa y la pantalla TFT. En primer lugar, se inicializa el sensor DHT con dht.begin(). A continuación, se inicia la comunicación serial con Serial.begin(9600) a una velocidad de 9600 baudios. Luego, se configura la pantalla TFT con tft.begin(ID), donde ID es la identificación de la pantalla leída con tft.readID(). Si la identificación de la pantalla coincide con una cierta identificación, se realiza una corrección. Después, se imprime un mensaje de prueba del sensor DHT11 en la consola serial.

A continuación, se configura la pantalla TFT con diversos comandos. Primero, se borra la pantalla con tft.fillScreen(BLACK). Luego, se establece la rotación de la pantalla en 0 grados con tft.setRotation(0). A continuación, se dibuja un rectángulo azul en la parte superior de la pantalla para formar un encabezado con tft.fillRect(0, 0, 230, 40, BLUE). A continuación, se configura el color y la escala del texto con tft.setTextColor(WHITE), tft.setTextSize(2), y se establece la posición del cursor con tft.setCursor(x,y). Luego, se imprime texto en la pantalla TFT con tft.print().

Finalmente, se inicia el sensor BMP180 con bmp180.begin() y se verifica si se inició correctamente con if (bmp180.begin()). Si el inicio es exitoso, se imprime un mensaje de confirmación. Si no se inicia correctamente, se imprime un mensaje de error y se entra en un bucle infinito.

este artículo se ha presentado el código de configuración inicial del programa y la pantalla TFT para la estación climática con Arduino y pantalla ILI9486. Se han definido los pines SDA y SCL como entrada de datos BMP180, se ha creado un objeto BMP180 y se han declarado variables para la identificación de iconos en la pantalla TFT y para los sensores DHT11 y BMP180.

Además, se ha iniciado la pantalla TFT y se ha realizado la identificación de pantalla con g_identifier. Se ha configurado la pantalla TFT, se ha realizado una prueba del sensor DHT11 y se ha verificado el inicio exitoso del sensor BMP180.

Contine en el capitulo 3 y continuara viendo el resto del código para la estación climática con Arduino y pantalla ILI9486, les invitamos a leer el siguiente artículo donde se abordará la lectura de los sensores y la visualización de los datos en la pantalla TFT.

¡Gracias por leer este artículo y esperamos verlos en el siguiente!

 

 

Te gusta el articulo? compártelo en tus redes!!!

Quizás también te interese leer…

1 Comentario

  1. Maykol Rey

    Que buen proyecto colega, gracias por ayudarme a difundir la educación en Kicad.

Enviar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *