Arduino (IoT): Simple Tutorial Sensores T/H

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Sensores T/H

Hasta ahora hemos principalmente enviado informacion a los componentes.  Escribimos datos a una LCD, a motores y LEDs.  Ahora veamos como leer informacion de los componentes.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. DHT11 Sensor de Temp/Humedad
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)
Arduino Sensor Tutorial Santiapps Marcio Valenzuela
Arduino Sensor

 

La conexión es sencilla:

Arduino Sensor Tutorial Santiapps Marcio Valenzuela
Arduino Sensor

El pin de data, a la par del pin de 5V en el sensor, lo conectamos al pin 5 de la MEGA.  Este sera el pin que leeremos en codigo para obtener la data.

El codigo…

#include <dht.h>

dht DHT;

#define DHT11_PIN 5

void setup()
{
Serial.begin(9600);
Serial.println(“DHT TEST PROGRAM “);
Serial.print(“LIBRARY VERSION: “);
Serial.println(DHT_LIB_VERSION);
Serial.println();
Serial.println(“Type,\tstatus,\tHumidity (%),\tTemperature (C)”);
}

void loop()
{
// LEER DATA
Serial.print(“DHT11, \t”);
int chk = DHT.read11(DHT11_PIN);
switch (chk)
{
case DHTLIB_OK:
Serial.print(“OK,\t”);
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print(“Checksum error,\t”);
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print(“Time out error,\t”);
break;
case DHTLIB_ERROR_CONNECT:
Serial.print(“Connect error,\t”);
break;
case DHTLIB_ERROR_ACK_L:
Serial.print(“Ack Low error,\t”);
break;
case DHTLIB_ERROR_ACK_H:
Serial.print(“Ack High error,\t”);
break;
default:
Serial.print(“Unknown error,\t”);
break;
}
// DISPLAY DATA
Serial.print(“Hum”);
Serial.print(DHT.humidity, 1);
Serial.print(“,\t”);
Serial.print(“\n”);
Serial.print(“Temp”);
Serial.println(DHT.temperature, 1);

delay(2000);
}

Finalmente, la data.   La data la obtenemos del Monitor Serial asi:

Arduino Sensor Tutorial Santiapps Marcio Valenzuela
Arduino Sensor Tutorial Santiapps Marcio Valenzuela

DHT BRARY VERSION: 0.1.20

Type, status, Humidity (%), Temperature (C)
DHT11, OK, Hum36.0,
Temp32.0
DHT TEST PROGRAM
LIBRARY VERSION: 0.1.20

Type, status, Humidity (%), Temperature (C)
DHT11, OK, Hum36.0,
Temp32.0
DHT11, Checksum error, Hum36.0,
Temp32.0
DHT11, OK, Hum35.0,
Temp32.0
DHT11, OK, Hum34.0,
Temp32.0
DHT11, OK, Hum34.0,
Temp31.0
DHT11, OK, Hum34.0,
DHT11, Checksum error, Hum34.0,
Temp31.0
DHT11, OK, Hum33.0,
Temp31.0
DHT11, OK, Hum33.0,
Temp30.0
DHT11, OK, Hum35.0,
Temp29.0

Primero inicia midiendo el ambiente, luego el aire acondicionado enfria un poco el ambiente, finalmente pongo un vaso frío (con humedad).  Importante notar que a veces los sensores y/o la comunicación fallan y tenemos un Checksum Error.  Es importante tenerlo en cuenta para mas adelante para asegurarnos que contemplemos arreglos para esos casos a la hora de almacenar o utilizar o comunicar nuestra data.

Es sencillo no?  Con este esquema, si repasamos, básicamente siempre ocupamos un +, un – y uno o mas cables de data.  Veremos tutoriales de sensores mas avanzados pronto.  Por ahora repasemos el camino:

  • Dominamos escribir y leer electricidad a componentes.
  • Eventualmente vamos a tener que comunicar esa data desde nuestro robot a algun almacén mas permanente.
  • Para eso necesitamos componentes de comunicación.

Excelente!  Ahora estamos listos para aprender a comunicar data entre dispositivos.  Esta es la base para cualquier control remoto y definitivamente para cualquier robot decente!

Arduino (IoT): Simple Tutorial LCD

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial LCD

Ya sabemos accionar luces y motores.  Ahora veamos como visualizar informacion en una pantalla LCD que es una tarea muy común para mostrar informacion obtenida de sensores.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. Pantalla LCD
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Una pantalla LCD es un componente un poco mas complicado.  Como pueden ver ya viene montado sobre una tarjeta de circuitos.  Pero no es de asustarse, una tarjeta de circuitos lo único que es, es una conexión de varios componentes de manera fija.  Es mas, en los tutoriales anteriores que hicimos interconexiones usando la breadboard, todos esos cables y resistores y diodos son exactamente eso.  La diferencia es que en una breadboard se ensaya y cuando ya se tiene un circuito bien probado, para no tener todos esos cables colgando, se reduce todo en tamaño y se fijan los cables a una tarjeta de circuitos.

En este caso la pantalla es sencilla (hay mas complicadas) pero lo mas importante es que tiene 16 pines que podemos ver en la esquina inferior derecha.  Estan nombrados:

– VSS, VDD, VO: VDD (+), VSS (-) & V0 (contraste)

– RS, RW, E: RS (registro), RW (Read/Write) & E (enable)

– D0 – D7: D0-D3 (no data), D4-D7 (data)

– A & K: A (backlight) & K (backlight GND)

 

 

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

 

Las conexiones aquí se vuelven un poco mas complicadas asi que prepárense.  Si hay una conexión mas sencilla ahora utilizando un protocolo llamado I2C pero siempre es bueno empezar por lo tradicional y crecer desde allí.

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

Se mira complicado pero no lo es.  Vamos por partes:

  • Primero alimentamos la breadboard con 5V de la MEGA (cable rojo superior izquierdo) y con el GND (cable negro en el centro de la imagen).  Esto es VSS y VDD.
  • Luego un cable azul pequeño en el breadboard conecta al 3er pin en el LCD denominado V0.  Este dijimos que es el contraste.  Es común que las LCDs tenga un controlados de contraste ya que dependiendo de la luz ambiental se puede ver mejor si se ajusta el mismo.  Esto se hace variando la corriente al LCD y ya sabemos que para variar la corriente con un dial, un pot es ideal.
  • Ahora viene un cable rojo vino del pin 12 de la MEGA (RS), un cable negro al GND (R/W) y un cable blanco al pin 11 de la MEGA (E).
  • Luego los pines D0-D3 están libres en este caso.
  • Siguen los 4 pines de datos que se conectan a los pines 2-5 del LCD. (NOTA: usar 4 pines es equivalente a usar el LCD en modo 4-bits y usar los 8 pines es usarlo en modo 8-bits)
  • Finalmente tenemos un resistor al 5V en el backlight (A) y el GND al backlight GND (K).

La alimentacion de VSS y VDD no necesita explicación, es la fuente de poder para la LCD.  La alimentación para el backlight, A & K, tampoco.  Los 4 pines de data es donde enviaremos la data y los 4 pines vacíos pues no hay nada que explicar.  El pin V0 al pot es para regular el contraste.

Lo único que requiere explicación es RS, RW y E.

RS determina si la LCD esta en modo instrucción o caracteres.  En modo instrucción la LCD responde a comandos como limpiar el display o mover el cursor.  A diferencia del modo caracteres que dice a la LCD que reciba data tipo alfanumerica o de símbolos.  Si el RS esta a voltaje bajo o GND, esta en modo instrucción.  Si esta a voltaje alto o 5V esta en modo caracteres.

RW es similar y la distincion radica entre modo de lectura del display (READ) o modo de escritura al display (WRITE).  Read es poco comun pero existe.  Nosotros principalmente estaremos usando el modo write.

Finalmente, E, habilita y deshabilita los dos RS y RW.  Es decir, cuando E tiene voltaje bajo, RS y RW no importan, la LCD no recibe data.  Cuando E recibe voltaje alto entonces lee datos entrantes.

Bueno suficiente explicación, ahora veamos la conexión:

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD Tutorial Santiapps Marcio Valenzuela

Parece complejo pero es tan sencillo como el diagrama que vimos arriba con algunas modificaciones.

De derecha a izquierda

El primer par rojo/negro (err: en la imagen falta el cable negro) es el que alimenta de la MEGA.  El segundo par rojo/negro que sale hacia la esquina inferior derecha son los que alimentan el pot.  El tercer par rojo/negro son los que entran directamente al LCD en sus pines VDD/VSS.  Luego viene el cable verde en la LCD que va al wiper del pot.  Le sigue el cable verde (RS) al pin 12, cable negro(RW) a GND comun y otro cable verde(E) al pin 11.  A continuacion los 4 pines vacios seguidos de los 4 pines (D4-D7) con cables de data.  Finalmente esta el ultimo par rojo/negro a los pines A/K respectivamente.  En resumen deberiamos tener:

LCD -> MEGA -> Breadboard -> Color de Cable –> Otro

VSS –> GND —>  SI ————-> Negro

VDD –> 5V ——> SI ————–> Rojo

V0 ——————> NO ————> Verde —————> Wiper del Pot

RS —–> 12 ——> NO ————> Verde

RW —-> GND —> SI ————–> Negro

E ——-> 11 ——> NO ————> Verde

D0-D3

D4-D7 -> 5-2 ————————-> 5&4 naranja, 3&2 amarillos

A ——-> 5V ——-> SI ————-> Rojo

K ——-> GND —-> SI ————-> Negro

Finalmente el codigo:

//#include <SPI.h> // Esta no la usaremos, es para LCDs con una conexión distinta pero mas avanzada
#include <LiquidCrystal.h>
// initializamos el objeto LiquidCrystal, similar como el Servo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// Nuestro LCD es 16 cols x 2 filas
lcd.begin(16, 2);
// Imprimimos al LCD
lcd.print("Hola Arduino HN!");
}
void loop() {
// Cada loop reseteamos el cursor a col0, linea1
// linea 1 es la 2da fila porque linea 0 es la primera
lcd.setCursor(0, 1);
// Imprimimos segundos desde reinicio...
lcd.print(millis() / 2000);
delay(1000);
}

Y ahora el resultado final…bueno, al menos el mio…

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

 

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

Ok, repasando lo que aprendimos:

  • Aprendimos a usar componentes con varios pines.
  • Tenemos una manera mas amigable para visualizar la data de un proyecto en una pantalla.

Ahora podemos relacionar esto al uso de una pantalla mas sofisticada como una TFT para ver mas datos o incluso TFT touchscreen que nos permite una interacción intuitiva entre el usuario y la data.

En el proximo tutorial aprenderemos a leer data de un sensor.  La idea es comenzar a trabajar con componentes mas sofisticados y con libraries para ir conectándolos de manera que podamos incorporar a nuestro proyecto de datos, la comunicación de esos datos.

Arduino (IoT): Simple Tutorial Motores DC & Servos

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Motores

Ya sabemos controlar flujo de electricidad a luces.  Ahora lo vamos a hacer con motores.  Al igual que con luces hay algunos detalles importantes.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. Motor DC & Servo
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Terminología

Motor DC es un tipo de motor continuo.  Es decir que rota continuamente o infinitamente en la misma dirección.

Motor Servo es un tipo de motor que gira o rota de manera escalonada dependiendo del valor eléctrico pasado al mismo.

 

Arduino DC Servo Motors Santiapps Marcio Valenzuela
Arduino DC & Servo Motors

Comencemos sencillo.  Vamos a conectar primero 1 motor DC a la MEGA y usaremos el Monitor Serial para enviar datos de electricidad a la MEGA para determinar cuanta enviar al motor.

Conozcamos los componentes

Que son estos 3 componentes extraños?

Arduino Motor Tutorial Santiapps Marcio Valenzuela
Arduino Motor

El primero de arriba a abajo es el transistor.  El de en medio lo habíamos usado antes y es un resistor.  El de abajo es un diodo.

Un transistor…

Un Resistor resiste el flujo de corriente en el circuito.

Un diodo controla que el flujo eléctrico solo avance en una dirección.

Ahora entendamos el circuito.

:

Arduino Motor Tutorial Santiapps Marcio Valenzuela
Arduino Motor

Primero veamos el bosque. La corriente fluye de la MEGA 5V por el cable naranja que cruza del centro a la derecha de la imagen.  El cable amarillo cierra el circuito, GND.  El otro cable naranja sale del pin 3 de la MEGA hacia la breadboard.

Veamos estas conexiones en mayor detalle:

Arduino Motores Tutorial Santiapps Marcio Valenzuela
Arduino Motores

Ok, comencemos con la 5V proveniente de la MEGA.  Este cable conecta en la fila 5 de la breadboard (tiene una manga negra en cada punta).  Aquí mismo conecta a la terminal (+) del motor.  Aquí también hace conexión con el diodo, el cual restringe el flujo en una sola dirección.

Luego ese flujo pasa al transistor en una de sus patas extremas que resulta estar conectada a la terminal (-) del motor.  La otra pata del transistor se conecta al cable amarillo proveniente del GND en la MEGA.  Esto deja unicamente la pata central del transistor.  Esta se conecta al resistor quien hace la conexión al pin 3 de la MEGA.

El código es lo mas simple:

int motorPin = 3; // definimos el pin 3 en la MEGA como el del motor
void setup() {
pinMode(motorPin, OUTPUT);  //declaramos ese pin de tipo output
Serial.begin(9600);         // iniciamos el monitor serial
while (! Serial);           // mientras no hay nada en serial, imprimimos un mensaje
Serial.println("Speed 0 to 255");
}
void loop() {
if (Serial.available()){    // Si hay un valor en el Serial, lo leemos...
int velocidad = Serial.parseInt();  //convertimos a un int almacenado en velocidad
if (velocidad >= 0 && velocidad <= 255) // Si dicho valor esta entre 0 y 255...
{
analogWrite(motorPin, velocidad); // lo escribimos al pin del motor
}
}
}

Aquí el video:

Ahora cambiemos el tipo de motor…conozcamos al servo-motor.  Un servo no genera rotación continua sino discrecional y en valores concretos.  Es decir, en lugar de usar la corriente para girar el motor hasta que se retire la corriente, un servo es mas preciso y puede girar exactamente una cantidad determinada dependiendo de la corriente enviada.  Hay servos que giran 180 grados en una dirección y luego 180 en la dirección contraria.  Estos son los mas comunes pero no son los únicos ya que también hay servo motores que giran 360 grados y se usan comúnmente en juguetes como robots y carros.

Hagamos girar un servo-motor y luego podremos jugar un poco con un…juguete. 🙂

Podríamos usar un setup como este:

Arduino Servo Tutorial Santiapps Marcio Valenzuela
Arduino Servo

Aqui vemos como usar el pot para controlar el servo.  Los 5V van al + del pot y la GND va al – del pot.  Habíamos visto que el pin central del pot es el que genera la señal de cuanta corriente fluye dependiendo del dial.  Es decir que aqui lo que hariamos es leer el pin analogo y escribir al pin digital.  De hecho aqui esta el sketch para este proyecto:

#include <Servo.h> 
Servo myservo;  // Creamos objeto servo 
int potpin = 0;  // definimos A0 como pin del pot
int val;    // variable para almacenar valor del pot 
void setup() {
myservo.attach(9);  // Pegamos el servo al pin digital 9
}
void loop() {
val = analogRead(potpin);            // Leemos el pot (valor de 0 – 1023) 
val = map(val, 0, 1023, 0, 179);     // Mapeamos al servo (valor de 0 – 180) 
myservo.write(val);                  // Escribimos valor al servo 
delay(15);                           // Esperamos un rato para volver a empezar 
}

Lo único nuevo aquí, aparte del hecho que un servo tiene un cable adicional, que es el cable que recibe la señal, es que el servo utiliza una library.  Una library no es mas que un set de código adicional que nos permite interactuar con alguna objeto. En este caso el objeto es Servo y lo creamos en la primera linea del código.  Crear ese objeto en código lo que hace es:

  1. Ir al codigo de la library Servo.h y crear un objeto en codigo usando la plantilla del objeto Servo.  Crear uno de estos objetos en codigo nos da propiedades de ese objeto que podemos modificar y funciones de ese objeto que podemos usar.  Por ejemplo la función write que usamos al final nos permite escribir el valor de corriente que queremos al objeto Servo.
  2. Una vez creado uno de estos objetos en código, interactuar con ese objeto es mas sencillo.  Podemos usar funciones como .attach() para conectar el servo real en pin 9 al objeto servo virtual que acabamos de crear.  Otra función es la de .write().  Esta función que esta en la Servo library es un set de instrucciones como nuestra función setup() o loop() que define que hacer con los valores que ponemos adentro de los paréntesis write() para que se conviertan en una señal eléctrica que activen el motor.

Es importante familiarizarnos con libraries y sus métodos porque lo estaremos usando en los siguientes tutoriales que involucran LCDs y comunicaciones usando distintas tecnologías.  De hecho las libraries se vuelven complicadas porque hay distintas versiones para una misma library que tienen pequeñas variaciones y a veces pueden hacer que nuestro código falle.  Pero eso lo veremos en su momento.

Ok, repasando lo que aprendimos:

  • Convertimos aquella LED en un motor.  Lo mismo aplicaría para cerrojos o válvulas de flujo.
  • Convertimos el flujo eléctrico repetitivo a uno condicionado por input del usuario, ie: el ingreso de un valor al Monitor Serial.  Ese input del usuario podría venir de una conexión BT, Wifi, GPRS, NFC etc.
  • O aun mas interesante, en lugar de un usuario que debe accionar el sistema, la condición puede venir del resultado computado de un sensor de luz, sonido, calidad de aire, temperatura, huella digital etc…

En el proximo tutorial exploraremos LCD’s para visualizar información de una manera mas amigable.