Ingeniería en Mecatrónica - Programación Avanzada

Instituto Tecnológico de Colima
Departamento de Ingeniería Industrial
Ingeniería en Mecatrónica
Materia:
Programación Avanzada
Práctica # 11 y 12
LECTURA DE HUMEDAD Y
TEMPERATURA CON EL SENSOR DHT11
CON ARDUINO.
LEER DHT11 Y ENCENDER MOTOR CON
C#.
Alumnos:
Saúl Orozco Maldonado
José Manuel Hurtado Salinas
Christian Emanuel Cuellar Ruvalcaba
Colima, Col.; a 23 de Abril de 2015
I.
INTRODUCCIÓN
Arduino [1] es una herramienta para la fabricación de computadoras que pueden
detectar y controlar más del mundo físico que el equipo de escritorio. Es una
plataforma de computación física de código abierto basado en una placa electrónica
simple, y un entorno de desarrollo para escribir software para la placa.
Arduino se puede utilizar para desarrollar objetos interactivos, teniendo las
entradas de una variedad de interruptores o sensores, y el control de una variedad
de luces, motores, y otras salidas físicas. Proyectos Arduino pueden ser entes
individuales, o pueden comunicarse con el software que se ejecuta en el ordenador
(por ejemplo, Flash, Processing, MaxMSP.) Las tablas se pueden montar a mano o
comprados pre ensamblado; el IDE de código abierto se puede descargar de forma
gratuita.
El lenguaje de programación de Arduino es una implementación de cableado,
una plataforma similar computación física, que se basa en el entorno de
programación multimedia de procesamiento.
El Mega Arduino (Véase figura 1) es una placa electrónica basada en el
ATmega1280 (ficha técnica). Cuenta con 54 pines digitales de entrada / salida (de
los cuales 14 se pueden utilizar como salidas PWM), 16 entradas analógicas, 4
UARTs (puertas seriales), un oscilador de 16MHz, una conexión USB, un conector
de alimentación, una cabecera ICSP, y un botón de reinicio. Contiene todo lo
necesario para apoyar el microcontrolador; basta con conectarlo a un ordenador con
un cable USB o el poder con un adaptador de CA o la batería a CC para empezar.
C# [2] es un nuevo lenguaje de programación de Microsoft que puede utilizarse
en el .NET Framework. Debido a que C# s deriva de C++ y C, los desarrolladores
que ya conozcan estos lenguajes no tendrán que aprender VB.NET para programas
sus páginas ASP.NET.
C# también tiene cierta semejanza con el lenguaje de programación java, por lo
que incluso los programadores de este no deberán tener problemas con él.
Sensor de humedad DHT11 [3] es un sensor muy básico y lento (solo se pueden
obtener datos como mínimo cada 2 segundos), pero es de bajo costo y muy
manejable para obtener datos básicos en proyectos caseros.
Sus características técnicas más destacables son: se puede alimentar con un
voltaje de entre 3V y 5V y 2,5mA como máximo, puede medir un rango de
temperatura entre -40 y 125 °C con una precisión de ± 0,5 °C y un rango de
humedad entre 0 y 100% con una precisión del -2.5%. Está formado básicamente
por un sensor de humedad capacitivo y un termistor como se muestra en la imagen
3.
Los motores de corriente directa (DC) [3] transforman la energía eléctrica en
energía mecánica. Impulsan dispositivos tales como malacates, ventiladores,
bombas, calandrias, prensas y carros, como se muestra en la imagen 4.
Figura 1. Tarjeta de desarrollo Arduino MEGA 2560.
Figura 2. Imagen Visual C#.
Figura 3. Imagen Sensor DHT11.
Figura 4. Motor de DC.
1.1 OBJETIVO DE LA PRÁCTICA
Desarrollar un programa que pueda realizar las dos prácticas pendientes usando la
tarjeta de desarrollo Arduino y usando como activador la comunicación serial por
medio de un programa en C#. el programa deberá leer la temperatura y el porcentaje
de humedad que se encuentra en el ambiente y se pueda activar y desactivar un
motor estableciendo un rango de humedad o manualmente desde la aplicación..
1.2 MATERIALES DE LA PRACTICA







II.
Tarjeta Arduino
Protoboard
LED
Motor de DC
Resistencia
Cables
Sensor DHT11
DESARROLLO DE LA PRACTICA
Para la realización de esta práctica, se tuvo que llevar a cabo en dos etapas, la
primer etapa tuvimos que diseñar la interfaz en Microsoft Visual Studio en
lenguaje de programación C#, está interfaz será la que nos permita
comunicarnos con el Arduino a través de la comunicación serial. El código de
dicho programa de C# se anexará al final de este documento. Haciendo uso de
la consola que este programa nos genera, se utilizó dicha consola para tener la
interfaz de comunicación entre el Arduino y la computadora.
Figura 5. Interfaz de comunicación con Arduino en C#.
La segunda parte entonces, fue el generar el código de comunicación con el
Arduino, así como el código de lectura del sensor, dicho código se anexa de
igual forma al final del documento. La conexión que tuvimos se muestra en la
siguiente imagen.
Figura 6. Conexión del sensor de humedad con Arduino.
Una vez que se realizó la conexión al final únicamente se tuvo que intercalar
entre el monitor serial del Arduino y la interfaz generada por nosotros en C#
para en uno tener las lecturas mostradas en una u en otra interfaz y poder así
por medio de la interfaz generada por nosotros en C# encender o apagar un
motor al llegar el censor a medir determinada cantidad fijada por nosotros de
humedad.
2.1 RESULTADOS
Los resultados fueron los esperados como se plantearon en el objetivo de la
práctica, la conexión en físico fue muy sencilla y por medio del programa en C# y el
programa de la tarjeta arduino se pudo tener el acceso a la comunicación serial con
la cual se mostraron en el computador la temperatura y el porcentaje de humedad
del aula de clases. Posterior mente en el programa se acomodó un porcentaje en
53% de humedad, el cual si era superado activaba el motor y si era menor lo
apagaba.
Si de lo contrario tú deseabas encender el motor de DC manualmente solo desde el
computador lo activabas y desactivabas.
III CONCLUSIONES
Se concluye que con la tarjeta de desarrollo Arduino y Visual Studio usando C#, se
pueden diseñar programas y circuitos para la activación y desactivación de un motor
de DC por medio de comunicación serial, además con el sensor DHT11 se
obtuvieron las medidas de la humedad y la temperatura, dado a que como se
mencionó en la introducción este sensor cuanta con un termistor lo cual nos evita
poner un sensor de humedad y uno de temperatura complicando más la conexión;
de esta manera se tienen costos más bajos al realizar este tipo de prácticas.
ANEXOS.
/////////////////////////////////// Código de comunicación en C# ///////////////////////////////////////////
using System;
using System.IO.Ports;
using System.Threading;
namespace CSharpArduino
{
class Program
{
private static void Encabezado()
{
Console.WriteLine("--------------------------------------");
Console.WriteLine("C# + Arduino usando el System.IO.Ports");
Console.WriteLine("--------------------------------------");
Console.WriteLine("Por Pelumecatronicos");
Console.WriteLine("http://equipoazul.esy.es/");
Console.WriteLine("--------------------------------------");
}
private static void Pie()
{
Console.WriteLine("--------------------------------------");
Console.WriteLine("COM: " + puertoArduino);
Console.WriteLine("LED: " + LED);
Console.WriteLine("--------------------------------------");
}
private static void EsperarParaContinuar()
{
Console.WriteLine("--------------------------------------");
Console.WriteLine("Espere ...");
Console.WriteLine("--------------------------------------");
Thread.Sleep(2000);
}
private static void Menu()
{
Encabezado();
Console.WriteLine("|L|
Console.WriteLine("|S|
Console.WriteLine("|E|
Console.WriteLine("|P|
Console.WriteLine("|Q|
Pie();
}
Listar puertos COM disponibles");
Setear puerto COM del Arduino");
Encender/Apagar MOTOR");
Leer HUMEDAD");
Salir");
private static void ListarPuertos()
{
Console.Clear();
Encabezado();
string[] v = SerialPort.GetPortNames();
Array.Sort(v);
foreach (string s in v)
{
Console.WriteLine(s);
}
EsperarParaContinuar();
}
private static byte puertoArduino = 0;
private static void SetearPuertoArduino()
{
Console.Clear();
Encabezado();
Console.WriteLine("Indicar solo el número de puerto COM");
Console.WriteLine("al que se encuentra conectado la placa");
Console.WriteLine("--------------------------------------");
Console.Write("Númeropuerto: ");
try
{
Console.CursorVisible = true;
puertoArduino = byte.Parse(Console.ReadLine());
Console.CursorVisible = false;
if (
Array.Find(
SerialPort.GetPortNames(),
s => s.Equals("COM" + puertoArduino)
) == null
) throw new Exception();
Console.WriteLine("Puerto " + puertoArduino + " seteado");
}
catch (Exception)
{
Console.WriteLine("(!) Puerto incorrecto");
puertoArduino = 0;
}
EsperarParaContinuar();
}
private static bool LED = false;
private static void EncenderLED()
{
using (SerialPort sp = new SerialPort("COM" + puertoArduino, 9600))
{
sp.Open();
sp.Write(LED ? "L" : "H");
sp.Close();
}
LED = !LED;
}
private static void LeerPOT()
{
Console.Clear();
Console.WriteLine("--------------------------------------");
Console.WriteLine("% HUM:
0");
Console.WriteLine("--------------------------------------");
Console.WriteLine("Presione una tecla para regresar ...");
Console.WriteLine("--------------------------------------");
using (SerialPort sp = new SerialPort("COM" + puertoArduino, 9600))
{
sp.Open();
while (!Console.KeyAvailable)
{
Console.SetCursorPosition(8, 1);
sp.DiscardInBuffer();
Console.WriteLine(sp.ReadByte().ToString().PadLeft(2, ' '));
}
sp.Close();
}
}
static void Main()
{
while (true)
{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Green;
Console.CursorVisible = false;
Menu();
char c = Console.ReadKey(true).KeyChar;
switch (char.ToUpper(c))
{
case 'L':
ListarPuertos();
break;
case 'S':
SetearPuertoArduino();
break;
case 'E':
if (puertoArduino != 0) EncenderLED();
break;
case 'P':
if (puertoArduino != 0) LeerPOT();
break;
case 'Q':
return;
break;
}
}
}
}
}
//////////////////////////////////////////////// Código de Arduino ///////////////////////////////////////////////////
#include <SoftwareSerial.h>
#include "DHT.h"
#define DHTPIN 7
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
pinMode(22,OUTPUT);
dht.begin();
// se define al Pin2 como RX, Pin3 como TX
Serial.begin(9600);
}
void loop()
{
int h = dht.readHumidity();// Lee la humedad
int t= dht.readTemperature();//Lee la temperatura
//////////////////////////////////////////////////Humedad
Serial.print("Humedad Relativa: ");
Serial.print(h);//Escribe la humedad
Serial.println(" %");
delay (2500);
///////////////////////////////////////////////////Temperatura
Serial.print("Temperatura: ");
Serial.print(t);//Escribe la temperatura
Serial.println(" C'");
delay (2500);
///////////////////////////////////////////////////
Serial.println ();
if(h>=54)
pinMode(22,HIGH);
if(h<=53)
pinMode(22,LOW);
}
BIBLIOGRAFÍA
[1] Roberto Guido, ARDUINO, (2015), Arduino mega 2560, Fecha de consulta 26 de
marzo del 2015. http://arduino.cc/en/guide/introduction.
[2] Payne, Chris, Aprendiendo ASP.NET en 21 Lecciones Avanzadas, C#, Fecha de
consulta
14
de
Abril
del
2015,
https://books.google.com.mx/books?id=iXxI7pB8ntkC&pg=PA96&dq=que+es+c%2
3&hl=en&sa=X&ei=Eq4tVamWOIbQsAXUlIHIBA&ved=0CC8Q6AEwAg#v=onepag
e&q=que%20es%20c%23&f=false
[3] Torrente Artero, Oscar, Arduino Curso Práctico de Información, Sensor DHT11,
fecha
23
de
abril
del
2015.
https://books.google.com.mx/books?id=6cZhDmf7suQC&printsec=frontcover&dq=s
ensor+de+humedad+DTH11&hl=es419&sa=X&ei=3oQ5VdeZMcO_sAXkyYG4CA&ved=0CC0Q6AEwAQ#v=onepage
&q&f=false