Archivo de la categoría: Sensores

Sensor de temperatura LM35 y arduino


Vamos a ver como poder realizar mediciones de temperatura con nuestro Arduino y el sensor LM35. Dicho sensor es un sensor analógico de la casa Texas Instruments, que nos permite realizar medidas de temperatura de una forma bastante precisa a través de las entradas analógicas de nuestro Arduino (pines A0-A5) sin necesidad de emplear ninguna librería especifica para su programación.

Encapsulados LM35

LM35

 

 

 

 

 

 

 

 

 

 

Como se puede ver es un sensor que presenta únicamente 3 pines (VCC, GND y Data), por ello su conexión es muy sencilla. Además presenta las siguientes características:

  • Está calibrado directamente en grados Celsius.
  • Rango de medición de -55ºC a 150ºC.
  • La tensión de salida es proporcional a la temperatura. Esto quiere decir que 1ºC equivale a 10mV.
  • Presenta una precisión garantizada de 0.5ºC a 25ºC.
  • Presenta un rango de alimentación entre 4 y 30V.
  • Presenta baja impedancia de salida.
  • Presenta baja corriente de alimentación (60uA).
  • No necesita de circuitos adicionales para su calibración.
  • Presenta un coste bastante reducido.

Aquí podéis ver una imagen de como conectaríamos este sensor a nuestro Arduino para poder realizar las mediciones de temperatura:

LM35 fritzing

Como siempre os dejo los archivos Fritzing de este ejemplo, el datasheet del sensor y el código empleado para su programación. Lo podéis descargar desde este enlace: http://www.mediafire.com/?atycg43ubfnnunn

Aquí tenéis un código de ejemplo, de como obtener tanto el voltaje leído por el sensor, como los grados centígrados y los grados fahrenheit, además de mostrar los valores máximos y mínimos para cada una de las medidas mencionadas.

/* Sketch de ejemplo para testear el sensor de temperatura analógico LM35
 Escrito por Regata para www.tallerarduino.wordpress.com

 MODO DE CONEXIÓN DEL SENSOR

 Conectamos el pin 1 que corresponde a la alimentación del sensor con los 5V del Arduino
 Conectamos el pin 2 que corresponde al pin de datos del sensor con cualquier pin analógico del Arduino A0
 Conectamos el pin 3 que corresponde al pin de masa (GND) del sensor con el pin GND del Arduino

*/

int temp = 0;  //Pin analógico A0 del Arduino donde conectaremos el pin de datos del sensor LM35
float maxC = 0, minC = 100, maxF = 0, minF = 500;  //Variables para ir comprobando maximos y minimos

void setup()
{
  Serial.begin(9600);  //Iniciamos comunicación serie con el Arduino para ver los resultados del sensor
                       //a través de la consola serie del IDE de Arduino
}

void loop()
{
  float gradosC, gradosF;  //Declaramos estas variables tipo float para guardar los valores de lectura

  gradosC = (5.0 * analogRead(temp) * 100.0) / 1024;  //Esta es la funcion con la que obtenemos la medida del sensor
                                                      // en ºC

  gradosF = (gradosC * 1.8) + 32;  //Multiplicando los ºC por 1.8 y luego sumando 32 obtenemos grados Fahrenheit

  //Mostramos mensaje con valores actuales de temperatura, asi como maximos y minimos de cada uno de ellos
  Serial.print("Medidas actuales\n");
  Serial.print("C: ");
  Serial.print(gradosC);
  Serial.print("\tF: ");
  Serial.print(gradosF);
  //Comprobacion de maximos y minimos de temperatura
  if (maxC < gradosC)
    maxC = gradosC;
  if (gradosC < minC)
    minC = gradosC;
  if (maxF < gradosF)
    maxF = gradosF;
  if (gradosF < minF)
    minF = gradosF;
  Serial.print("\nMedidas maximas\n");
  Serial.print("C: ");
  Serial.print(maxC);
  Serial.print("\tF: ");
  Serial.print(maxF);
  Serial.print("\nMedidas minimas\n");
  Serial.print("C: ");
  Serial.print(minC);
  Serial.print("\tF: ");
  Serial.print(minF);
  Serial.print("\n\n");
  delay(2000);  //Usamos un retardo de 2 segundos entre lectura y lectura
}

Aquí podéis ver una captura de las medidas actuales que toma el sensor, así como las medidas mínimas y máximas capturadas por el sistema:

Captura Sensor LM35

Espero que os sirva de ayuda la entrada!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

sensor de temperatura tmp36 y arduino


En esta nueva entrada vamos a ver como usar un sensor de temperatura analógico (emplea uno de los pines analógicos) modelo TMP36 con nuestra placa Arduino, dicho sensor es de la casa Analog Devices y permite realizar unas medidas de temperatura bastante precisas y a un muy reducido coste.

Foto Sensor TMP 36 GZ

Como podéis ver el sensor empleado es de tipo TO-92 (encapsulado como el DS18B20 o el de algunos transistores). Además se caracteriza por ser un sensor que es muy empleado para realizar medidas de temperatura y es muy sencillo de emplear (no hacen falta librerías para su uso). Es un sensor que se puede alimentar entre un rango de voltaje que va desde los 2.7V hasta los 5.5V, viene calibrado directamente en grados centígrados (ºC), presenta un factor de escala lineal de 10 mV/ºC (esto es la relación entre el cambio en la señal de salida y el cambio en la señal de la medida, es decir, cada 10 mV aumenta 1 ºC). Las características generales son:

Caracteristicas TMP36

Aquí os dejo un enlace para que podáis descargaros el datasheet del sensor de temperatura, el esquema en fritzing de conexionado y el sketch de Arduino: http://www.mediafire.com/?c26yr7fk48my0fw

Os pongo el esquema para la conexión del sensor a Arduino:

Conexion Fritzing TMP36

Aquí tenéis un código de ejemplo, de como obtener tanto el voltaje leído por el sensor, como los grados centígrados y los grados fahrenheit, además de mostrar los valores máximos y mínimos para cada una de las medidas mencionadas.

/* Sketch de ejemplo para testear el sensor de temperatura analógico TMP36
 Escrito por Regata para www.tallerarduino.wordpress.com

 MODO DE CONEXIÓN DEL SENSOR

 Conectamos el pin 1 que corresponde a la alimentación del sensor con los 5V del Arduino
 Conectamos el pin 2 que corresponde al pin de datos del sensor con cualquier pin analógico del Arduino
 Conectamos el pin 3 que corresponde al pin de masa (GND) del sensor con el pin GND del Arduino

*/

int temp = 5;  //Pin analógico A5 del Arduino donde conectaremos el pin de datos del sensor TMP36
float maxC = 0, minC = 100, maxF = 0, minF = 500, maxV = 0, minV = 5;  //Variables para ir comprobando maximos y minimos

void setup()
{
  Serial.begin(9600);  //Iniciamos comunicación serie con el Arduino para ver los resultados del sensor
                        //a través de la consola serie del IDE de Arduino
}

void loop()
{
  float voltaje, gradosC, gradosF;  //Declaramos estas variables tipo float para guardar los valores de lectura
                                    //del sensor, así como las conversiones a realizar para convertir a grados
                                    //centígrados y a grados Fahrenheit
                                    
  voltaje = analogRead(5) * 0.004882814;  //Con esta operación lo que hacemos es convertir el valor que nos devuelve
                                           //el analogRead(5) que va a estar comprendido entre 0 y 1023 a un valor
                                           //comprendido entre los 0.0 y los 5.0 voltios
                                           
  gradosC = (voltaje - 0.5) * 100.0;  //Gracias a esta fórmula que viene en el datasheet del sensor podemos convertir
                                       //el valor del voltaje a grados centigrados
                                       
  gradosF = ((voltaje - 0.5) * 100.0) * (9.0/5.0) + 32.0;  //Gracias a esta fórmula que viene en el datasheet del sensor podemos convertir
                                                           //el valor del voltaje a grados Fahrenheit
                                                           
  //Mostramos mensaje con valores actuales de humedad y temperatura, asi como maximos y minimos de cada uno de ellos
  Serial.print("Medidas actuales\n");
  Serial.print("C: "); 
  Serial.print(gradosC);
  Serial.print("\tF: "); 
  Serial.print(gradosF);
  Serial.print("\tV: "); 
  Serial.print(voltaje);
  //Comprobacion de maximos y minimos de humedad y temperatura
  if (maxC < gradosC)
    maxC = gradosC;
  if (gradosC < minC)
    minC = gradosC;
  if (maxF < gradosF)
    maxF = gradosF;
  if (gradosF < minF)
    minF = gradosF;
  if (maxV < voltaje)
    maxV = voltaje;
  if (voltaje < minV)
    minV = voltaje;
  Serial.print("\nMedidas maximas\n");
  Serial.print("C: "); 
  Serial.print(maxC);
  Serial.print("\tF: "); 
  Serial.print(maxF);
  Serial.print("\tV: "); 
  Serial.print(maxV);
  Serial.print("\nMedidas minimas\n");
  Serial.print("C: "); 
  Serial.print(minC);
  Serial.print("\tF: "); 
  Serial.print(minF);
  Serial.print("\tV: "); 
  Serial.print(minV);
  Serial.print("\n\n");
  delay(2000);  //Usamos un retardo de 2 segundos entre lectura y lectura  
}

La salida que obtenemos a través de la consola serie del IDE de Arduino es la siguiente:

Muestra de datos TMP36

Espero que os sirva de ayuda para vuestros proyectos!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Sensor DHT11 (Humedad y Temperatura) con Arduino


En esta nueva entrada vamos a ver como hacer funcionar este sensor DHT11 que nos va a servir para medir tanto la humedad relativa como la temperatura. Lo malo de este sensor es que solo nos va a dar medidas enteras, es decir sin decimales, ya que la resolución que presenta es de 1% para la humedad relativa y de 1ºC para la temperatura. Pero compensa ya que presenta un valor muy económico para pequeños proyectos y que nos permite obtener medidas tanto para humedad como para temperatura.

DHT11_Pins

Este sensor se caracteriza por tener la señal digital calibrada por lo que asegura una alta calidad y una fiabilidad a lo largo del tiempo, ya que contiene un microcontrolador de 8 bits integrado. Está constituido por dos sensores resistivos (NTC y humedad). Tiene una excelente calidad y una respuesta rápida en las medidas.Puede medir la humedad entre el rango 20% – aprox. 95% y la temperatura entre el rango 0ºC – 50ºC.

Cada sensor DHT11 está estrictamente calibrado en laboratorio, presentando una extrema precisión en la calibración. Los coeficientes de calibración se almacenan como programas en la memoria OTP, que son empleados por el proceso de detección de señal interna del sensor.

El protocolo de comunicación es a través de un único hilo (protocolo 1-wire), por lo tanto hace que la integración de este sensor en nuestros proyectos sea rápida y sencilla. Además presenta un tamaño reducido, un bajo consumo y la capacidad de transmitir la señal hasta 20 metros de distancia.

Os dejo las características de dicho sensor:

caracteristicas

Aquí podéis descargar los archivos de esta entrada (un pdf explicativo, esquema fritzing, sketchs arduino): http://www.mediafire.com/?vvofjfvuu6fttf4

Os pongo el esquema para la conexión del sensor a Arduino (sensor solo sin módulo):

Esquema fritzing dht11

Yo he usado un módulo que adquirí a un precio muy económico y que me ahorra estar poniendo la resistencia de pull-up. Os pongo una imagen del módulo:

3689624d-66bf-48ac-9865-4b42952c227d

Ahora os pongo dos tipos de programa para arduino, uno que no emplea librería para la programación del sensor (programación a través de funciones) y otro que si emplea una librería hecha por ladyada y que va adjunta en los archivos indicados arriba.

Programa sin librería:

//Programa test para sensor DHT11 de humedad y temperatura
//cleaned by sucotronic
//Modificado por Regata para tallerarduino.wordpress.com


#define DHTPIN 2 // Indicamos el pin del arduino donde conectamos el sensor

byte bGlobalErr;  //para pasar el codigo de error de vuelta de las funciones
byte DHTDAT[5];  //Array para almacenar los bytes enviados por el sensor
int maxh=0,minh=100,maxt=0,mint=100,t,h; //variables para ir guardando las maximas de
// humedad y temperatura y las minimas de humedad y temperatura

void setup()
{
  InitDHT();  // Inicializamos el pin empleado para leer el sensor
  Serial.begin(9600);  //Iniciamos comunicacion serie con el pc para ver los datos leidos
  Serial.println("Test sensor DHT11:");
  delay(1000);  //Este delay es para esperar el tiempo recomendado para acceder al sensor (1 segundo) 
}

void loop()
{
  ReadDHT(); // Leemos el sensor y almacenamos el resultados en variables globales
  switch (bGlobalErr)
  {
     case 0:
        //Como en este sensor la humedad y la temperatura no nos sale con decimales, 
        //podemos desechar los bytes 1 y 3 de la lectura del sensor
        h=DHTDAT[0];
        t=DHTDAT[2];
	Serial.print("Humedad relativa: ");
	Serial.print(h);
	Serial.print(" %\t");
	Serial.print("Temperatura: ");
	Serial.print(t);
	Serial.println("*C");
        //Comprobacion de maximos y minimos de humedad y temperatura
        if (maxh<h)
          maxh=h;
        if (h<minh)
          minh=h;
        if (maxt<t)
          maxt=t;
        if (t<mint)
          mint=t;
        Serial.print("Max: ");
        Serial.print(maxh);
        Serial.print(" % ");
        Serial.print("Min: ");
        Serial.print(minh);
        Serial.print(" %\t");
        Serial.print("Max: ");
        Serial.print(maxt);
        Serial.print(" *C ");
        Serial.print("Min: ");
        Serial.print(mint);
        Serial.println(" *C\n");
        break;
     case 1:
        Serial.println("Error 1: Condicion de start 1 no conocida.");
        break;
     case 2:
        Serial.println("Error 2: Condicion de start 2 no conocida.");
        break;
     case 3:
        Serial.println("Error 3: DHT checksum error.");
        break;
     default:
        Serial.println("Error: Encontrado codigo irreconocible.");
        break;
  }
  delay(1000);// Esperamos 1 segundo para la siguiente lectura
}


// Initilize pin for reading
void InitDHT(){
        pinMode(DHTPIN,OUTPUT);
        digitalWrite(DHTPIN,HIGH);
}

void ReadDHT(){
  bGlobalErr=0;
  byte dht_in;
  byte i;
  // Enviamos el comando "start read and report" al sensor
  // Primero: ponemos a "0" el pin durante 18ms
  digitalWrite(DHTPIN,LOW);
  delay(18);
  delay(5);//TKB, frm Quine at Arduino forum
  //Segundo: ponemos a "1" el pin durante 40us,enviamos el comando de "start read" al sensor
  digitalWrite(DHTPIN,HIGH);
  delayMicroseconds(40);
  //Tercero: Cambiamos el pin de Arduino a entrada de datos
  pinMode(DHTPIN,INPUT);
  delayMicroseconds(40); //Esperamos 40 us
  dht_in=digitalRead(DHTPIN);
  //si hay un 1 en la lectura del pin, indicamos que hay error de tipo 1
  if(dht_in)
  {
    bGlobalErr=1;
    return;
  }
  delayMicroseconds(80); //Esperamos 80us
  dht_in=digitalRead(DHTPIN); 
  //si no hay un 1 en la lectura del pin, indicamos que hay error de tipo 2
  if(!dht_in){
    bGlobalErr=2;
    return;
  }
  /*Despues de 40us a nivel bajo, el pin deberia de estar durante 80us a nivel alto.
  Despues de esto comienza el envio del primer bit hasta alcanzar los 40 bits enviados.
  The routine "read_dht_dat()" expects to be called with the system already into this low.*/
  delayMicroseconds(80); //Esperamos 80us
  //Ahora comienza la recepcion de datos, son 5 bytes de datos, es decir 40 bits, almacenamos en un array de 5 bytes
  for (i=0; i<5; i++)
    DHTDAT[i] = read_dht_dat();
  //Cuarto: Volvemos a configurar el pin del arduino como salida
  pinMode(DHTPIN,OUTPUT);
  //Quinto:Ponemos a "1" el pin de salida
  digitalWrite(DHTPIN,HIGH);
  //Comprobamos si los datos recibidos coinciden con el checksum recibido
  byte DHTCHECKSUM = DHTDAT[0]+DHTDAT[1]+DHTDAT[2]+DHTDAT[3];
  //Si no coincide el byte recibido de checksum con la suma de los 4 primeros bytes enviamos error tipo 3
  if(DHTDAT[4]!= DHTCHECKSUM)
    bGlobalErr=3;
  };

byte read_dht_dat()
{
  //Cogemos 8 de los bits recibidos y los devolvemos como un byte.
  //Si por ejemplo recibimos 00000100 , devolvemos en decimal 4
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    //Entramos mientras dura el primer bit de start (a nivel bajo durante 50us) del byte
    //Esperamos hasta que el pin se pone a nivel alto señalizando fin del la transmision del bit de start
    while(digitalRead(DHTPIN)==LOW);
    //La linea de datos debera estar ahora a nivel alto durante 27 o 70us, 
    //dependiendo si un "0" o un "1" esta siendo enviado respectivamente
    delayMicroseconds(30);  //Esperamos 30 us
    if (digitalRead(DHTPIN)==HIGH)
      result |=(1<<(7-i));  //Si despues de los 30us el pin permanece a "1" añadimos un 1 al byte, sino queda un "0" 
    //Esperamos hasta que el pin se vuelve a poner a nivel bajo,
    // el cual indica la señal de start del siguiente bit de la transmision
    while (digitalRead(DHTPIN)==HIGH);
  }
  return result; //devolvemos el resultado
}

Y este es el programa con librería:

// Sketch de ejemplo para testear el famoso sensor DHT de humedad y temperatura
// Escrito por ladyada, de dominio público
// Modificado por Regata para www.tallerarduino.wordpress.com

#include "DHT.h"  //Añadimos la libreria con la cual trabaja nuestro sensor

#define DHTPIN 2     // Indicamos el pin donde conectaremos la patilla data de nuestro sensor

// Descomenta el tipo de sensor que vas a emplear. En este caso usamos el DHT11
#define DHTTYPE DHT11   // DHT 11 
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Conecta el pin 1 (el de la izquierda) del sensor a +5V
// Conecta el pin 2 del sensor al pin que has elegido para DHTPIN
// Conecta el pin 4 (el de la derecha) del sensor a GROUND
// Conecta una resistencia de 10K del pin 2 (data) al pin 1 (+5V) del sensor

DHT dht(DHTPIN, DHTTYPE);  //Indica el pin con el que trabajamos y el tipo de sensor
int maxh=0, minh=100, maxt=0, mint=100;  //Variables para ir comprobando maximos y minimos

void setup() 
{
  //Inicio comunicacion serie para ver los datos en el ordenador
  Serial.begin(9600); 
  //Mensaje de inicio
  Serial.println("Comprobacion sensor DHTxx:");
  //Iniciamos el sensor
  dht.begin();
}

void loop() 
{
  // La lectura de la temperatura o de la humedad lleva sobre 250 milisegundos  
  // La lectura del sensor tambien puede estar sobre los 2 segundos (es un sensor muy lento)
  int h = dht.readHumidity();  //Guarda la lectura de la humedad en la variable float h
  int t = dht.readTemperature();  //Guarda la lectura de la temperatura en la variable float t

  // Comprobamos si lo que devuelve el sensor es valido, si no son numeros algo esta fallando
  if (isnan(t) || isnan(h)) // funcion que comprueba si son numeros las variables indicadas 
  {
    Serial.println("Fallo al leer del sensor DHT"); //Mostramos mensaje de fallo si no son numeros
  } else {
    //Mostramos mensaje con valores actuales de humedad y temperatura, asi como maximos y minimos de cada uno de ellos
    Serial.print("Humedad relativa: "); 
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperatura: "); 
    Serial.print(t);
    Serial.println(" *C");
    //Comprobacion de maximos y minimos de humedad y temperatura
    if (maxh<h)
      maxh=h;
    if (h<minh)
      minh=h;
    if (maxt<t)
      maxt=t;
    if (t<mint)
      mint=t;
    Serial.print("Max: ");
    Serial.print(maxh);
    Serial.print(" % ");
    Serial.print("Min: ");
    Serial.print(minh);
    Serial.print(" %\t");
    Serial.print("Max: ");
    Serial.print(maxt);
    Serial.print(" *C ");
    Serial.print("Min: ");
    Serial.print(mint);
    Serial.println(" *C\n");
  }
  delay(1000);
}

La salida que obtenemos a través de la consola serie del IDE de Arduino es la misma para ambos códigos, os dejo una imagen:

Medicion sensor dht11

Espero que os sirva de ayuda para vuestros proyectos!! Felices fiestas a todos!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Sensor de nivel de liquido y arduino o pinguino pic


Como estoy metido en un proyecto sobre el control de unos depósitos de agua para la furgoneta vivienda de un amigo mio, me parece interesante hablar aquí de los sensores de nivel de liquido.

Los sensores de nivel de liquido de los que vamos a hablar son de este tipo:

La verdad es que son muy fáciles de usar, ya que cuando están activados puentean los dos cables que traen, así que funcionan como un interruptor. Os dejo las características de los mismos:

El ejemplo que hice para probarlo es muy básico y es el mismo tanto para arduino como para pinguino pic, lo único que cambia son los pines a donde he conectado tanto el sensor como el led de alarma (los podéis ver en el código de pinguino pic), os dejo una imagen del esquema de conexionado:

Aquí podéis ver un vídeo del funcionamiento del sensor (en un improvisado depósito de agua realizado con una botella de refresco):

El código para arduino:

/*Prueba sensor de nivel de liquido*/

int sensor=12;  //Indicamos el pin al que tenemos conectado el sensor de nivel de liquido
int led=11;      //Indicamos el pin al que tenemos conectado el led que indica alarma

void setup()
{                
	//Configuramos los pines correspondientes como entradas o salidas
  pinMode(sensor,INPUT);   //sensor de nivel de liquido
  pinMode(led, OUTPUT); //salida led
}

void loop()
{
  if(digitalRead(sensor)==LOW)
    digitalWrite(led,LOW);
  else
    digitalWrite(led,HIGH);
}

El código para pinguino pic:

/*Prueba sensor de nivel de liquido*/

int sensor=0;  //Indicamos el pin al que tenemos conectado el sensor de nivel de liquido
int led=1;      //Indicamos el pin al que tenemos conectado el led que indica alarma

void setup()
{                
	//Configuramos los pines correspondientes como entradas o salidas
  pinMode(sensor,INPUT);   //sensor de nivel de liquido
  pinMode(led, OUTPUT); //salida led
}

void loop()
{
  if(digitalRead(sensor)==LOW)
    digitalWrite(led,LOW);
  else
    digitalWrite(led,HIGH);
}

Espero que os sirva de ayuda!!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Arduino y sensores de temperatura DS18B20


Os traigo un ejemplo de como usar los sensores de temperatura DS18B20 con nuestro Arduino. La ventaja principal que presentan estos sensores es que se pueden conectar hasta 100 dispositivos a un único pin y a una distancia máxima de nuestro Arduino de 200 metros. Dichos sensores emplean el protocolo de comunicación en serie 1-wire diseñado por Dallas Semiconductor.

Pero, ¿en que se basa este protocolo de comunicación? pues básicamente y para no entrar en muchos tecnicismos, es un bus donde disponemos de un maestro y varios esclavos en una sola línea de datos (pin de nuestro Arduino) en la que se alimentan. Por supuesto, necesita igualmente una referencia a tierra común a todos los dispositivos. También debemos conocer que la línea de datos/alimentación debe de disponer de una resistencia de pull-up conectada a alimentación para cuando no se produzca la transmisión de datos cuando tengamos 5 voltios en dicha línea.

En este tipo de sensores podemos encontrar dos tipos de alimentación:

* El primero de ellos alimenta a los dispositivos en modo parásito, esto quiere decir que solo suministra alimentación mientras se realizan las operaciones de conversión de temperatura, se deben puentear las patillas GND y VDD del DS18B20 a GND del Arduino.

* El segundo es alimentación de los sensores mediante una fuente de alimentación externa conectada a la patilla VDD del DS18B20, y la patilla GND al pin GND de Arduino.

Ahora vamos al lío, aquí tenéis el esquema de conexionado de los tres sensores y dos led indicadores de temperatura:

NOTA: Las conexiones a GND de los sensores 2 y 3 están mal en el esquema de Fritzing, tienen que ir donde GND del Arduino.

Como podéis ver uso la alimentación tipo parasito y en el programa que he realizado básicamente indicamos el pin por el que vamos a comunicar nuestros sensores con el Arduino, añadiendo para ello dos librerías, las cuales son OneWire.h y DallasTemperature.h. Leemos la temperatura de los 3 sensores DS18B20 y mostramos mediante el monitor serie dichas temperaturas, además mostramos una temperatura media de las tres, y guardamos la temperatura mínima y máxima para mostrar también. Los diodos led se encienden dependiendo de la temperatura media que tengamos, el led verde se enciende para una temperatura de menos de 22ºC y el led rojo indica una temperatura mayor de 22ºC.

Aquí podéis ver un vídeo del funcionamiento del programa:

Aquí dejo el código:

/*Programa realizado por Regata para tallerarduino.wordpress.com*/
/*Medición de temperatura mediante varios sensores 1-wire DS18B20+*/

#include <OneWire.h>
#include <DallasTemperature.h>

// DQ esta conectado al pin 10 de Arduino
#define ONE_WIRE_BUS 10

// Configuramos para comunicar con otros dispositivos 1-Wire
OneWire oneWire(ONE_WIRE_BUS);

// Indicamos el pin asignado al sensor 1-Wire a DallasTemperature 
DallasTemperature sensores(&oneWire);

int ledverde=11;  //indicamos que le led verde esta conectado en el pin 11 de Arduino
int ledrojo=12;  //indicamos que el led rojo esta conectado en el pin 12 del Arduino
float val=0; // variable donde guardaremos la temperatura leida del sensor
int i;  //variable que contiene el numero de sensores empleados en el caso de ser mas de 1
float tempmin=100;  //Variable donde guardamos la temperatura minima registrada
                    //Le pongo 100 por que en donde lo he probado no llega a esa temperatura
                    //y así puede coger el menor valor de temperatura que aparezca
float tempmax=0;    //Varibale donde guardamos la temperatura maxima registrada

void setup(void)
{
  //Indicamos ledverde y ledrojo como salidas  
  pinMode(ledverde,OUTPUT);
  pinMode(ledrojo,OUTPUT);
  // Iniciamos el puerto serie a 9600 baudios
  Serial.begin(9600);
  // Inicializamos la libreria
  sensores.begin();
  //Ponemos a 0 las salidas ledverde y ledrojo
  digitalWrite(ledverde,LOW);
  digitalWrite(ledrojo,LOW);
}

void loop(void)
{ 
  // call sensors.requestTemperatures() to issue a global temperature 
  // request to all devices on the bus
  float media=0;
  for(i=0;i<=2;i++)
  {
    sensores.requestTemperatures(); //Enviamos el comando para obtener la temperatura  
    Serial.print("Temperatura Sensor ");
    Serial.print(i);
    Serial.print(": ");
    float val =  sensores.getTempCByIndex(i); // Almacenamos la temperatura en la variable val
    media=media+val;  //Vamos sumando para poder calcular la media de las temperaturas
    Serial.println(val);  //Mostramos por puerto serie el valor de la temperatura leida
    if (val<tempmin)
      tempmin=val;
    if (val>tempmax)
      tempmax=val;
  }
    media=media/i;  //Calculamos la media de las temperaturas
    Serial.print("La temperatura media es: ");  //Mostramos la temperatura media de todas las temperaturas
    Serial.println(media);
    Serial.print("La temperatura minima registrada es: ");  //Mostramos la temperatura minima registrada
    Serial.println(tempmin);
    Serial.print("La temperatura maxima registrada es: ");  //Mostramos la temperatura maxima registrada
    Serial.println(tempmax);
    //Si la temperatura media es mayor o igual a 22ºC encendemos el led rojo y apagamos el led verde
    if(media>=22)
     {
      digitalWrite(ledverde,LOW);
      digitalWrite(ledrojo,HIGH);
     }
     //Si es menor a 22ºC encendemos el led verde y apagamos y el led rojo
     else
     {
        digitalWrite(ledrojo,LOW);
        digitalWrite(ledverde,HIGH);
     }
    Serial.println();
    delay(1500);  //Esperamos 1500ms
}

Os dejo también los documentos necesarios para realizar el montaje:

http://www.mediafire.com/?x5h64n3k82c6pkg

Ante las preguntas de varios visitantes del blog, he estado mirando la forma de leer los sensores a través de su dirección de dispositivo, ya que bien podemos tener distintos sensores colocados en varios sitios y queremos leer independientemente cada uno de ellos. Un ejemplo de dirección de dispositivo de estos sensores puede ser {0x28, 0xC7, 0xE8, 0x06, 0x05, 0x00, 0x00, 0xDC}. Arriba hemos visto la forma de leer los sensores por Index, que para varios sensores la verdad no es muy recomendado ya que la propia librería se encarga de asignar la posición de los sensores para ser leídos, por eso vamos a trabajar con la dirección específica para cada sensor y así tener el control sobre ellos.

Lo primero que vamos a tener que hacer es detectar cual es la dirección del dispositivo, para ello conectamos el sensor a nuestro Arduino (en este caso he realizado la prueba con un Arduino Mega 2560, pero vale con cualquier otro Arduino, lo único que tenéis que cambiar es el pin donde conectamos el sensor):

DS18B20 Address

El código para obtener la dirección del sensor es el siguiente:

/*Programa realizado por Javier Couto Rego (Regata) para www.tallerarduino.wordpress.com

Programa de lectura de sensores de temperatura DS18B20 de Dallas Semiconductor a través de
su direccion de dispositivo en lugar de lectura indexada.*/

//Incluimos las librerias para controlar los sensores de temperatura
#include <OneWire.h>
#include <DallasTemperature.h>

//Estoy trabajando con un Arduino Mega, indico que los sensores estan conectados al pin 33
#define ONE_WIRE_BUS 33
OneWire oneWire(ONE_WIRE_BUS);  // Configuramos para comunicar con otros dispositivos 1-Wire
DallasTemperature sensores(&oneWire); // Indicamos el pin asignado al sensor 1-Wire a DallasTemperature 
DeviceAddress Sensor;  // Array donde almacenamos la direccion del sensor DS18B20

void setup(void)
{
  Serial.begin(9600);  //Iniciamos la comunicacion serie a 9600 baudios
  Serial.println("Comprobación Direccion Sensores DS18B20:");
  sensores.begin();  //Iniciamos la libreria para la lectura de los sensores
  //Obtenemos la direccion del sensor de temperatura
  if (!sensores.getAddress(Sensor, 0)) 
    Serial.println("Imposible encontrar direccion del sensor.");
}

//Funcion que muestra la direccion del sensor de dicha direccion
void Mostrar_Direccion(DeviceAddress direccion)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    if (direccion[i] < 16) Serial.print("0");
    Serial.print(direccion[i], HEX);
  }
}

void loop(void)
{ 
  //Mostramos la direccion del sensor
  Serial.print("Direccion del sensor: ");
  Mostrar_Direccion(Sensor);
  Serial.println();
  delay(1000);
}

Un ejemplo de uso de estos comando con la librería DallasTemperature y 5 sensores DS18B20:

Ejemplo DS18B20 5 Sensores

El código es:

/*Programa realizado por Javier Couto Rego (Regata) para www.tallerarduino.wordpress.com

Programa de lectura de sensores de temperatura DS18B20 de Dallas Semiconductor a través de
su direccion de dispositivo en lugar de lectura indexada.*/

//Incluimos las librerias para controlar los sensores de temperatura
#include <OneWire.h>
#include <DallasTemperature.h>

//Estoy trabajando con un Arduino Mega, indico que los sensores estan conectados al pin 33
#define ONE_WIRE_BUS 33
                              
OneWire oneWire(ONE_WIRE_BUS);  // Configuramos para comunicar con otros dispositivos 1-Wire
DallasTemperature sensores(&oneWire); // Indicamos el pin asignado al sensor 1-Wire a DallasTemperature 

//Indicamos las direcciones de los distintos sensores
DeviceAddress S1 = {0x28, 0xC7, 0xE8, 0x06, 0x05, 0x00, 0x00, 0xDC};  //Sensor 1
DeviceAddress S2 = {0x28, 0xD7, 0xF2, 0x07, 0x05, 0x00, 0x00, 0xC9};  //Sensor 2
DeviceAddress S3 = {0x28, 0xC4, 0xF0, 0x07, 0x05, 0x00, 0x00, 0x48};  //Sensor 3
DeviceAddress S4 = {0x28, 0xC9, 0xB6, 0x07, 0x05, 0x00, 0x00, 0x77};  //Sensor 4
DeviceAddress S5 = {0x28, 0x8D, 0xE9, 0x06, 0x05, 0x00, 0x00, 0xAB};  //Sensor 5

void setup(void)
{
  Serial.begin(9600);  //Iniciamos la comunicacion serie a 9600 baudios
  sensores.begin();  //Iniciamos la libreria para la lectura de los sensores
}

//Funcion que muestra la direccion del dispositivo de dicha direccion
void Mostrar_Direccion(DeviceAddress direccion)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    if (direccion[i] < 16) 
      Serial.print("0");
    Serial.print(direccion[i], HEX);
  }
}

//Funcion que muestra la temperatura en grados centigrados del sensor de dicha direccion
void Mostrar_Temperatura(DeviceAddress direccion)
{
  float tempC = sensores.getTempC(direccion);
  Serial.print("Temperatura: ");
  Serial.print(tempC);
}

//Funcion que muestra la resolucion del sensor de dicha direccion
void Mostrar_Resolucion(DeviceAddress direccion)
{
  Serial.print("Resolucion: ");
  Serial.print(sensores.getResolution(direccion));
  Serial.println();    
}

//Funcion que muestra los datos del sensor de dicha direccion
void Mostrar_Datos(DeviceAddress direccion)
{
  Serial.print("Direccion del dispositivo: ");
  Mostrar_Direccion(direccion);
  Serial.print(" ");
  Mostrar_Temperatura(direccion);
  Serial.println();
}

void loop(void)
{ 
  Serial.println("Comprobación Direccion Sensores DS18B20:");
  //Podemos ver el numero de dispositivos que estan conectados al bus 1-Wire
  Serial.print("El numero de dispositivos es: ");
  Serial.println(sensores.getDeviceCount(), DEC);
  //Podemos comprobar si el sensor esta alimentado en modo Parasito
  Serial.print("Alimentacion en modo Parasito: "); 
  if (sensores.isParasitePowerMode()) 
    Serial.println("ON");
  else 
    Serial.println("OFF");
  Serial.print("Direccion Sensor 1: ");
  Mostrar_Direccion(S1);
  Serial.println();
  Serial.print("Direccion Sensor 2: ");
  Mostrar_Direccion(S2);
  Serial.println();
  Serial.print("Direccion Sensor 3: ");
  Mostrar_Direccion(S3);
  Serial.println();
  Serial.print("Direccion Sensor 4: ");
  Mostrar_Direccion(S4);
  Serial.println();
  Serial.print("Direccion Sensor 5: ");
  Mostrar_Direccion(S5);
  Serial.println();
  //Establecemos la resolucion para cada sensor, PRECISION es a 9 bits
  sensores.setResolution(S1, 9);  //Resolucion a 9 bits 0.50 ºC
  sensores.setResolution(S2, 9);  //Resolucion a 9 bits 0.50 ºC
  sensores.setResolution(S3, 10); //Resolucion a 10 bits 0.25 ºC
  sensores.setResolution(S4, 11); //Resolucion a 11 bits 0.125 ºC
  sensores.setResolution(S5, 12); //Resolucion a 12 bits 0.0625 ºC
  //Si queremos mostrar la resolucion que tiene cada sensor:
  Serial.print("Resolucion Sensor 1: ");
  Serial.print(sensores.getResolution(S1), DEC); 
  Serial.println();
  Serial.print("Resolucion Sensor 2: ");
  Serial.print(sensores.getResolution(S2), DEC); 
  Serial.println();
  Serial.print("Resolucion Sensor 3: ");
  Serial.print(sensores.getResolution(S3), DEC); 
  Serial.println();
  Serial.print("Resolucion Sensor 4: ");
  Serial.print(sensores.getResolution(S4), DEC); 
  Serial.println();
  Serial.print("Resolucion Sensor 5: ");
  Serial.print(sensores.getResolution(S5), DEC); 
  Serial.println();
  sensores.requestTemperatures();  //Enviamos el comando para obtener los datos de los sensores
  //Mostramos los datos de todos los sensores
  //Llamamos a la funcion Mostrar_Datos indicando la direccion del sensor que queremos leer
  Serial.print("Sensor 1 --> ");
  Mostrar_Datos(S1);
  Serial.print("Sensor 2 --> ");  
  Mostrar_Datos(S2);
  Serial.print("Sensor 3 --> ");
  Mostrar_Datos(S3);
  Serial.print("Sensor 4 --> ");
  Mostrar_Datos(S4);
  Serial.print("Sensor 5 --> ");
  Mostrar_Datos(S5);
  delay(2000);  //Retardo de 2 segundo
}

Espero que os guste!!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Sensor infrarrojo TSOP1838 y Arduino


Pensando ideas para poder domotizar la habitación de mi casa, he pensado en hacer un prototipo para controlar las luces (quien dice luces dice cualquier cosa) mediante un mando a distancia que emplea el protocolo NEC, creo que uno de los más extendidos, por lo menos todos los mandos que he encontrado por casa tienen este protocolo. Para ello dispongo en mi taller de un sensor infrarrojo TSOP1838 que me compré por ebay, y los siguientes mandos para probar el circuito, aparte de probar mi nueva prototype shield para el arduino:

Estos mandos los he probado y funcionan los 3 perfecto, el único fallo es con el  más pequeño de todos que algunas teclas no me las reconoce pero el resto funcionan perfectamente, el 1º de ellos es de mi tarjeta de televisión Avermedeia TV203, el 2º es el del TDT que tengo en la tele de la habitación y el último (con el que he realizado el programa) es de un disco duro, que se me estropeo, Iomega Screenplay HD Multimedia.

Os cuento un poco de que trata el protocolo NEC de los mandos a distancia:

  • Longitud de 8 bits de dirección y 8 bits de comando.
  • Tanto la dirección como el comando son envíados dos veces a modo de CRC.
  • La primera vez envía los bits originales y la segunda los mismos pero negados.
  • Los pulsos son por modulación de amplitud.
  • La frecuencia portadora es de 38kHz (detectable por el TSOP1838).
  • La frecuencia de un bit ‘0’ es de 1.12ms y la de un bit ‘1’ es de 2.25ms.
  • En total se transmiten un bit de Start de 9ms+4.5ms=13.5ms mas 32 bits de datos.

Aquí está la conexión del sensor infrarrojo TSOP1838 según su datasheet y el patillaje del mismo (aunque yo solo conecto una resistencia de 470 ohmios que son las que uso para los leds conectada a Vcc y a la patilla 1 del TSOP1838):

Para el programa en Arduino he utilizado la libreria IRremote.h de Ken Shirriff, que simplifica mucho el uso de los mandos a distancia en nuestros programas. Os dejo a continuación un video del funcionamiento del programa así como el código del programa de dos maneras distintas, una empleando sentencias if y otra empleado switch case en su lugar:

Este es el código con sentencias if (ocupa más memoria de programa como se puede ver en la imagen de abajo que con la sentencia switch case):

/*Programa realizado por Regata 04/09/2011*/

/*Programa para control de luces (en este caso leds) mediante un mando con protocolo NEC,
ademas de encender y apagar tambien podemos controlar dos led mediante PWM para ver como
funciona*/

#include <IRremote.h> //Añadimos la libreria para el control del TSOP1838 que usamos

/*En este programa trabajo con el mando del disco duro IOMEGA SCREENPLAY HD MULTIMEDIA
Los datos de los codigos de las teclas de este mando y del mando de AVERMEDIA TV203
estan abajo del programa*/

#define RECV_PIN 12 //indicamos el pin por el que recibimos los datos del sensor TSOP1838
int i;  //Variable para salidas
boolean encendido[8]; //Matriz donde guardamos el estado de las sariables de control de los leds
int brillo1=0;  //Cuanto alumbra el led rojo
int brillo2=0;  //Cuanto alumbra el led verde

//Iniciamos la libreria para el control del sensor TSOP indicando el pin de lectura
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
//Configuramos comunicacion serie para depuracion y poder ver los codigos de las teclas
Serial.begin(9600);
//Indicamos como salidas los pines del 2 al 9
for(i=2;i<12;i++)
{
pinMode(i,OUTPUT);
}
for(i=0;i<8;i++)
{
encendido[i]=0;
}
irrecv.enableIRIn(); // Iniciamos la recepcion
}

void loop()
{
//Si tenemos datos de lectura debido a que se pulsa una tecla en el mando
if (irrecv.decode(&results))
{
//Mostramos por puerte serie dicho codigo en Hexadecimal(para depuracion)
Serial.print("Codigo: 0x") ;
Serial.println(results.value,HEX) ;
//Comprobamos si es la TECLA 1
if(results.value==0x2FC827D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[0]==1)
{
digitalWrite(2,LOW);
encendido[0]=0;
}
//si no, lo encendemos
else
{
digitalWrite(2,HIGH);
encendido[0]=1;
}
}
//Comprobamos si es la TECLA 2
if(results.value==0x2FCB24D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[1]==1)
{
digitalWrite(3,LOW);
encendido[1]=0;
}
//si no, lo encendemos
else
{
digitalWrite(3,HIGH);
encendido[1]=1;
}
}
//Comprobamos si es la TECLA 3
if(results.value==0x2FCA25D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[2]==1)
{
digitalWrite(4,LOW);
encendido[2]=0;
}
//si no, lo encendemos
else
{
digitalWrite(4,HIGH);
encendido[2]=1;
}
}
//Comprobamos si es la TECLA 4
if(results.value==0x2FC42BD)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[3]==1)
{
digitalWrite(5,LOW);
encendido[3]=0;
}
//si no, lo encendemos
else
{
digitalWrite(5,HIGH);
encendido[3]=1;
}
}
//Comprobamos si es la TECLA 5
if(results.value==0x2FC728D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[4]==1)
{
digitalWrite(6,LOW);
encendido[4]=0;
}
//si no, lo encendemos
else
{
digitalWrite(6,HIGH);
encendido[4]=1;
}
}
//Comprobamos si es la TECLA 6
if(results.value==0x2FC629D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[5]==1)
{
digitalWrite(7,LOW);
encendido[5]=0;
}
//si no, lo encendemos
else
{
digitalWrite(7,HIGH);
encendido[5]=1;
}
}
//Comprobamos si es la TECLA 7
if(results.value==0x2FCC23D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[6]==1)
{
digitalWrite(8,LOW);
encendido[6]=0;
}
//si no, lo encendemos
else
{
digitalWrite(8,HIGH);
encendido[6]=1;
}
}
//Comprobamos si es la TECLA 8
if(results.value==0x2FCF20D)
{
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[7]==1)
{
digitalWrite(9,LOW);
encendido[7]=0;
}
//si no, lo encendemos
else
{
digitalWrite(9,HIGH);
encendido[7]=1;
}
}
//Comprobamos si es la TECLA STOP
if(results.value==0x2FC20DF)
{
//Apagamos todos los leds
for(i=2;i<12;i++)
{
digitalWrite(i,LOW);
if(i<10) //Comprobamos el limite de los leds de la barra de leds
//y ponemos a 0 la variable de control de cada led
{
encendido[i-2]=0;
}
brillo1=0;
brillo2=0;
}
}
//Comprobamos si es la TECLA PLAY
if(results.value==0x2FCE817)
{
//Encendemos todos los leds
for(i=2;i<12;i++)
{
digitalWrite(i,HIGH);
if(i<10) //Comprobamos el limite de los leds de la barra de leds
//y ponemos a 1 la variable de control de cada led
{
encendido[i-2]=1;
}
brillo1=255;
brillo2=255;
}
}
//Comprobamos si es la tecla VOL+, aumentamos el brillo del led rojo
if(results.value==0x2FCB04F)
{
//Si el brillo es menor de 255 aumentamos 1 paso de 5 su brillo
if(brillo1<255)
{
brillo1=brillo1+51;
analogWrite(10,brillo1);
}
}
//Comprobamos si es la tecla VOL-, disminuimos el brillo del led rojo
if(results.value==0x2FCC837)
{
//Si el brillo es mayor de 0 disminuimos 1 paso de 5 su brillo
if(brillo1>0)
{
brillo1=brillo1-51;
analogWrite(10,brillo1);
}
}
//Comprobamos si es la tecla >>, aumentamos el brillo del led verde
if(results.value==0x2FC28D7)
{
//Si el brillo es menor de 255 aumentamos 1 paso de 5 su brillo
if(brillo2<255)
{
brillo2=brillo2+51;
analogWrite(11,brillo2);
}
}
//Comprobamos si es la tecla <<, disminuimos el brillo del led rojo
if(results.value==0x2FC38C7)
{
//Si el brillo es mayor de 0 disminuimos 1 paso de 5 su brillo
if(brillo2>0)
{
brillo2=brillo2-51;
analogWrite(11,brillo2);
}
}
delay(50); //retardo de 250 ms para evitar que el codigo se lea dos veces en una pulsacion
irrecv.resume(); // Recibimos el siguiente valor del sensor
}
}

/*Datos Mando IOMEGA SCREENPLAY HD MULTIMEDIA

TECLA 1 Codigo: 0x2FC827D
TECLA 2 Codigo: 0x2FCB24D
TECLA 3 Codigo: 0x2FCA25D
TECLA 4 Codigo: 0x2FC42BD
TECLA 5 Codigo: 0x2FC728D
TECLA 6 Codigo: 0x2FC629D
TECLA 7 Codigo: 0x2FCC23D
TECLA 8 Codigo: 0x2FCF20D
TECLA 9 Codigo: 0x2FCE21D
TECLA 0 Codigo: 0x2FC18E7
TECLA VOL+ Codigo: 0x2FCB04F
TECLA VOL- Codigo: 0x2FCC837
TECLA SETUP Codigo: 0x2FC12ED
TECLA MENU Codigo: 0x2FC6897
TECLA << Codigo: 0x2FC38C7
TECLA >> Codigo: 0x2FC28D7
TECLA AUDIO Codigo: 0x2FC926D
TECLA ANGLE Codigo: 0x2FC52AD
TECLA SUBTITLE Codigo: 0x2FCD22D
TECLA FLECHA ARRIBA Codigo: 0x2FC807F
TECLA FLECHA IZQUIERDA Codigo: 0x2FC9867
TECLA FLECHA ABAJO Codigo: 0x2FC906F
TECLA PLAY Codigo: 0x2FCE817
TECLA DISPLAY Codigo: 0x2FCD827
TECLA SEARCH Codigo: 0x2FCD02F
TECLA STOP  Codigo: 0x2FC20DF
TECLA PAUSE Codigo: 0x2FCE01F
TECLA A-B Codigo: 0x2FC40BF
TECLA REPEAT Codigo: 0x2FCC03F
TECLA SLOW Codigo: 0x2FC50AF

TECLAS QUE NO ENVIAN NINGUN CODIGO:

TECLA POWER, TECLA TITEL, TECLA |<<, TECLA >>|, TECLA FLECHA DERECHA, TECLA SLOW
*/

/*Datos mando AVERMEDIA TV203

TECLA TV/FM Codigo: 0x40BF807F
TECLA CD Codigo: 0x40BF40BF
TECLA TELETEXT Codigo: 0x40BFC03F
TECLA  POWER Codigo: 0x40BF00FF
TECLA 1 Codigo: 0x40BFA05F
TECLA 2 Codigo: 0x40BF609F
TECLA 3 Codigo: 0x40BFE01F
TECLA 4 Codigo: 0x40BF906F
TECLA 5 Codigo: 0x40BF50AF
TECLA 6 Codigo: 0x40BFD02F
TECLA 7 Codigo: 0x40BFB04F
TECLA 8 Codigo: 0x40BF708F
TECLA 9 Codigo: 0x40BFF00F
TECLA 0 Codigo: 0x40BF8877
TECLA VIDEO Codigo: 0x40BF20DF
TECLA AUDIO Codigo: 0x40BF10EF
TECLA FULL SCREEN Codigo: 0x40BF30CF
TECLA DISPLAY Codigo: 0x40BF48B7
TECLA LOOP Codigo: 0x40BFC837
TECLA PREVIEW Codigo: 0x40BF08F7
TECLA AUTOSCAN Codigo: 0x40BFA857
TECLA FREEZE Codigo: 0x40BF6897
TECLA CAPTURE Codigo: 0x40BFE817
TECLA MUTE Codigo: 0x40BF28D7
TECLA RECORD Codigo: 0x40BF9867
TECLA PAUSE Codigo: 0x40BF58A7
TECLA STOP Codigo: 0x40BFD827
TECLA PLAY Codigo: 0x40BF18E7
TECLA CIRCULO ROJO Codigo: 0x40BFB847
TECLA VOL- Codigo: 0x40BF7887
TECLA VOL+ Codigo: 0x40BFF807
TECLA CIRCULO AMARILLO Codigo: 0x40BF38C7
TECLA CIRCULO VERDE Codigo: 0xC03F807F
TECLA CHANNEL- Codigo: 0xC03F40BF
TECLA CHANNEL+ Codigo: 0xC03FC03F
TECLA CIRCULO AZUL Codigo: 0xC03F00FF

EN ESTE MANDO SE VISUALIZAN TODOS LOS CODIGOS DE LAS TECLAS
*/

Aquí está el código con la sentencia switch case en lugar de con las sentencias if:

/*Programa realizado por Regata 04/09/2011*/

/*Programa para control de luces (en este caso leds) mediante un mando con protocolo NEC,
ademas de encender y apagar tambien podemos controlar dos led mediante PWM para ver como
funciona*/

#include <IRremote.h> //Añadimos la libreria para el control del TSOP1838 que usamos

/*En este programa trabajo con el mando del disco duro IOMEGA SCREENPLAY HD MULTIMEDIA
Los datos de los codigos de las teclas de este mando y del mando de AVERMEDIA TV203
estan abajo del programa*/

#define RECV_PIN 12 //indicamos el pin por el que recibimos los datos del sensor TSOP1838
int i;  //Variable para salidas
boolean encendido[8]; //Matriz donde guardamos el estado de las sariables de control de los leds
int brillo1=0;  //Cuanto alumbra el led rojo
int brillo2=0;  //Cuanto alumbra el led verde

//Iniciamos la libreria para el control del sensor TSOP indicando el pin de lectura
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
//Configuramos comunicacion serie para depuracion y poder ver los codigos de las teclas
Serial.begin(9600);
//Indicamos como salidas los pines del 2 al 9
for(i=2;i<12;i++)
{
pinMode(i,OUTPUT);
}
for(i=0;i<8;i++)
{
encendido[i]=0;
}
irrecv.enableIRIn(); // Iniciamos la recepcion
}

void loop()
{
//Si tenemos datos de lectura debido a que se pulsa una tecla en el mando
if (irrecv.decode(&results))
{
//Mostramos por puerte serie dicho codigo en Hexadecimal(para depuracion)
Serial.print("Codigo: 0x") ;
Serial.println(results.value,HEX) ;
//Comprobamos si es la TECLA 1
switch(results.value)
{
case 0x2FC827D: //Comprobamos si es la TECLA 1
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[0]==1)
{
digitalWrite(2,LOW);
encendido[0]=0;
}
//si no, lo encendemos
else
{
digitalWrite(2,HIGH);
encendido[0]=1;
}
break;
case 0x2FCB24D: //Comprobamos si es la TECLA 2
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[1]==1)
{
digitalWrite(3,LOW);
encendido[1]=0;
}
//si no, lo encendemos
else
{
digitalWrite(3,HIGH);
encendido[1]=1;
}
break;
case 0x2FCA25D: //Comprobamos si es la TECLA 3
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[2]==1)
{
digitalWrite(4,LOW);
encendido[2]=0;
}
//si no, lo encendemos
else
{
digitalWrite(4,HIGH);
encendido[2]=1;
}
break;
case 0x2FC42BD: //Comprobamos si es la TECLA 4
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[3]==1)
{
digitalWrite(5,LOW);
encendido[3]=0;
}
//si no, lo encendemos
else
{
digitalWrite(5,HIGH);
encendido[3]=1;
}
break;
case 0x2FC728D: //Comprobamos si es la TECLA 5
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[4]==1)
{
digitalWrite(6,LOW);
encendido[4]=0;
}
//si no, lo encendemos
else
{
digitalWrite(6,HIGH);
encendido[4]=1;
}
break;
case 0x2FC629D: //Comprobamos si es la TECLA 6
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[5]==1)
{
digitalWrite(7,LOW);
encendido[5]=0;
}
//si no, lo encendemos
else
{
digitalWrite(7,HIGH);
encendido[5]=1;
}
break;
case 0x2FCC23D: //Comprobamos si es la TECLA 7
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[6]==1)
{
digitalWrite(8,LOW);
encendido[6]=0;
}
//si no, lo encendemos
else
{
digitalWrite(8,HIGH);
encendido[6]=1;
}
break;
case 0x2FCF20D: //Comprobamos si es la TECLA 8
//Comprobamos si esta encendido el led, si lo esta lo apagamos
if(encendido[7]==1)
{
digitalWrite(9,LOW);
encendido[7]=0;
}
//si no, lo encendemos
else
{
digitalWrite(9,HIGH);
encendido[7]=1;
}
break;
case 0x2FC20DF: //Comprobamos si es la TECLA STOP
//Apagamos todos los leds
for(i=2;i<12;i++)
{
digitalWrite(i,LOW);
if(i<10) //Comprobamos el limite de los leds de la barra de leds
//y ponemos a 0 la variable de control de cada led
{
encendido[i-2]=0;
}
brillo1=0;
brillo2=0;
}
break;
case 0x2FCE817: //Comprobamos si es la TECLA PLAY
//Encendemos todos los leds
for(i=2;i<12;i++)
{
digitalWrite(i,HIGH);
if(i<10) //Comprobamos el limite de los leds de la barra de leds
//y ponemos a 1 la variable de control de cada led
{
encendido[i-2]=1;
}
brillo1=255;
brillo2=255;
}
break;
case 0x2FCB04F: //Comprobamos si es la tecla VOL+, aumentamos el brillo del led rojo
//Si el brillo es menor de 255 aumentamos 1 paso de 5 su brillo
if(brillo1<255)
{
brillo1=brillo1+51;
analogWrite(10,brillo1);
}
break;
case 0x2FCC837: //Comprobamos si es la tecla VOL-, disminuimos el brillo del led rojo
//Si el brillo es mayor de 0 disminuimos 1 paso de 5 su brillo
if(brillo1>0)
{
brillo1=brillo1-51;
analogWrite(10,brillo1);
}
break;
case 0x2FC28D7: //Comprobamos si es la tecla >>, aumentamos el brillo del led verde
//Si el brillo es menor de 255 aumentamos 1 paso de 5 su brillo
if(brillo2<255)
{
brillo2=brillo2+51;
analogWrite(11,brillo2);
}
break;
case 0x2FC38C7: //Comprobamos si es la tecla <<, disminuimos el brillo del led rojo
//Si el brillo es mayor de 0 disminuimos 1 paso de 5 su brillo
if(brillo2>0)
{
brillo2=brillo2-51;
analogWrite(11,brillo2);
}
break;
}
delay(50); //retardo de 250 ms para evitar que el codigo se lea dos veces en una pulsacion
irrecv.resume(); // Recibimos el siguiente valor del sensor
}
}

/*Datos Mando IOMEGA SCREENPLAY HD MULTIMEDIA

TECLA 1 Codigo: 0x2FC827D
TECLA 2 Codigo: 0x2FCB24D
TECLA 3 Codigo: 0x2FCA25D
TECLA 4 Codigo: 0x2FC42BD
TECLA 5 Codigo: 0x2FC728D
TECLA 6 Codigo: 0x2FC629D
TECLA 7 Codigo: 0x2FCC23D
TECLA 8 Codigo: 0x2FCF20D
TECLA 9 Codigo: 0x2FCE21D
TECLA 0 Codigo: 0x2FC18E7
TECLA VOL+ Codigo: 0x2FCB04F
TECLA VOL- Codigo: 0x2FCC837
TECLA SETUP Codigo: 0x2FC12ED
TECLA MENU Codigo: 0x2FC6897
TECLA << Codigo: 0x2FC38C7
TECLA >> Codigo: 0x2FC28D7
TECLA AUDIO Codigo: 0x2FC926D
TECLA ANGLE Codigo: 0x2FC52AD
TECLA SUBTITLE Codigo: 0x2FCD22D
TECLA FLECHA ARRIBA Codigo: 0x2FC807F
TECLA FLECHA IZQUIERDA Codigo: 0x2FC9867
TECLA FLECHA ABAJO Codigo: 0x2FC906F
TECLA PLAY Codigo: 0x2FCE817
TECLA DISPLAY Codigo: 0x2FCD827
TECLA SEARCH Codigo: 0x2FCD02F
TECLA STOP  Codigo: 0x2FC20DF
TECLA PAUSE Codigo: 0x2FCE01F
TECLA A-B Codigo: 0x2FC40BF
TECLA REPEAT Codigo: 0x2FCC03F
TECLA SLOW Codigo: 0x2FC50AF

TECLAS QUE NO ENVIAN NINGUN CODIGO:

TECLA POWER, TECLA TITEL, TECLA |<<, TECLA >>|, TECLA FLECHA DERECHA, TECLA SLOW
*/

/*Datos mando AVERMEDIA TV203

TECLA TV/FM Codigo: 0x40BF807F
TECLA CD Codigo: 0x40BF40BF
TECLA TELETEXT Codigo: 0x40BFC03F
TECLA  POWER Codigo: 0x40BF00FF
TECLA 1 Codigo: 0x40BFA05F
TECLA 2 Codigo: 0x40BF609F
TECLA 3 Codigo: 0x40BFE01F
TECLA 4 Codigo: 0x40BF906F
TECLA 5 Codigo: 0x40BF50AF
TECLA 6 Codigo: 0x40BFD02F
TECLA 7 Codigo: 0x40BFB04F
TECLA 8 Codigo: 0x40BF708F
TECLA 9 Codigo: 0x40BFF00F
TECLA 0 Codigo: 0x40BF8877
TECLA VIDEO Codigo: 0x40BF20DF
TECLA AUDIO Codigo: 0x40BF10EF
TECLA FULL SCREEN Codigo: 0x40BF30CF
TECLA DISPLAY Codigo: 0x40BF48B7
TECLA LOOP Codigo: 0x40BFC837
TECLA PREVIEW Codigo: 0x40BF08F7
TECLA AUTOSCAN Codigo: 0x40BFA857
TECLA FREEZE Codigo: 0x40BF6897
TECLA CAPTURE Codigo: 0x40BFE817
TECLA MUTE Codigo: 0x40BF28D7
TECLA RECORD Codigo: 0x40BF9867
TECLA PAUSE Codigo: 0x40BF58A7
TECLA STOP Codigo: 0x40BFD827
TECLA PLAY Codigo: 0x40BF18E7
TECLA CIRCULO ROJO Codigo: 0x40BFB847
TECLA VOL- Codigo: 0x40BF7887
TECLA VOL+ Codigo: 0x40BFF807
TECLA CIRCULO AMARILLO Codigo: 0x40BF38C7
TECLA CIRCULO VERDE Codigo: 0xC03F807F
TECLA CHANNEL- Codigo: 0xC03F40BF
TECLA CHANNEL+ Codigo: 0xC03FC03F
TECLA CIRCULO AZUL Codigo: 0xC03F00FF

EN ESTE MANDO SE VISUALIZAN TODOS LOS CODIGOS DE LAS TECLAS
*/

Espero que os sirva de ayuda para vuestros proyectos.

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal