Proyecto: integración de módulos (2)

Bueno, les quiero dejar el programa de integración de módulos. Recuerden que funciona con las librerías de la pantalla, sensor de temperatura y del módulo nrf24l01 para poder funcionar correctamente.

Sin más, acá les dejo el link para que puedan bajarlo!

Programa:
https://mega.nz/#!3ohUgBbQ!qkQU7D-mcURIWdzxYvfEcP015TmrJchWKaGQMx6t7Uw

Librerías:

DHT:
https://mega.nz/#!K0hi2YaC!Spubjr7ApxeBBqBSpDXeofYLQ9JDDn4AfqzeWCas4lA

MIRF:
https://mega.nz/#!e95mAbjQ!3IODmjbqTFaPyV-JfWrcHqYfgZ1kem02rLMNbO3gmKk

Pantalla:
https://mega.nz/#!H5gCzSiL!9PSVtEKC326hzOGqBiLbj_rzA-WvoyYP7OYyO4FoJvc

Proyecto: Sonómetro libre gigante (3)

Bueno, en vista de que ya tengo el programa en mi poder y así como los circuitos, simplemente voy a dejarles los archivos con las cosas necesarias.

Acá el apunte de los circuitos:

https://mega.nz/#!694RnQ6R!qWZPC8xzSQwp9Lj870W4qShS-DBzk9stBCRKRt4QIXc

y acá les dejo el programa del arduino:

https://mega.nz/#!H9JTCC4I!sNSEIdr-0s4SZ7f3xD1z_HjMIeaiBgR1BWE3e-Jup6I

Placa de desarrollo

Hoy les traigo una pequeña placa de desarrollo que realicé para un arduino nano, cuenta con borneras macho para conectar servos, una configuración para conectar un nrf24l01 y borneras hembra. Se puede acceder a cualquier pin de la placa nano (sea o no un pin programable ya sea tanto de entrada como de salida). En principio tiene un puerto USB tipo A, pero por problemas de espacio no pude conectarlo a la placa y quedó soldado para un "futuro" mejoramiento.

Así es la "etapa" final, como se puede ver el USB tipo A está bien ubicado, pero si quiero poner un cable para sacar los datos del mini (para no soldar en la plaqueta de la nano) no me dejaría espacio para conectarlo a la pc.

En la siguiente foto se puede apreciar como es la placa, en este caso puse un diodo con una resistencia para obtener los 3,3v necesarios por la placa del nrf24l01 (me había olvidado que el arduino nano entrega esa tensión, pero decidí dejárselo para no saturar el pin de los 3,3v)

En la siguiente foto (se puede agrandar si hacen click en la foto) se puede apreciar el conexionado entre la bornera del nrf24l01 y las borneras donde va el arduino nano, el dibujo lo puse para no tener que aplicar el circuito del diodo con la resistencia, por lo que se obtienen los 3,3v del arduino.

Y por último para que se pueda apreciar bien, la tira de pines que está más a la derecha es el GND, la que le sigue a la izquierda es el positivo y la tercera línea de pines es el "espejo" de los pines del arduino, así como las borneras hembra que están en la 4º línea, todo esto se repite al otro lado del arduino, siendo la 1º línea la tierra, la 2º línea el postivo y la 3º y 4º líneas son los espejos del arduino.

Como último comentario, si se usa el nrf24l01 no se pueden usar los pines encargados del spi como entradas o salidas normales, esto es porque justamente las está usando el transceptor. Los pines que no se pueden usar son: D13, D12, D11, D10 y D9.

Android y arduino

Bueno, hoy les traigo algunas aplicaciones para android con las que se pueden hacer cosas con arduino.

La primera de todas es un IDE con el cual se puede programar desde una tablet o celular (debe tener capacidad de tener USB OTG. Se llama "ArduinoDroid" y es una aplicación que nos permite escribir código y subirlo al aruino. Lamentablemente no soporta todas las placas, pero si las más "comunes" como:

UNO/UNO_r3
Duemilanove
Nano
Mega 2560
Leonardo
Micro/Pro Micro
Pro/Pro Mini

Tiene una versión paga que nos permite tener algunas opciones más, pero la versión gratuita contiene todo lo necesario (ejemplos, librerías, abrir y editar códigos, crear nuevos códigos y lo más importante, subir el código al arduino desde un dispositivo android).

La segunda es una que nos permite controlar el arduino a través de un puerto USB OTG, y podemos poner distintos pines como entrada o salida y también nos permite poner un valor alto o uno bajo en el arduino desde una interfaz gráfica. La aplicación se llama "Arduino UNO Port Control" y es gratuita. Para poder funcionar, hace falta subir un código (que ellos mismos proveen) al arduino.
Una cosa a tener en cuenta es que solo funciona con el Arduino UNO.
El código (por si no quieren ir a la página a buscarlo) es el siguiente:

byte lineEnding = 0x0A;
byte readBuffer[15];
byte defaultByte = 0x10;

void setup() {   
  for (int i=0; i < sizeof(readBuffer)-1 ; ++i) {
    readBuffer[i] = defaultByte;
  } 
  Serial.begin(9600);
}

void loop() {              
  if (Serial.available() > 14) {
    Serial.readBytesUntil(lineEnding, (char*) readBuffer, 15);
    for (int i=2; i < sizeof(readBuffer)-1 ; i++ ) {                
      if( bitRead(readBuffer[i], 4 )) { pinMode(i,INPUT);} else { pinMode(i,OUTPUT);} 
    }
    
    for (int i=2; i < sizeof(readBuffer)-1 ; i++ ) {                
      if( bitRead(readBuffer[i], 0 )) { digitalWrite(i,HIGH);} else { digitalWrite(i,LOW);}
    }  
  }
}

Links:

ArduinoDroid:
https://play.google.com/store/apps/details?id=name.antonsmirnov.android.arduinodroid2

Arduino UNO Port Control:
https://play.google.com/store/apps/details?id=com.erdemaslan.arduinounodigitalportcontrol

Proyecto: Sonómetro libre gigante (2)

Bueno, nuevamente les traigo el proyecto del sonómetro libre gigante, tengo más fotos y los circuitos.

Bueno, acá van las fotos:

Como se puede obvservar, hay distintos módulos (display, control de potencia, tratamiento analógico de la señal y el arduino que se encarga de hacer el muestreo en el display y unos cálculos).

Acá les dejo un link de todos los circuitos necesarios y en algunos días les dejo el programa:

https://mega.co.nz/#!694RnQ6R!qWZPC8xzSQwp9Lj870W4qShS-DBzk9stBCRKRt4QIXc

¿Sonar?

Bueno, luego de hacer las publicaciones del medidor de distancia por ultrasonido, del servo y de la pantalla, se me ocurrió realizar un radar. En el título lo puse entre signos de pregunta, porque no sé hasta que punto es factible realizarlo, pero si es necesario lo vamos a realizar en 2 o 3 publicaciones.

No es un proyecto propiamente dicho porque no va a tener utilidad. Quizá se pregunten ¿porqué?, bueno la razón o razones son sencillas:

1) Tiene un alcance ridículamente limitado (en las publicación del ultrasonido pude ver que tenía un máximo de 2 metros aproximadamente)

2) Los tiempos van a ser cruciales, por lo que parecería que no se va a poder mostrar en tiempo real el objeto.

Pero a pesar de esas cosas voy a desarrollarlo por "amor al arte" y ver que sale, quizá se pueda conseguir algo interesante.

Entonces, para empezar, voy a reciclar código (como no podía ser de otra forma) de la publicación del servo, de la pantalla y del ultrasonido.

La idea sería mostrar en la pantalla los puntos que se consideran que bloqueen la "vista" del ultrasonido.

Sin más, les dejo el código:

//pantalla
#include <Adafruit_GFX.h>                                    // Core graphics library
#include "SWTFT.h"                                           // Hardware-specific library
//algunos colores
#define negro     0x0000
#define azul      0x001F
#define rojo      0xF800
#define verde     0x07E0
#define cyan      0x07FF
#define magenta   0xF81F
#define amarillo  0xFFE0
#define blanco    0xFFFF
//de la pantalla
SWTFT tft;

//para el touch
#include <stdint.h>
#include "TouchScreen.h"
//declaraciones para el touch
#define YP A1                                                // must be an analog pin, use "An" notation!
#define XM A2                                                // must be an analog pin, use "An" notation!
#define YM 7                                                 // can be a digital pin
#define XP 6                                                 // can be a digital pin

#define MINPRESSURE 10
#define MAXPRESSURE 1000

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

//servo
#include <SoftwareServo.h>
SoftwareServo servo1;

//ultrasonido
#define trigPin 32
#define echoPin 34

int x = 0, y = 0, x1 = 0, y1 = 0, check = 1;
long distancia;

void setup() {
  servo1.attach(30);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  tft.reset();
  tft.begin();
  tft.fillScreen(negro);
  tft.setRotation(3);
  tft.fillCircle(50, 50, 10, blanco);
  Serial.begin(9800);
}

void loop() {
  tft.fillScreen(negro);
  for (int val = 0; val <= 180; val++)
  {
    servo1.write(val);
    ultrasonido();                                                                      //obtenemos la distancia hasta el objeto
    tft.fillCircle((160-(distancia*cos(val))), (240-((distancia*sin(val))/2)), 2, blanco);  //ubicamos el cursor en el medio abajo 
    SoftwareServo::refresh();                                                           //y situamos el punto donde esté el objeto
  }
  tft.fillScreen(negro);
  for (int val = 180; val >= 0; val--)
  {
    servo1.write(val);
    ultrasonido();                                                                      //obtenemos la distancia hasta el objeto
    tft.fillCircle((160-(distancia*cos(val))), (240-((distancia*sin(val))/2)), 2, blanco);  //ubicamos el cursor en el medio abajo
    SoftwareServo::refresh();                                                           //y situamos el punto donde esté el objeto
  }
}

void ultrasonido() {

  long duracion;
a:;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5); 
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(15);
  digitalWrite(trigPin, LOW);
  duracion = pulseIn(echoPin, HIGH);
  SoftwareServo::refresh();
  distancia = (duracion/2) / 29.1;
  if (distancia > 450)
  {
    goto a;                                                                              //si el objeto está muy lejos volvemos a
  }                                                                                      //buscar el valor
  Serial.println(distancia);
}

Servos

Hola, hoy quería mostrarles lo sencillo que resulta manejar un servo con arduino.

Antes de comenzar, voy a hacer una breve explicación de qué es un servo o servomotor de modelismo. Un servo es un dispositivo electromecánico que tiene la capacidad de ir y mantenerse en la posición que se le diga, recibe pulso periódico pwm, que varía de 1mS a 2mS, como muestra la imágen.

Bueno, ahora que saben más o menos qué es y como funciona, vamos al programa.

En la parte de ejemplos, en el ide de arduino, hay una opción que dice "servo", ahí se van a encontrar con 2 ejemplos "knob" y "sweep", si bien estos ejemplos sirven, creo que solo tienen una cantidad de pines limitados (9 y 10), por lo que no se pueden poner más que 2 servos (o al menos eso entendí). Por eso, buscando un poquito me topé con esta otra librería que parece que podría aceptar como salida cualquier pin, soporte o no salidas pwm.

El siguiente códgo lo saqué de este sitio y lo único que hice fue traducir los comentarios.

#include <SoftwareServo.h> 

SoftwareServo myservo;  // crea el objeto servo, para controlar el servo

int potpin = 0;  // pin analógico para conectar el potenciómetro
int val;    // variable que lee el valor analógico

void setup() 
{ 
  myservo.attach(2);  // vincual el servo al pin 2 
} 

void loop() 
{ 
  val = analogRead(potpin);            // lee el valor del pote
  val = map(val, 0, 1023, 0, 179);     // re-escala el valor del pote a 0 - 180
  myservo.write(val);                  // pone el servo en el ángulo escalado del pote
  delay(15);                           // le da tiempo al servo para llegar

  SoftwareServo::refresh();
} 

Bueno, el código parece ser simple, por lo que pude leer, la línea "SoftwareServo::refresh();" tiene que estar cada 50mS o menos, para que el servo funcione correctamente, por lo que eso podría llegar a ser un problema para programas largos, por lo que recomiendo (dependiendo del programa) agregar el siguiente código:

tiempo = micros();

colocar el código acá

Serial.print((micros() - tiempo));

Eso lo que va a hacer es calcular de forma casi precisa cuantos micro segundos pasaron mientras el código se estaba ejecutando, probablemente tenga un error, pero no creo que llegue al mS. En caso de que se superen los 50mS con el código, lo único que hay que hacer es colocar periódicamente "SoftwareServo::refresh();" y ya se soluciona (obviamente siempre teniendo en cuenta que el tiempo sin poner ese fragmento de código no supere los 50mS).

Descargas:

Librería del servo:

https://mega.co.nz/#!blhhhCpS!MpJYJ44tsdfn8ZwFCpdu7anjrVUms-0BXTSjYwX5rhY

Proyecto: Sonómetro libre gigante (1)

Hoy les traigo un proyecto que realicé con otros estudiantes de la facultad FCEIA, más específicamente con el grupo GEII (Grupo de Experimentación Innovativa e Instrumental, por sus siglas en español).

en su etapa final, haciendo las últimas pruebas antes de cerrar la caja.
En esta etapa solo queda encender el dBA y calibrarlo (que se hace una
 vez cerrada la caja)

Se trata de un sonómetro gigante que nos pidieron para medir el sonido de la calle. Consta de una plaqueta con varios circuitos (pre amplificador, amplificador, autorango y un verdadero valor eficaz), un arduino y un equipo de potencia. La plaqueta con los distintos circuitos, se encarga de preparar la señal y convertirla al verdadero valor eficaz para que el arduino (es un arduino UNO) lea el valor analógico y lo convierta a decibeles. Una vez convertido y procesado ese valor va al display (que consta de tiras de led simulando un 7 segmentos gigante). El consumo aproximado del display es de 3 a 4 amperes, por lo que ahí entra en juego la parte de potencia.

En otra entrada (cuando vuelva al GEII, porque ahora está en el receso de invierno) pondré algunos datos más, como los circuitos y el programa, así como algunas fotos y algún video.

Proyecto: integración de módulos (1)

Hoy les quiero mostrar un proyecto en el que llevo trabajando un poco más de 6 meses y sigo ampliándolo casi todos los días.

Se trata de un "dispositivo" a falta de un mejor nombre, que consta de un arduino MEGA 2560, la pantalla de mcufriend (hablé anteriormente en esta otra entrada), el transceptor NRF24L01 y el sensor de temperatura y humedad DTH11.

El proyecto lo realicé porque quería ver cuantas cosas podía integrar en un solo arduino, y como los arduino UNO, NANO y LEONARDO tenían pocos pines I/O decidí pasar al MEGA, con el cual puedo disponer de 53 pines I/O y 15 entradas analógicas. El sistema cuenta con: una comunicación con otro dispositivo (las direcciones todavía no se pueden cambiar) llamado "serv1", un reloj configurable, una linterna en pantalla y sensor de temperatura y humedad. A futuro estoy pensando en agregar un control remoto de domótica y un "generador de ondas" que serviría para generar señales cuadradas con ciertos patrones o frecuencias.

De momento el dispositivo solo puede establecer comunicación inalámbrica con la computadora (por puerto serie) con un arduino NANO y un tranceptor como interfaz (para recibir estoy usando el programa del chat que está en esta otra entrada), pero estoy seguro que si se obtiene el mismo equipo y realizando cambios mínimos (como la dirección de recepción y la dirección de emisión) se debería poder tener ambos equipos con una comunicación entre ellos.

En algunos días, subiré el programa y las librerías. Cuando yo considere que está terminado, voy a crear una página dedicada al proyecto completo para que se pueda ver sin tener que buscar viejas entradas.

Medidor de distancia por ultrasonido

Esta vez les traigo un sensor que es capaz de medir las distancias mediante el sonido, manda un pulso y se cuenta cuanto tiempo demora en llegar, en función de eso se sabe la distancia.
El módulo en cuestión es el SFR05 y se alimenta con los 5V que puede entregar el arduino.

el programa es muy sencillo y no necesita librerías:

#define trigPin 13
#define echoPin 12

void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  long duracion, distancia;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duracion = pulseIn(echoPin, HIGH);
  distancia = (duracion/2) / 29.1;
  }
  if (distancia >= 200 || distancia <= 0){
    Serial.println("Fuera de rango");
  }
  else {
    Serial.print(distancia);
    Serial.println(" cm");
  }
  delay(500);
}

Prueba led variante

Hoy les traigo un programa sencillo que puede llegar a ser útil para ver distintas intensidades de un led, sin usar el pwm (de esta forma se puede obtener mayor resolución) el problema es que consume todo el tiempo de procesamiento.

unsigned long tiempo;
int t = 12, g=0, h=6;

void setup() {

    pinMode(9, OUTPUT);          // Selecciono el pin 9 como salida
}

void loop() {

  tiempo = millis()+1000;        // guardo la cantidad de milisegundos
                                 // que va a haber dentro de 1 segundo
  while (tiempo > millis()) {    // 
    digitalWrite(9, HIGH);       // prendo el led 
    delay(t - g);                // durante un tiempo (t - g)
    digitalWrite(9, LOW);        // apago el led
    delay(g);                    // durante un tiempo g
  }

  tiempo = millis()+1000;        // 
                                 // 
  while (tiempo > millis()) {    // 
    digitalWrite(9, HIGH);       // hago lo mismo que arriba, pero con 
    delay(h);                    // h como variable en lugar de g
    digitalWrite(9, LOW);        // 
    delay(t-h);                  // 
  }
}

Pantalla táctil 2,4"

Hola nuevamente, hoy les traigo unas pantallas del fabricante "mcufriend", el controlador es el SPFD5408. Me costó bastante encontrar las librerías y demás.
Cuenta con un lector de tarjetas micro SD y tiene una resolución de 240 x 320, son un poco lentas pero sirven para la mayoría de las aplicaciones.

Se puede conseguir en DX, al final después de las descargas les dejo el link.

En la librería se pueden encontrar algunos ejemplos muy claros de como funciona, con lo cual no es necesario poner algún ejemplo de mi parte, en la página "proyecto: integrador arduino" van a ver un ejemplo bastante interesante sobre como funciona.

En la carpeta de las librerías de la pantalla ("SWTFT-Shield") hay una carpeta que dice placas, dentro de ella se pueden encontrar 2 archivos, uno es para el arduino UNO y el otro para el mega. Esto es por la disposición de ciertos pines o definiciones de variables (lo corregí hace un tiempo largo ya, por lo que no recuerdo exactamente cual de las 2 cosas era). Para cambiar de placa solo hay que poner el archivo de la placa correcta, borrar lo que tiene en el paréntesis y cambiarlo por el SWTFT que está en la carpeta "SWTFT-Shield". Actualmente está puesto para hacerlo funcionar en un MEGA como se puede apreciar en las fotos de abajo.

Y ahora tienen un pequeño programa de ejemplo que viene con las librerías que es un "paint" en el cual se puede dibujar. Ese programa de ejemplo, en el arduino mega anda mal, está invertido el exe "x" y el eje "y", se podría modificarlo con la función map, pero como son los ejemplos "originales" decidí dejarlo como estaba

Descargas:

Pantalla:

https://mega.co.nz/#!H5gCzSiL!9PSVtEKC326hzOGqBiLbj_rzA-WvoyYP7OYyO4FoJvc


Donde comprar:

http://www.dx.com/p/diy-2-4-tft-lcd-touch-screen-shield-expansion-board-for-arduino-uno-350121

Assembler y arduino juntos.

Hoy les traigo algo interesante. Se trata de agregar porciones de código en assembler al arduino, esto se puede lograr colocando:

__asm__();

Ejemplo:

__asm__("nop\n\t");

Esto lo que hace es un nop (sería un "no operation"), con lo cual se pueden hacer delays de 1 ciclo máquina o dicho de otra forma se puede crear un delay (o tiempo de espera) de 62,5nS o 0,0000000625 segundos. 

Quizá todo esto pueda parecer un poco irrelevante, dado que esa cantidad de tiempo es imperceptible, pero a efectos prácticos se podrían desarrollar porciones de código que corran a una velocidad mayor o más precisamente, aunque como contra hay que aprender un lenguaje nuevo.

Acá les dejo un poco más de información sobre el tema (lamentablemente en inglés):

http://playground.arduino.cc/Main/AVR

https://www.arduino.cc/en/Reference/PortManipulation

http://www.nongnu.org/avr-libc/user-manual/inline_asm.html

módulo NRF24L01

En esta ocación voy a demostrar como se usan los módulos NRF24L01.

Se alimenta con 3,3V (es algo a destacar) pero tolera los 5V de un arduino como señal. Utiliza la interfaz "SPI" para comunicarse y tienen un bajo consumo (se consiguen los NRF24L01+ que tienen significativamente más potencia) que para trabajos de domótica son ideales, además de las librerías (que vienen con algunos ejemplos) les voy a dejar un programa mio que sirva para "chatear" entre 2 computadoras inalámbricamente a través del puerto serie que ofrece el ide de arduino. 

La librería que uso es la MIRF.

El chat es un programa simple, está pensado para comunicar un arduino nano y un mega

También les dejo unos programas para mandar y recibir datos fijos, además del chat en un archivo comprimido.

La idea es que descomenten las partes del código necesarios para el arduino mega o el nano

/*
  Este programa sirve para transmitir y recibir mensajes entre
  2 arduinos, el ejemplo este sirve para un arduino mega a un
  arduino nano. Descomentar según sea el caso.
  V2.5
*/

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

int incomingByte;
byte mensaje[33];

void setup(){
  Serial.begin(9600);

/*
  Mirf.cePin = 48;                          //para arduino mega
  Mirf.csnPin = 49;
*/

/*
  Mirf.cePin = 10;                          //para arduino nano
  Mirf.csnPin = 9;
*/

  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();
  
/*
  Mirf.setRADDR((byte *)"mega");            //para arduino mega
  Mirf.setTADDR((byte *)"nano");
*/

/*
  Mirf.setRADDR((byte *)"nano");            //para arduino nano
  Mirf.setTADDR((byte *)"mega");
*/

  Mirf.payload = 1;
  Mirf.config();
}

void loop(){
  
  if (Serial.available() > 0)               //emisor 
  {
    Serial.print("yo -> ");
    char mensaje_letra;
    while (Serial.available())
    {
      incomingByte = Serial.read();
      mensaje_letra = incomingByte;
      Serial.print(mensaje_letra);
      Mirf.send((byte *)&incomingByte);
      while(Mirf.isSending());
      delay(3);
    }
    Serial.println(" ");
  }
  
  if(Mirf.dataReady())                      //receptor
  {
    Serial.print("el -> ");
    char mensaje_letra;
    int i = 0;
    byte c;
    while (Mirf.dataReady())
    {
      Mirf.getData(&c);
      mensaje[i] = c;
      mensaje_letra = mensaje[i];
      Serial.print(mensaje_letra);
      i++;
      delay(4);
    }
    i = 0;
    Serial.println(" ");
  }
}

Descargas:

Mirf:

https://mega.co.nz/#!e95mAbjQ!3IODmjbqTFaPyV-JfWrcHqYfgZ1kem02rLMNbO3gmKk

Ejemplos:

https://mega.co.nz/#!r1Rw2bCT!u_5bOL2ABX82iC9JWABd5Yka81zIK1WlKwuxrPdO5n8

Información extra:

http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

Comunicación serie

Acá les dejo un pequeño programa para hacer una comunicación serie en la cual se reciben datos por el puerto serie y se devuelven los mismos datos, de esta forma se pueden mandar datos al arduino por esta vía, este programa va a servir para el que voy a subir dentro de un rato.

char hola[33];
int primero = 0, i = 0, cantidad = 0;
void setup() {
  Serial.begin(9600);
}

void loop() {
  if (primero == 0)
  {
    Serial.println("ahora puede empezar a escribir");
    primero = 1;
  }
  while (Serial.available()) 
  {
    hola[i] = Serial.read();
    i++;
    cantidad = 1;
    delay(3);
  }
  
  i = 0;
  if (cantidad > 0)
  {
    for (int i = 0; i < 33; i = i + 1) 
    {
      Serial.print(hola[i]);
      hola[i] = 32;
    }
    Serial.println(" ");
    cantidad = 0;
  }
}

Sensor DHT 11, 22 y 21

Bueno, acá les dejo la librería del DHT, como se puede notar dunciona para las versiones 11, 21 y 22.

El módulo de la imágen es el "DHT 11" y si se mira de frente los pines son el gnd (se puede alimentar desde 3,3v hasta 5v), datos y positivo. No es una herramienta de precisión, porque tiene errores (teóricos) del 5% en humedad y 2ºC en temperatura.

Tiene un rango que va desde los 0ºC hasta los 50ºC.

En el ejemplo adjunto a la librería se puede ver cual es la programación que conlleva (muy sencilla), pero se la puede simplificar más aun.

Acá les dejo un sencillo programa para obtener los datos de temperatura y humedad

#include "DHT.h"
#define DHTPIN 22
#define DHTTYPE DHT11                                      
DHT dht(DHTPIN, DHTTYPE);

void setup () {

  Serial.begin(9800);
  dht.begin();

}

void loop () {

  int h = dht.readHumidity();
  int t = dht.readTemperature();

  Serial.print("temperatura: ");
  Serial.print(t);
  Serial.print("    humedad: ");
  Serial.println(h);
  delay(100);

}

El echo de declarar las variables como int, no influye casi, dado que no tiene la resolución necesaria para mostrar fracciones de grado.

Descargas:

DHT:
https://mega.co.nz/#!K0hi2YaC!Spubjr7ApxeBBqBSpDXeofYLQ9JDDn4AfqzeWCas4lA