Bienvenida al curso

1

Enlaces del taller IoT

2

Qué aprenderás sobre el desarrollo de hardware con Arduino

Introducción al hardware libre

3

¿Qué es Arduino y qué placas hay?

4

¿Cómo se desarrolla el Hardware?

5

¿Cuál es el software para diseño mecánico?

6

Elección del software a utilizar

7

Limitaciones de Arduino y qué es el hardware libre

8

Reto 1: Para un proyecto de IoT, ¿Cuál tarjeta Arduino utilizarías?

9

¿Cómo funciona el Curso de Desarrollo de Hardware con Arduino?

10

Lista de Materiales o Componentes a Utilizar

Sensores, Actuadores y Procesadores

11

Sensores, actuadores y procesadores

12

Diferentes tipos de sensores según la salida

13

Diferentes tipos de sensores según la aplicación

14

Diferentes tipos de actuadores

Introducción a la electrónica

15

Diferencias entre electricidad y electrónica

16

Tipos de componentes electrónicos

17

Más tipos de componentes electrónicos

18

Limitando la corriente para evitar quemar un led

Manos a la obra

19

Puertos de un arduino y sus funciones

20

Qué es un protoboard

21

Estructura general de un programa en Arduino y hello world con un LED

22

Variables y Constantes Globales

23

Manejo de librerías y funciones

24

Manejo de valores analógicos: uso del potenciómetro

25

Uso del monitor serial

26

PWM y señales analógicas

27

Un control de color RGB e intensidad lumínica para una lampara de mesa

28

Uso de push buttons

29

Monitor de temperatura con Arduino (uso de LM35 y un lcd 16x2)

30

Continuando con el monitor de temperatura con Arduino

31

Finalizando con el monitor de temperatura con Arduino

32

Reto: Crea tu semáforo con Arduino

Automatización de procesos

33

Cómo generar movimiento y uso de motores

34

Cómo generar movimiento y servomotores

35

Agregando un potenciométro para controlar la posición del Servomotor

36

Robot evasor de obstáculos

37

Continuando con el Robot evasor de obstáculos

38

Terminando con el Robot evasor de obstáculos

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Finalizando con el monitor de temperatura con Arduino

31/38
Recursos

Ahora que tenemos la lectura de la temperatura, vamos a mostrarla sin necesidad de tener conectado el Arduino a nuestra Computadora.

Aportes 33

Preguntas 9

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Si tienes el display LCD1602 con módulo I2C

I2C es un puerto y protocolo de comunicación serial. El módulo I2C es usado para reducir el número de cables para conectar el display. De los 4 pines que tiene los que nos interesan son el SDA y SCL que irán conectados en los SDA y SCL del arduino en la parte de comunicación. En mi caso están en los pines 20(SDA) y 21(SCL) ya que es un mega 2560.
Yo instale esta librería para mi sketch: https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

el display con modulo I2C:

conexión SDA y SCL:

Sketch

// librería para LCD1602 (LCD 16 caracteres 2 líneas) con módulo I2C
#include <Wire.h>
#include <LiquidCrystal_I2C.h>


// definimos el objeto lcd
// en la dirección 0x27, le especificamos que son 16 caracteres y 2 líneas
LiquidCrystal_I2C lcd(0x27, 16, 2);


//libreria DHT sensor library Adafruit
#include "DHT.h" 

#define DHTPIN 2     // pin usado para recibir la medición
#define DHTTYPE DHT11   // impirtante verificar que sea el sensor que estamos usando
 
// Inicializamos el sensor DHT11
DHT dht(DHTPIN, DHTTYPE);


void setup() {
  // Inicializamos comunicación serie
  Serial.begin(9600);
 
  // Inicializamos el sensor DHT
  dht.begin();

  // Inicializamos el LCD,
  lcd.begin();
  
}

void loop() {

  // Esperamos 2 segundos entre cada medida del sensor
  delay(2000);

 
  // Leemos la humedad relativa
  float h = dht.readHumidity();
  // Leemos la temperatura en grados centígrados (por defecto)
  float t = dht.readTemperature();
  // Leemos la temperatura en grados Fahrenheit
  float f = dht.readTemperature(true);
 
  // Comprobamos si ha habido algún error en la lectura
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Error obteniendo los datos del sensor DHT11");
    return;
  }
 
  // Calcular el índice de calor o sensación térmica en Fahrenheit
  float hif = dht.computeHeatIndex(f, h);
  // Calcular el índice de calor o sensación térmica en grados centígrados
  float hic = dht.computeHeatIndex(t, h, false);


  //mensajes LCD
  lcd.clear(); // limpiamos LCD
  
  lcd.setCursor (0, 0); // vamos al inicio de la linea 1
  lcd.print("Humedad: ");
  lcd.print(h);
  
  lcd.setCursor (0, 1); // vamos al inicio de la linea 2
  lcd.print("Temp: ");
  lcd.print(t);
  

  //mensajes Serial 
  Serial.print("Humedad: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print(f);
  Serial.print(" *F\t");
  Serial.print("Sensación Térmica: ");
  Serial.print(hic);
  Serial.print(" *C ");
  Serial.print(hif);
  Serial.println(" *F");
 
}

Circuito

No es mucho, pero es trabajo honesto:

#include <LiquidCrystal.h>

int tempC;
const int sensorTemp = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
}

void loop()
{
 tempC = analogRead(sensorTemp);
 tempC = map(tempC, 20, 358, -40, 125);
 Serial.println(tempC);
 lcd.setCursor(0, 0);
 lcd.print("Temperatura:");
 lcd.setCursor(0, 1);
 lcd.print(tempC);
 lcd.setCursor(4, 1);
 lcd.print("grados C");
 delay(1000);
 lcd.clear();
  
}```

Métanle a los servers de streaming, a cada rato se pausan los videos, y no es mi internet.

#include <LiquidCrystal.h>

LiquidCrystal lcd (7,6,5,4,3,2);

#include <DHT.h>
#include <DHT_U.h>

int SENSOR = 8;
int TEMPERATURA;
int HUMEDAD;
int temperatura_inicial;
int temperatura_final;
int delta_temperatura;

DHT dht (SENSOR, DHT11);

void setup() 
{
  lcd.begin (16,2);
  dht.begin ();
  Serial.begin (9600);
}

void loop() 
{
  TEMPERATURA = dht.readTemperature();
  HUMEDAD = dht.readHumidity();
  temperatura_final = TEMPERATURA;
  delta_temperatura = temperatura_final - temperatura_inicial;

  if (temperatura_inicial < temperatura_final)
  {
    lcd.setCursor (0,0);
    lcd.print ("Subiendo");
    lcd.setCursor (0,1);
    lcd.print (TEMPERATURA);
  }
  else if (temperatura_inicial > temperatura_final)
  {
    lcd.setCursor (0,0);
    lcd.print ("Bajando");
    lcd.setCursor (0,1);
    lcd.print (TEMPERATURA);
  }
  else
  {
    lcd.setCursor (0,0);
    lcd.print ("Se mantiene");
    lcd.setCursor (0,1);
    lcd.print (TEMPERATURA);
  }
  delay (1000);
  lcd.clear();

  temperatura_inicial = temperatura_final;
  Serial.println ("inicial es:");
  Serial.println (temperatura_inicial);
  Serial.println ("final es:");
  Serial.println (temperatura_final);
  Serial.println ("diferencia es:");
  Serial.print (delta_temperatura);
  Serial.println (" °C");```
<#include <FastIO.h>
#include <I2CIO.h>
#include <LCD.h>
#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>
#include <LiquidCrystal_SR.h>
#include <LiquidCrystal_SR2W.h>
#include <LiquidCrystal_SR3W.h>

int tempC;
const int sensorTemp = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  lcd.begin(20, 4);
}

void loop() {
  // put your main code here, to run repeatedly:
  tempC = analogRead(sensorTemp);
  tempC = tempC*0.34;
  Serial.println(tempC);
  lcd.setCursor(0,0);
  lcd.print("Temperatura");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  
  if (tempC < 30){
    lcd.setCursor(0,3);
    lcd.print(":'v");
    }
  else{
    lcd.setCursor(0,3);
    lcd.print("Huele a carnitas");
    }

  delay(1000);
  lcd.clear();
  
}> 

![](

Les comparto mi código bien documentado para su entendimiento, aunque para controlar el LC uso la interfaz I2C,

/*
 * Sensor de temperatura LM35 con pantalla con LCD 16x2
 * Acortes.co
*/
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>  


float tempC; // Variable para almacenar el valor obtenido del sensor (0 a 1023)
int pinLM35 = A0; // Variable del pin de entrada del sensor (A0)
LiquidCrystal_I2C lcd(0x27, 16, 2);  //Establece la direccion del LCD 0x27 de 16 caracteres y 2 lineas


void setup() 
{
  // Configuramos el puerto serial a 9600 bps
  Serial.begin(9600);
  lcd.init();   //Inicializa la pantalla 
  lcd.backlight();

}

void loop() 
{
  // Con analogRead leemos el sensor, recuerda que es un valor de 0 a 1023
  tempC = analogRead(pinLM35); 
   
  // Calculamos la temperatura con la fórmula
  tempC = (5.0 * tempC * 100.0)/1024.0; 

  // Envia el dato al puerto serial
  Serial.print(tempC);
  // Salto de línea
  Serial.print("\n");
  //Enviamos el dato al LCD
  lcd.clear();
  lcd.setCursor(0,0);  //Posición Caracter 1,Fila 1 para el texto
  lcd.print ("*  Temperatura *");
  lcd.setCursor(4,1);   //Posición Caracter 5,Fila 2 para el valor 
  lcd.print(tempC);
  lcd.setCursor(11,1); //Posición Caracter 12,Fila 2 para la C
  lcd.print("C");
  
  // Esperamos un tiempo para repetir el loop
  delay(2000);
}

Utilizando el sensor de temperatura en un proyecto que hice de un Invernadero Inteligente: https://www.youtube.com/watch?v=mtfQvV8-1qY

Saludos

ayuda por favor
he revisado las conexiones , el programa y no me funciona
tambien cambie el display y no quiere funcionar
dentro del programa envie un blink al pin 13 para revisar que no sea falla del arduino y el led 13 prende y apaga correctamente pero el mensaje en el display no sale y el display brilla y da contraste correctamente
alguna sugerencia??

![](

<#include<LiquidCrystal.h>
int tempC;
int tempU = 0;
String tempV = "CONSTANT";
const int sensorTemp  = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);


void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
  // put your main code here, to run repeatedly:
tempC = analogRead(sensorTemp);
tempC = tempC*0.48828125;

if (tempU == tempC){
  tempV = "CONSTANT";
  tempU = tempC;
}else if (tempU>tempC){
  tempV = "DOWN";
  tempU = tempC;
}else{
  tempV = "UP";
  tempU = tempC;
}

Serial.println(tempC);
Serial.println(tempV);
Serial.println(tempU);
lcd.setCursor(0,0);
lcd.print("Temperatura:");
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Temperature:");
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
}>

Logré hacer el reto pero me quedó una duda: en el loop de mi código, está declarado

  temp_anterior = temp;

al final del mismo. O sea, después de los if. Si pongo esta misma parte antes de declarar el valor de temp, funciona igual. Pero si lo pongo entre el valor de _temp _y los _if _solo marca Temperatura estable ¿Alguno sabe por qué?

Lo configuré para que diga cuándo la temperatura está estable y cuando sube o baja, y diga la diferencia entre la actual y la anterior.

También, al principio, marca que temp_anterior vale 0.0 pero después toma el valor que le corresponde ¿es así?

#include <DHT.h>
#include <DHT_U.h>
#include <LiquidCrystal.h>

const int temp_pin = 9;
DHT dht(temp_pin, DHT11);

float temp, temp_anterior, diferencia;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() 
{
  dht.begin();
  lcd.begin(16, 2);
}

void loop() 
{
  temp = dht.readTemperature();
  diferencia = temp - temp_anterior;
  
  if(temp == temp_anterior)
  {
    lcd.setCursor(0,0);
    lcd.print("Temp. estable");
    lcd.setCursor(0,1);
    lcd.print(temp);
  }
  
  if(temp > temp_anterior)
  {
    lcd.setCursor(0,0);
    lcd.print("Temp. subiendo");
    lcd.setCursor(0,1);
    lcd.print(temp);
    lcd.print("-");
    lcd.print(temp_anterior);
    lcd.print("=");
    lcd.print(diferencia);
  }
  
  if(temp < temp_anterior)
  {
    lcd.setCursor(0,0);
    lcd.print("Temp. bajando");
    lcd.setCursor(0,1);
    lcd.print(temp);
    lcd.print("-");
    lcd.print(temp_anterior);
    lcd.print("=");
    lcd.print(diferencia);
  }
  
  delay(3000);
  lcd.clear();

  temp_anterior = temp;
}




¿Cómo conectar un display LCD?

Me aparece el error “LiquidCrystal” does not a name type
Ayuda D:

Así quedo mi proyecto de temperatura

no logro subir las fots de mis proyectos 😦

Planeo agregarle una alarma para cuando llegue a niveles críticos, pero mientras aquí está el desafío cambia de idioma a inglés y español

#include<LiquidCrystal.h>
int tempC;
const int sensor = A0;
int beftemp;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  Serial.begin(9600); 
  lcd.begin(16, 2);
}

void loop() {
  beftemp = tempC;
  
  tempC = analogRead(sensor);
  tempC = tempC*.48828125;
  Serial.println(tempC);
  varTemp();
  lcd.clear();

  
}

void varTemp(){
  if(tempC==beftemp){
    lcd.setCursor(0,0);
    lcd.print("Temp estable");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grados C");
    delay(1000);
    
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Stable temp");
   
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grades C");
    delay(1000);
    lcd.clear();
  }

  else if(tempC>beftemp){
    lcd.setCursor(0,0);
    lcd.print("Aumento de temp");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grados C");
    delay(1000);
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Temp rise");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grades C");
    delay(1000);
    lcd.clear();
  }

  else{
    lcd.setCursor(0,0);
    lcd.print("Bajando temp");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grados C");
    delay(1000);
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Lowering temp");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(2,1);
    lcd.print("Grades C");
    delay(1000);
    lcd.clear();
  }

}

Se debe de tomar en cuenta el tamaño de las variables para evitar errores de desbordamiento:

#include <LiquidCrystal.h>

unsigned long currentTemperature = 0;     // LM35 2 a 150 °C
unsigned int pastTemperature = 0;
const int temperatureSensor = A0;


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // put your setup code here, to run once:
  lcd.begin(16, 2);
}

void loop() {
  // put your main code here, to run repeatedly:
  currentTemperature = analogRead(temperatureSensor);

  currentTemperature = currentTemperature * 500 >> 10;              // 1706 bytes

  char temperatureString[17];
  sprintf(temperatureString, "Temperatura:%d C", currentTemperature);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(temperatureString);
  
  lcd.setCursor(0, 1);
  if(currentTemperature > pastTemperature)
    lcd.print("En aumento");
  else if(currentTemperature < pastTemperature)
    lcd.print("En descenso");
  else
    lcd.print("Estable");
    
  pastTemperature = currentTemperature;
  delay(1000);
}
#include <LiquidCrystal.h>

int tempC;
int temperatura1;
int temperatura2;
const int sensorTemp= A0;
LiquidCrystal lcd(12,11,5,4,3,2);

void setup() {
  lcd.begin(16,2);
}

void loop() {
  tempC = analogRead(sensorTemp);
  tempC = tempC * 0.48828125;
  temperatura1 = tempC;
  lcd.setCursor(0,0);
  lcd.print("Temperatura: ");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  delay(500);
  if(temperatura1 > temperatura2)
  {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Aumenta");
    delay(500);
  } else if (temperatura2 > temperatura1)
  {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Disminuye");
    delay(500);
  }
  temperatura2 = temperatura1;
  lcd.clear();

}```

Buenas noches compañeras y compañeros!

Les comparto el proyecto prototipado y el código.

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

#define DHTPIN 2 //Pin digital para sensor
#define DHTTYPE DHT11 //Sensor DHT11

float temp;
float hum;
float tempNow = 0; 

LiquidCrystal_I2C lcd(0x3f,16,2); //Crear el objeto lcd  dirección  0x3F y 16 columnas x 2 filas
DHT dht(DHTPIN, DHTTYPE); // Crear objeto dht con los parametros antes definidos

void setup() 
{
  Serial.begin(9600);
  dht.begin(); //Inicializa sensor
  lcd.init();  // Inicializar el LCD
  lcd.backlight();  //Encender la luz de fondo
  

}

void loop() 
{
  hum= dht.readHumidity(); //Humedad Relativa
  temp = dht.readTemperature(); //De 0°C a 100°C
  
  lcd.setCursor(0,0);
  lcd.print("Temp:");
  lcd.setCursor(5,0);
  lcd.print(temp); // En esta parte mostramos la primer lectura
  lcd.setCursor(10,0);
  lcd.print(char(223)); // Simbolo de ° en ASCII
   lcd.setCursor(11,0);
  lcd.print("C");

  lcd.setCursor(0,1);
  lcd.print("Humedad:"); // Ya que el DHT11 lo trae incorporado, demosle uso
  lcd.setCursor(8,1);
  lcd.print(hum);
  lcd.setCursor(13,1);
  lcd.print("%");

  

  if (temp > tempNow) // Condición si la temperatura sube
  { 
    lcd.clear(); 
    lcd.print("Temp:");
    lcd.setCursor(5,0);
    lcd.print(temp);
    lcd.setCursor(10,0);
    lcd.print(char(223));
    lcd.setCursor(11,0);
    lcd.print("C - Subiendo");
    tempNow = temp; // Almacenamos la temperatura "actual" 
  }
  else if (temp < tempNow) // Condición si la temperatura sube
  {
    lcd.clear();
    lcd.print("Temp:");
    lcd.setCursor(5,0);
    lcd.print(temp);
    lcd.setCursor(10,0);
    lcd.print(char(223));
    lcd.setCursor(11,0);
    lcd.print("C - Bajando");
    tempNow = temp; // Almacenamos la temperatura "actual" 
  }
  else
  
  lcd.scrollDisplayLeft(); 
 
  delay(1000);
}

Algunas salvedades:

  • El sensor es un DHT11, las librerías las conseguí en guithub

  • El display LCD usa el bus I2C, las librerías tambien las consegui en guithub.
    Espero les sea de utilidad!

Buenos días compañeras y compañeros!

Les comparto el proyecto realizado en tinkercad, junto con una lista de materiales y el código. Más adelante subiré la versión “real” donde usaré algunos componentes distintos.


float tempC; // Para almacenar temp en °C
int sensRead; // Para alamcenar la lectura analogica (0 a 1023) del sensor
const int sensor = A0;

LiquidCrystal lcd(12,11,5,4,3,2);
  
void setup()
{
  Serial.begin(9600);
  lcd.begin(16,2);
}

void loop()
{
  sensRead = analogRead(sensor);
  tempC = map(sensRead,0,1023,0,5000); // Uso de funcion MAP para transformar valores analaogico a mV
  tempC = (tempC-500)/10; // El datasheet del sensor TMP36 (no LM35) muestras que esta es la formula correcta para obtener el valor en °C

  
  lcd.setCursor(0,0);
  lcd.print("Temperatura:");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  delay(1000);
}

Algunas salvedades:

  • El sensor es un TMP36 no LM35, el valor de temperatura se calcula distinto
  • Use una resitencia de 160ohms para el led de retroiluminació ya que el voltaje directo es muy alto

Espero les sea de utilidad!

![](

#include<LiquidCrystal.h>
int tempC;
int tempU = 0;
String tempV = "CONSTANT";
const int sensorTemp  = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);


void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
  // put your main code here, to run repeatedly:
tempC = analogRead(sensorTemp);
tempC = tempC*0.48828125;

if (tempU == tempC){
  tempV = "CONSTANT";
  tempU = tempC;
}else if (tempU>tempC){
  tempV = "DOWN";
  tempU = tempC;
}else{
  tempV = "UP";
  tempU = tempC;
}

Serial.println(tempC);
Serial.println(tempV);
Serial.println(tempU);
lcd.setCursor(0,0);
lcd.print("Temperatura:");
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Temperature:");
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
}

<code>
```



[](https://www.youtube.com/watch?v=s0012kx21K8)


https://www.youtube.com/watch?v=s0012kx21K8


#include<LiquidCrystal.h>
int tempC;
int tempU = 0;
String tempV = “CONSTANT”;
const int sensorTemp = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
// put your main code here, to run repeatedly:
tempC = analogRead(sensorTemp);
tempC = tempC*0.48828125;

if (tempU == tempC){
tempV = “CONSTANT”;
tempU = tempC;
}else if (tempU>tempC){
tempV = “DOWN”;
tempU = tempC;
}else{
tempV = “UP”;
tempU = tempC;
}

Serial.println(tempC);
Serial.println(tempV);
Serial.println(tempU);
lcd.setCursor(0,0);
lcd.print(“Temperatura:”);
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“Temperature:”);
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
}

https://www.youtube.com/watch?v=s0012kx21K8

![](``
#include<LiquidCrystal.h>
int tempC;
int tempU = 0;
String tempV = “CONSTANT”;
const int sensorTemp = A0;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
// put your main code here, to run repeatedly:
tempC = analogRead(sensorTemp);
tempC = tempC*0.48828125;

if (tempU == tempC){
tempV = “CONSTANT”;
tempU = tempC;
}else if (tempU>tempC){
tempV = “DOWN”;
tempU = tempC;
}else{
tempV = “UP”;
tempU = tempC;
}

Serial.println(tempC);
Serial.println(tempV);
Serial.println(tempU);
lcd.setCursor(0,0);
lcd.print(“Temperatura:”);
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“Temperature:”);
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.setCursor(4,1);
lcd.print(tempV);
delay(1000);
lcd.clear();
}

Para el ejercicio propuesto hay que comparar la temperatura a lo largo del tiempo y si es menor a la anterior la temperatura baja, si es mayor sube. Espero les sirva.

¿Què pasa si usamos el modulo de LCD?
Tendriamos que hacer modificaciones en el codigo o ajustar los componentes.

Si usaras una interfaz i2c para lcd… Sería mejor.

Listo
Mi programa obtiene una referencia de la temperatura cada cierto tiempo (estaria bueno obtener el valor a cierta hora del día para comparar), despues de esto compara el valor.

#include <LiquidCrystal.h>

int tempC = 0;
const int pinAnalog = A0;
int tempActual = 0;
int constant = 120;
LiquidCrystal lcd(12, 11, 7, 6, 5, 4);//(Enable, Enable)

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  lcd.begin(16, 2);
  regTempActual();
}

void loop() {
  // put your main code here, to run repeatedly:
  tempC = analogRead(pinAnalog)* 0.488228125;
  
  if(tempActual<tempC)
  {
    lcd.clear();
    //Serial.println(tempC);
    lcd.setCursor(0,0);
    lcd.print("Temp Subiendo");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(9,1);
    lcd.print("Ref:");
    lcd.setCursor(13,1);
    lcd.print(tempActual);
    delay(500);
  }
  else if(tempActual > tempC)
  {
    lcd.clear();
    //Serial.println(tempC);
    lcd.setCursor(0,0);
    lcd.print("Temp Bajando");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(9,1);
    lcd.print("Ref:");
    lcd.setCursor(13,1);
    lcd.print(tempActual);
    delay(500);
  }
  else
  {
    lcd.clear();
    //Serial.println(tempC);
    lcd.setCursor(0,0);
    lcd.print("Temp Ambiente");
    lcd.setCursor(0,1);
    lcd.print(tempC);
    lcd.setCursor(9,1);
    lcd.print("Ref:");
    lcd.setCursor(13,1);
    lcd.print(tempActual);
    delay(500);
  }

  constant = constant - 1;
  //Serial.println(constant);
  if(constant == 0)
  {
    constant = 120;
    regTempActual();
  }
  
}

int regTempActual()
{
  tempActual = (analogRead(pinAnalog)* 0.488228125);
  return tempActual;
}```

Con el siguiente LCD no hay necesidad de tantas conexiones https://www.adafruit.com/product/772, además es azul 😃

No tenia sensor de temperatura asi que lo complete con la practica pasada.

yo he montado alcoholimetro con pantalla LCD 🙂🙂 https://www.youtube.com/watch?v=7w9ziw0N2T0

Mas sencillo el display lcd 1602 con el modulo I2c. Ahorra mucho cable.