Pract Lab Ardu v2
Pract Lab Ardu v2
Pract Lab Ardu v2
Clave MTF-1021
Descripción de la práctica No 1
Instalación del “hardware y software” del microcontrolador Arduino.
Introducción.
¿Qué es Arduino?
Arduino es una herramienta para hacer
que los ordenadores puedan sentir y
controlar el mundo físico a través de tu
ordenador personal. Es una plataforma de
desarrollo de computación física (physical
computing) de código abierto, basada en
una placa con un sencillo
microcontrolador y un entorno de
desarrollo para crear software
(programas) para la placa.
Entradas y salidas
Consta de 14 entradas digitales configurables entrada i/o salidas que operan a 5 voltios. Cada
pin puede proporcionar o recibir como máximo 40 ma. Los pines 3, 5, 6, 8, 10 y 11 pueden
proporcionar una salida PWM (Pulse Width
Modulation). Si se conecta cualquier cosa a los
pines 0 y 1, eso interferirá con la comunicación
USB. Arduino Uno, también tiene 6 entradas
analógicas que proporcionan una resolución de 10
bits. Por defecto miden de 0 voltios (masa) hasta 5
voltios, aunque es posible cambiar el nivel más
alto, utilizando el pin Aref y algún código de bajo
nivel.
Esquema y pines
Elementos con los que podemos interactuar:
(tomando como ejemplo la placa USB).
Entorno de desarrollo
Procedimiento:
Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de desarrollo de
Arduino es configurar las comunicaciones entre la tarjeta Arduino y el PC. Para ello deberemos
abrir en el menú "Tools" la opción "Serial Port". En esta opción deberemos seleccionar el
puerto serie al que está conectada nuestra tarjeta. En Windows, si desconocemos el puerto al
que está conectado nuestra tarjeta podemos descubrirlo a través del Administrador de
dispositivos (Puertos COM & LPT/ USB Serial Port).
El primer paso para comprobar que todo lo que hemos hecho hasta ahora está bien y
familiarizarnos con el interfaz de desarrollo, es abrir uno de los ejemplos. Se recomienda abrir
el ejemplo "Blink". Para ello debemos acceder a través del menú File ( Sketchbook ( Examples (
Digital ( Blink.
El ejemplo "Blink" lo único que hace es parpadear un LED que está colocado en el pin número
13 de la tarjeta. Vamos a ver qué hay que hacer para subir el programa a la tarjeta Arduino.
Primero comprobamos que el código fuente es el correcto. Para ello pulsamos el botón de
verificación de código que tiene forma de triángulo inclinado 90 grados (Figura 3.a). Si todo va
bien deberá aparecer un mensaje en la parte inferior de la interfaz indicando "Done
compiling". Una vez que el código ha sido verificado procederemos a cargarlo en la tarjeta.
Para ello tenemos que pulsar el botón de reset de la tarjeta (Figura 3.b) e inmediatamente
después pulsar el botón que comienza la carga (Figura 3.c).
Como se observa en este bloque de código cada instrucción acaba con; y los comentarios se
indican con //. Al igual que en C se pueden introducir bloques de comentarios con /* ... */.
Resultados a entregar:
2.- Modifica los parámetros de delay para que el LED encienda 3 segundos y ½ seg. Apagado. Delay on
en milisegundos: _________________ Delay OFF en milisegundos: ________________
3. Porque razón podemos colocar un Led directamente en el Pin 13 (Salida Digital de Arduino), sin
colocar una resistencia limitadora de corriente?______________________________________________
_____________________________________________________________________________________
5.- Modifica el programa de ejemplo para que al energizar el Arduino, el LED encienda en la siguiente
secuencia:
1 ON 6 segundos
2 OFF 2 segundos
3 ON 10 segundos
4 OFF permanentemente
Escribe en tu reporte el programa que realiza la secuencia solicitada.
Descripción de la práctica No 2
Entradas y salidas digitales.
Nombre: _____________________________________ Mat: __________ Calif: __________
Introducción.
Salidas digitales: Están situadas en la parte de arriba de la placa, van del 0 hasta el 13, este último pin
lleva una resistencia interna incluida, (solo aquí puedes conectar un LED directamente). La señal digital
puede estar o encendida o apagada (LOW o HIGH). Los pines cero y uno se pueden utilizar para cargar el
programa en la placa. Por ejemplo, se utilizan para parpadear un LED o; como entrada, un pulsador.
Salidas PWM (analógicas): Son los pines 11, 10, 9, 6, 5 y 3, tienen una raya curva al lado, se denominan
salidas PWM (Pulse Width Modulation) que realmente son salidas digitales que imitan salidas
analógicas, modificando la separación entre los diferentes pulsos de la señal. La señal PWM puede dar
diversos valores hasta desde 0 a 255 (0 a 5 v.c.d.), se utilizan, por ejemplo para variar la intensidad de un
LED, variar la velocidad de un motor o hacer funcionar un servo, etc. Hay que decir que estos pines
funcionan como salidas o entradas digitales o como salidas analógicas.
Al hablar de Entradas o Salidas digitales se entiende que tanto la información que escuchan como las
respuestas pueden tener solamente dos estados: +5voltios o O voltios. OJO: Esto es solamente cuando
Opción 2 1 O
void setup(){
}
void loop(){
}
La función setup() sirve para definir el comportamiento inicial de mi placa Arduino, es decir cuando la a
una fuente de alimentación (pila, batería). Algunos ejemplos de uso de la función setup() son: Que pines
voy a utilizar, cuáles serán entradas y cuáles salidas, iniciar alguna variable, etc.
La función loop() sirve para definir todas las tareas que Arduino ejecutará repetidamente mientras esté
conectada. Por ejemplo: Leer el valor de las entradas, escribir en los pines de salida, enviar alertas,
emitir sonidos, enviar mensajes por el puerto serial, etc.
pinMode(pin, mode)
Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de
trabajo de un pin pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura 'pin' como salida
Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario
definirlos en el caso de que vayan a trabajar como entradas. Los pines configurados como entrada
quedan, bajo el punto de vista eléctrico, como entradas en alta impedancia. Se accede de la siguiente
manera:
pinMode(pin, INPUT); // Define # pin como entrada
pinMode(pin,OUTPUT); // Define # pin como salida
Los pins configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia y
pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta corriente es
suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es lo
suficiente grande como para alimentar cargas de mayor consumo como relés, solenoides o motores.
Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el
chip ATmega. Puede ser buena idea conectar un pin configurado como salida a un dispositivo externo en
serie con una resistencia de 470 o de 1000 Ω.
digitalRead(pin)
Lee el valor de un pin digital dando un resultado HIGH (alto) o LOW (bajo). El pin se puede especificar ya
sea como una variable o una constante (0-13).
valor = digitalRead(pin); // hace que 'valor' sea igual al
// estado leído en 'pin'
Objetivo. : Conocer y utilizar, las salidas digitales con las que cuenta el microcontrolador
Arduino, aquí se describe como se configuran los puertos para su aplicación como salidas
digitales utilizándolas tanto en niveles digitales (0 y 5 v.c.d) .
Procedimiento:
Programa de luces secuenciales (Torreta), empleando el programa y diagrama abajo descritos, carga el
programa en el Arduino para comprobar su resultado.
/*
Torreta
Enciende y apaga los 8 leds en forma de torreta
int led4 = 6;
int led5 = 7;
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(led7, OUTPUT);
}
digitalWrite(led4, HIGH);
digitalWrite(led5, LOW);
digitalWrite(led6, HIGH);
digitalWrite(led7, LOW);
// Enciende los leds en un patrón de 10101010
delay(1000);
// Retardo de un segundo (1000 milisegundos)
digitalWrite(led0, LOW);
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
digitalWrite(led4, LOW);
digitalWrite(led5, HIGH);
digitalWrite(led6, LOW);
digitalWrite(led7, HIGH);
// Enciende los leds en un patrón de 01010101
delay(1000);
// Retardo de un Segundo (1000 milisegundos)
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
digitalWrite(led6, LOW);
digitalWrite(led7, LOW);
// Enciende los leds en un patrón de 11110000
delay(1000);
// Retardo de un Segundo (1000 milisegundos)
digitalWrite(led0, LOW);
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
digitalWrite(led6, HIGH);
digitalWrite(led7, HIGH);
// Enciende los leds en un patrón de 00001111
delay(1000);
// Retardo de un segundo (1000 milisegundos)
}
//===========================================================
Por tanto podemos usar un valor típico igual o superior a ese. En mi caso, utilizaré una de 220Ω que
tengo al alcance, proporcionando al led una corriente algo menor a 10mA, pero suficiente para que se
ilumine. Además, de esta forma, alargaremos la vida del led. Con éstos números es obvio que una
resistencia de un cuarto de watt nos valdrá:
1. Modifica el primer programa de tal manera que los led enciendan siguiendo el siguiente
patrón: 10000001, 010000010, 00100100, 00011000, 00100100, 01000010, 10000001
2. Modifica nuevamente el programa de tal manera que el tiempo de retardo sea de ½ segundo,
reporta programa que realiza esta función.
Descripción de la práctica No 3
Entradas digitales del microcontrolador Arduino.
Nombre: _____________________________________ Mat: __________ Calif: __________
Introducción.
Para el correcto uso de lecturas digitales en Arduino, es necesario acondicionarlas empleando las
denominadas Resistencias Pull-Up y Pull-Down, y cómo actúan sobre nuestros circuitos para eliminar
aleatoriedades de tensión.
Como sabemos, las señales digitales se identifican por estados lógicos (0 y 1, ON y OFF). En
nuestros proyectos con Arduino, identificaremos una entrada digital como activada cuando su tensión
es de 5v (salvo modelos con 3,3v), y desactivada cuando su tensión es de 0v. Son los dos únicos casos
posibles, de tal forma que los podemos identificar con los famosos 1 y 0. Así pues, para distinguir si una
entrada está a 1 o a 0, Arduino ha de distinguir si la tensión está por encima de 2,5v o por debajo.
– En el caso de la resistencia Pull-Down, lo que nos asegura es que, cuando el interruptor está abierto,
toda posible fluctuación de tensión residual decaiga en la resistencia, consiguiendo a la entrada un valor
lógico de 0 (LOW). En el caso de haber obviado la resistencia, al abrir el interruptor, no podríamos
asegurar que a la entrada fueran a existir valores de tensión menores que 2,5 v.
– En el caso de la resistencia Pull-Up el comportamiento es justamente al revés, asegurándonos un valor
lógico de 1 (HIGH).
1 Resistencia de 220 Ω
1 Resistencia de 10 kΩ.
1 Protoboard.
1 Juego de cables.
Procedimiento:
Para comprobar la operación de entradas y salidas digitales simultáneamente, armar el siguiente
circuito:
Programa a utilizar:
/*
E/S DIGITALES
*/
// Variables estáticas
// Variables dinámicas
void setup() {
pinMode(pinLed, OUTPUT);
pinMode(pinBoton, INPUT);
void loop(){
// en la variable estadoBoton
estadoBoton = digitalRead(pinBoton);
if (estadoBoton == HIGH) {
digitalWrite(pinLed, HIGH);
else {
digitalWrite(pinLed, LOW);
Asume ahora que el switch seria un switch magnético (reed switch), como los utilizados en alarmas
residenciales los cuales se colocan en el marco de la puerta alineados con un iman permanente.
Resultados a entregar:
1.- Reporta el programa y las conexiones requeridas para la simulación de la alarma residencial.
Posteriormente podrías experimentar, substituyendo el led por un “Buzzer” piezoeléctrico para tener
salida auditiva. Investiga cómo se realizaría este cambio.
Referencia en videotutorial:
Manejo de teclado matricial; https://www.youtube.com/watch?v=-Hhb-mamd10
Descripción de la práctica No 4
Conversión A/D del microcontrolador Arduino
Introducción.
Objetivo. Conocer y utilizar los puertos del microcontrolador Arduino orientados como
entradas de valores analógicos utilizando primeramente un potenciómetro para simular una
entrada análoga de 0-5 v.c.d. y posteriormente emplear un sensor de temperatura del tipo
LM35 configurando para ello el puerto USB, teniendo la posibilidad de leer los valores en
grados centígrados directamente en la pantalla de la computadora.
Procedimiento:
1.- Primeramente utilizaremos un potenciómetro de 10,000 ohms (10K), para introducir a la entrada del
Arduino una señal que varie de 0 a 5 voltios, simulando asi una señal analógica que podría venir de un
señor. Esta variable la vamos a leer en el Arduino con un valor que varia de 0 a 1023 (resolución del
convertidor A/D 10 bits), para comprobar esto, realizaremos las siguientes conexiones:
Empleando el mismo programa del potenciometro, observa el valor que envia el sensor al
aumentar su temperatura (tocarlo sin hacer contacto con las terminales).
Resultados a entregar:
1.- Reporta los resultados obtenidos (conexiones, programa y valores obtenidos en los 2 programas de
prueba del sensor LM35.
2.- Reporta tus conclusiones
Descripción de la práctica No 5
Salidas de señales analógicas del microcontrolador Arduino.
Nombre: _____________________________________ Mat: __________ Calif: __________
Introducción.
Objetivo. Conocer y utilizar los pines orientados en aplicaciones donde se requieren salidas
análogas para ello se revisara la teoría de modulación de ancho de pulso, realizando ejercicios
de regular el brillo de un diodo tipo “LED” y posteriormente aplicarlo al ejemplo de variación
de velocidad de un motor de c.d. de baja potencia.
Frecuentemente, se intenta controlar un motor DC u otra carga, mediante una resistencia variable
conectada a un transistor.
Si bien este sistema funciona, genera gran cantidad de calor y perdidas de potencia.
Existe una técnica llamada modulación de ancho de pulso, la cual se elimina ese problema controlando
la velocidad de un motor DC u otra carga de corriente directa, mediante la modulación por ancho de
pulso. Cuando más ancho es el pulso, mayor es la velocidad del motor y viceversa, como lo vemos en la
figura:
Podemos observar que la frecuencia de la señal no cambia, (periodo fijo), al cambiar el ancho del pulso
se cambia el voltaje promedio de su salida. Esta técnica es usada por el Arduino empleada como su
salida analógica de 8 bits de resolución, esto representara un numero de 0 a 255 donde 0 enviara 0
voltios y 255 enviara a su salida 5 voltios.
Procedimiento:
Dentro de los ejemplos incluidos en el software de Arduino, existe uno llamado “FADE”, el cual
demuestra como variando el ancho de pulso (PWM) a la salida del Pin #9 configurado como salida
análoga envía una señal que encenderá gradualmente (Fade In) el brillo de un Led y posteriormente se
va disminuyendo se brillo (Fade Out), hasta apagarse y se repite este efecto cíclicamente. Llamaremos a
este programa “Latido de corazón”, para probarlo, debemos escribir y cargar en el Arduino el siguiente
programa:
Ahora, modificaremos nuestro circuito, añadiendo yn potenciómetro de 10 K ohms, para con este
regular el brillo del Led. Utilizaremos el siguiente programa:
Diagrama de conexiones:
El transistor 2N2222 es capaz de manejar corriente hasta unos 800 ma. Si tu motor requiere
mas corriente, podemos usar el transistor TIP41.
El programa a usar seria el mismo con el que regulamos el brillo del Led. Deberas reportar los
programas, fotografias de los circuitos armados y datos de consumo del motor que utilizaste.
Referencia en video:
Descripción de la práctica No 6
Sensores y acondicionamiento de señal.
Introducción.
La señal de salida del sensor de un sistema de medición en general se debe procesar de una forma
adecuada para la siguiente etapa de la operación. La señal puede ser, por ejemplo, demasiado pequeña,
y sería necesario amplificarla; podría contener interferencias que eliminar; ser no lineal y requerir su
linealización; ser analógica y requerir su digitalización; ser digital y convertirla en analógica; ser un
cambio en el valor de la resistencia, y convertirla a un cambio en corriente; consistir en un cambio de
voltaje y convertirla en un cambio de corriente de magnitud adecuada, etcétera. A todas estas
modificaciones se les designa en general con el término acondicionamiento de señal. Por ejemplo, la
salida de un termopar es un pequeño voltaje de unos cuantos milivolts. Por lo tanto, es necesario utilizar
un módulo acondicionador de señal para modificar dicha salida y convertirla en una señal de corriente
de tamaño adecuado, contar con un medio para rechazar ruido, lograr una linealización, y una
compensación por unión fría (es decir, la compensación cuando la unión fría no está a 0 °C).
1 Linealización
6 Adaptación de impedancias
7 Modulación y demodulación
La fotoresistencia (Ligth depending resistence LDR), es básicamente una resistencia variable que
depende de la variación de la luz.
Necesitaras una resistencia pull-down para evitar un corto en el pin del Arduino, esto es el
acondicionamiento de señal para este especifico tipo de sensor resistivo.
Este circuito trabajara entre 0-5VSi la luz es muy intensa, se satura a 5V.
Colocando un potenciometro de 10k (en lugar de la resistencia fija) , permite regular la posible
saturación del sensor.
La figura de arriba muestra la caracteristica tipica de respuesta de este sensor, observar que
es no lineal e inversamente proporcional su respuesta de cambio de resistencia respecto a
Luxes, recuerda que dentro de el acondicionamiento existe la linealizacion, esta se puede
aplicar por circuitos (hardware), o por programa (softwate).
Toma nota de los resultados obtenidos al variar la intensidad de la luz que incide en el sensor LDR.
1.- describe de qué forma se está acondicionando por software el valor del sensor bajo prueba.
2.- añade al programa el siguiente código, que permitirá encender un led al obscurecer la luz del sensor.
Nota: el valor de 490 empleado en la comparación del “IF” puede variar dependiendo del tipo de LDR
empleado, deberás verificarlo en el caso específico de tu sensor.
El circuito de prueba será el siguiente:
Descripción de la práctica No 7
Sensores especiales.
Introducción.
Sensor basado en ultrasonido modelo HC-SR04
El sensor de ultrasonidos se enmarca dentro de los sensores para medir distancias o detectar
obstáculos, nivel de líquidos y sólidos, entre otras posibles funciones.
En este caso vamos a utilizarlo para la medición de distancias. Esto lo consigue enviando un
ultrasonido (inaudible para el oído humano por su alta frecuencia) a través de uno de la pareja
de cilindros que compone el sensor (un transductor) y espera a que dicho sonido rebote sobre
un objeto y vuelva, retorno captado por el otro cilindro. Existen versiones de 3 Pines y 4 pines
como el que utilizaremos en esta práctica el modelo HC-SR04.
Este sensor en concreto tiene un rango de distancias sensible entre 3cm y 3m con una
precisión de 3mm.
El tiempo que transcurre entre el envío (ping) y la recepción (echo) del ultrasonido.
Conociendo que la velocidad del ultrasonido en el aire es de valor 340 m/s, o 0,034
cm/microseg. (ya que trabajaremos con centímetros y microsegundos). Para calcular la
distancia, recordaremos que v=d/t (definición de velocidad: distancia recorrida en un
determinado tiempo).
De la fórmula anterior despejamos d, obteniendo d=v·t, siendo v la constante anteriormente
citada y t el valor devuelto por el sensor a la placa Arduino.
También habrá que dividir el resultado entre 2 dado que el tiempo recibido es el tiempo de ida
y vuelta.
Material
Objetivo. Utilizando uno de los sensores más populares para medir distancia, nivel de líquidos
y otras aplicaciones donde se requiere que el microcontrolador detecte distancia se describe
como configurar y utilizar el sensor ultrasónico tipo hc-sr04.
Procedimiento:
Conexiones a realizar
Programa de prueba:
/*
HC-SR04 sensor de distancia
VCC to arduino 5v
GND to arduino GND
Echo to Arduino pin 7
Trig to Arduino pin 8
*/
void setup() {
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(LEDPin, OUTPUT); // Use LED indicator (si es requerido)
}
void loop() {
/* el siguiente trigPin/echoPin ciclo es usado para determinar la
distancia del objeto . */
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
1.- Modifica el programa para que actué como una alarma de proximidad, la cual deberá de encender un
Led cunado un objeto se aproxima a una distancia menor de 50 centímetros.
2.- Reporta el programa que obtuviste así como el diagrama de conexiones para esta alarma.
3.- Modifica y reporta y reporta nuevamente el programa, de tal manera que ahora actué como un
control de nivel de líquido de un depósito.
4.- Reporta el programa que obtuviste así como el diagrama de conexiones para este medidor de nivel
de líquidos.
Referencia en videotutorial:
HC-SR04 (4 pines) https://www.youtube.com/watch?v=b-5lcVebV_w
Sensor ultrasónico marca Paralax (3 pines); https://www.youtube.com/watch?v=T0SXMIM2aV4
Alarma de reversa de auto; https://www.youtube.com/watch?v=-cK5-Nv1Bfk
Descripción de la práctica No 8
Displays del tipo LCD.
Introducción.
Los displays LEDs de 7 segmentos, son baratos y prácticos, pero tienen el inconveniente de que
no pueden mostrar mensajes de texto, sino solo números.
Para mostrar mensajes de texto, números o símbolos, podemos usar los displays LCD. Son
fáciles de encontrar en diversos formatos: 16×2 (16 caracteres x 2 líneas) o LCD 16×4 (16
caracteres x4 líneas).
LCD viene del inglés Liquid Crystal Display, o sea Pantalla de cristal liquido.
Son una opción muy sencilla de usar, y además, elaborar tus proyectos de manera mas
profesional, y por eso, en los últimos años los displays LCD han ganado mucha aceptación en
productos comerciales de todo tipo.
Básicamente porque:
Son baratos.
Están disponibles en varios tamaños y configuraciones.
Son de bajo consumo.
Muy prácticos si te basta con mostrar solo texto (y algunos caracteres especiales).
Aunque, últimamente, estos displays suelen venir con los pines soldados, todavía hay muchos sitios que
cuando compras uno de estos, te lo envían en kit, con los pines aparte para que los sueldes
Esquema de conexión:
La conexión no es complicada, pero requiere ser cuidadoso. Asi que vamos a ir paso a paso con los
diferentes cables. Empieza conectando tensión y GND a la protoboard.
Vamos ahora a a conectar la alimentación el panel LCD. Conecta el pin16 del LCD a Ground y el 15 a 5V
Vamos a conectar ahora, el potenciómetro de ajuste. Para ello conecta uno de los extremos del
potenciometro a GND y el otro a 5V. El centro al pin 3 del LCD.
Aprovechemos también para dar tensión al panel LCD, El pin 1 va a GND y el 2 a tensión:
Si todo ha ido bien, ya podemos encender el dispay y probarlo. Conecta el USB a tu Arduino y veamos. Si
vas girando el potenciómetro, en algún momento tienes que ver unos cuadraditos en la pantalla,
en caso contrario revisa las conexiones.
Procedimiento:
Vamos a usar una librería de control del panel LCD, que viene incluida en nuestro Arduino, localizada
en:
\\Programa\Importar Libreria\LiquidCrystal
Y ahora podemos importar uno de los ejemplos o escribir el nuestro, comentando el código.Lo primero
es que al importar la librería nos ha escrito esto:
#include <LiquidCrystal.h>
Despues, hay que inicializar la librería. Creamos una instancia llamada lcd, de la clase LiquidCrystal y le
pasamos como parámetros los pines que hemos usado:
LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // ( RS, EN, d4, d5, d6, d7)
Tener cuidado porque los pines que hemos usado, no corresponden a los ejemplos de Arduino, así que
puedes cargarlos, pero asegúrate de cambiar la línea de definición de los pines.
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup()
{
lcd.begin(16, 2); // Fijamos el numero de caracteres y filas
lcd.print("Prometec.net"); // Aqi va el mensaje
}
void loop()
{
lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6
String s = reloj() ;
lcd.print(s) ;
}
String reloj()
{
int n = millis() / 1000 ; // Lo pasamos a segundos
int segundos = n % 60 ;
int minutos = n / 60 ;
String S = String(minutos) + ":" + String(segundos);
return (S);
}
Es importante, comentar algunas cosas de este código. En primer lugar en la función reloj, calculamos
los minutos y segundos a partir del reloj interno de Arduino en milisegundos, no hay nada nuevo en
esto. Pero observa que hemos definido reloj como String: String reloj()
Eso significa que vamos a devolver un parámetro tipo String a quien nos haya llamado. En algún punto
de la función habrá que hacer un return( String).
Observa que definimos dentro de la función un string llamado s:
String S = String(minutos) + ":" + String(segundos);
Para sacar el mensaje de texto. Todo lo que ya sabéis de Serial.print() se usa exactamente igual con esta
instrucción. Y por último, tenemos una línea como esta:
Que lo que hace es posicionar el cursor del panel, en la posición 6 de la segunda línea, para escribir la
hora centrada. Aquí os dejo un mini video con el resultado.
La librería LCD, viene con varios ejemplos muy interesantes, que os conviene probar. Recuerda ,
simplemente, que tienes que cambiar las definiciones de los pines para que corran.
Es muy interesante que veamos cómo definir algunos caracteres especiales, porque en la tabla base del
LCD, no están incluidas ñ, acentos, grados, etc. Así que dependiendo del uso que le deis pude seros de
interés saber cómo definir tus propios símbolos.
Vamos a definir un carácter propio, para digamos, el símbolo de grados centígrados, por ejemplo.
Lo primero que tenéis que saber, es que los caracteres se definen con un array ( si, de nuevo) de
8×8, como si los dibujarais en una cuadricula de ese tamaño, y rellenando el cuadradito completo.
byte grado[8] =
lcd.createChar(0, euro);
lcd.createChar(1, grado);
Y ahora ya estan disponibles. Tener en cuenta que solo podemos definir 8 caracteres especiales en un
momento dado ( Aunque podemos definir 30 arrays, de caracteres y crearlos y matarlos sobre la
marcha).
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
byte grado[8] =
{
0b00001100,
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};
void setup()
{
lcd.begin(16, 2); // Hay que inicializar el LCD
lcd.createChar(1, grado);
lcd.setCursor(0, 0);
lcd.print("Estamos a 25");
lcd.write(1);
}
void loop()
{
}
Resultados a entregar:
1.- Conecta un sensor de temperatura y realiza el programa que muestre la temperatura en grados
centígrados como se mostro en la imagen de arriba.
2. Reporta el diagrama de conexiones, programa usado y tus conclusiones.
Descripción de la práctica No 9
Drivers de potencia media y puente “H”.
Introducción.
Las salidas de Arduino, sus pines son ideales para controlar directamente los pequeños
elementos eléctricos, como los LED. Sin embargo, cuando se trata de dispositivos de consumos
más grandes (como un motor de juguete o el de un relevador), es necesario un controlador
externo. Un transistor es increíblemente útil. Se obtiene una buena cantidad de corriente de
colector con una, mucho menor alimentada a su base. Un transistor tipo NPN, conectaremos la
carga (M1) al colector del transistor y el emisor al negativo o masa. Así, cuando la señal alta del
pin de nuestro Arduino alcance la base, fluirá una pequeña corriente por R1 (2K) de la base al
emisor y la corriente a través del transistor fluirá y el motor girará, si se alimenta una señal
PWM podra regularse la velocidad, como se muestra en la figura el diagrama basico.
Si los requerimientos de corriente exeden los 800 ma. Podemo usar el transistor TIP41 para
mayor potencia. Si requerimos controlar simultaneamente mas de un motor, podemos utilizar
algunos circuitos integrados para este requerimiento, por ejemplo para 8 cargas de c.d.
podemos usar el C.I. ULN2803A que contiene 8 par darlington, com se muestra en la figura:
Como puede observar para girarlo en sentido directo cerramos los interruptores S1 y S4 y para
sentido inverso cerramos S3 y S2. A este arreglo se le denomina puente “H:.
Observa que este circuito emplea una fuente adicional para el suministro de potencia de la
carga, o sea que no se alimenta del Arduino.
Ejemplo de aplicación; si deseamos construir un robot móvil gobernado por 2 motores de c.d.
con reducción de engranes, podemos emplear el circuito anteriormente descrito, de una
manera simple y rápida usando un Arduino y un solo C.I. L293D, como se muestra en las
figuras:
Procedimiento:
ARDUINO L293D(Puente H)
5 10
6 15
9 7
10 2
5V 1, 9, 16
GND 4, 5, 12, 13
*/
int izqA = 5;
int izqB = 6;
int derA = 9;
int derB = 10;
int vel = 255; // Velocidad de los motores (0-255)
void setup() {
pinMode(derA, OUTPUT);
pinMode(derB, OUTPUT);
pinMode(izqA, OUTPUT);
pinMode(izqB, OUTPUT);
}
void loop() {
analogWrite(derB, 0); // Detiene los Motores
analogWrite(izqB, 0);
delay (500);
analogWrite(derA, vel); // Frente 2 segundos
analogWrite(izqA, vel);
delay (2000);
Resultados a entregar:
1.- Empleando el C.I. L293D, elabora un circuito de tal forma que el Arduino controle la
velocidad de 2 motores de c.d. de 9 v. realizando un avance hacia adelante y giros de
tal forma que recorra una trayectoria rectangular.
Descripción de la práctica No 10
Servomotores y motores de paso
Introducción.
MOTORES, SERVOMOTORES Y MOTORES PASO A PASO
Este tipo de motores tienen una rotación continua rápida y son utilizados para cualquier cosa
que necesite para hacer girar a altas RPM por ejemplo, ruedas de carro, ventiladores, etc
Servomotores
Los servomotores son en general un conjunto de cuatro cosas: un motor de corriente continua,
un conjunto de engranajes, un circuito de control y un sensor de posición que puede ser un
potenciómetro.
Los servos no giran libremente como un motor de corriente estándar, sino que el ángulo de
rotación se limita a 180 grados de ida y vuelta. Los servomotores reciben una señal de control
Como este tipo de motores tienen un alto par rápido y rotación precisa dentro de un ángulo
limitado son por lo general una alternativa de alto rendimiento a los motores paso a paso son
adecuados para brazos robóticos / piernas o control del timón, etc.
1.- Modifica el programa del servomotor de manera que rote sin el potenciómetro de
30 a 120 grados en un ciclo de ida y vuelta temporizado a 4 segundos.
2.- Modifica el programa del motor de pasos, de tal manera que gire en sentido inverso
al programa de la práctica y a una velocidad de 1 segunda en su ciclo de ida y vuelta.
Descripción de la práctica No 11
Tarjetas de expansión (Shields), del microcontrolador Arduino.
Introducción.
¿Qué es un Shield?
Un shield es una placa impresa que se pueden conectar en la parte superior de la placa
Arduino para ampliar sus capacidades, pudiendo ser apilada una encima de la otra.
Las shields suelen ser diseños bastante simples y en general de código abierto, el
diseño suelen ser publicados libremente. Podemos encontrar shields un poco más
sofisticadas, incluyendo una unidad de medida inercial con una estructura en seis
giroscopios DOF para su uso como parte de un piloto automático en un avión modelo.
Existe una lista de shields con los detalles de sus conexiones y la especificación básicas
aquí (http://shieldlist.org/), en la pagina oficial se encuentra publicada otra lista un
poco menos completa (http://www.arduino.cc/en/Principal/ArduinoShields)
Via: Design Spark.
Esta última versión incluye un slot para tarjetas micro-SD, el cual puede ser empleado
para almacenar archivos que podrás poner disponibles a través de la red. Es
compatible con el Arduino UNO y el Mega (empleando la librería que viene en la
versión de software Arduino 0019). La librería para el manejo de la tarjeta todavía no
está incluida en la distribución estándar de Arduino pero puedes emplear la
desarrollada por Bill Greiman sdfatlibl. Revisa este tutorial de Adafruit Industries para
las instrucciones de uso.
Con esta tarjeta podrás controlar las entradas y salidas de Arduino vía conexión de red
local y a su vez por INTERNET, usando los protocolos HTTP, Telnet, FTP, etc.
Este “Shield”, Bluetooth shield Integra un modulo Bluetooth serial. Puede ser utilizado
fácilmente con Arduino y es transparente para la comunicación serie inalámbrica.
Puede optar por dos pines de Arduino D0 a D7 como puertos de serie del software
para comunicarse con Bluetooth Shield (D0 y D1 es el puerto de serie del hardware).
También dispone de dos conectores conectar y listo (una es digital, el otro es
analógico) para la instalación de módulos conectar y listo
Nota: El shield puede no ser compatible con algunos dispositivos Bluetooth capaz,
como algunos teléfonos móviles HTC (G-7 con Android 2,33) y los dispositivos de Apple
con perfil especial sobre la función Bluetooth. Como puedes este modelo observar no
es la tarjeta Shield tradicional es su tamaño.
Esta tarjeta es ideal para el control remoso de dispositivos a corta distancia via Celular
u otro dispositivo que cuente con interfaz Bluetooth.
Procedimiento:
Módulo Bluetooth
El Bluetooth es un estándar de comunicación inalámbrica que permite la transmisión
de datos a través de radiofrecuencia en la banda de 2,4 GHz. Existen muchos módulos
Bluetooth para usarlos en nuestros proyectos de electrónica, pero los más utilizados
son los módulos de JY-MCU, ya que son muy económicos y fáciles de encontrar en el
mercado. Son módulos pequeños y con un consumo muy bajo que nos permitirán
agregar funcionalidades Bluetooth a nuestro Arduino. Estos módulos contienen el chip
con una placa de desarrollo con los pins necesarios para la comunicación serie.
Existen dos modelos de módulos Bluetooth: el HC-05 que puede ser maestro/esclavo
(master/slave), y el HC-06 que solo puede actuar como esclavo (slave). La diferencia
entre maestro y esclavo es que en modo esclavo es el dispositivo quien se conecta al
módulo, mientras que en modo maestro es el módulo quien se conecta con un
dispositivo.
Físicamente, los dos módulos son muy parecidos, solo varían algunas conexiones. Los
pins que encontraremos son los siguientes:
-Vcc: Alimentación del módulo entre 3,6V y 6V.
-GND: La masa del módulo.
-TXD: Transmisión de datos.
-RXD: Recepción de datos a un voltaje de 3,3V.
Comandos AT
Los comandos AT son un tipo de comandos que sirven para configurar el módulo
Bluetooth a través de un microcontrolador, un ordenador o con cualquier dispositivo
que posea una comunicación serie (Tx/Rx). Son unas instrucciones que nos permiten
cambiar los baudios del módulo, el PIN, el nombre, etc. Para usar los comandos AT el
módulo Bluetooth no debe estar vinculado a ningún dispositivo (led rojo del módulo
parpadeando). Según las especificaciones del módulo, el tiempo que se tiene que
respetar entre el envío de un comando AT y otro tiene que ser de 1 segundo. Si se
envía un comando AT y en menos de un segundo se envía otro, el módulo no devuelve
respuesta.
Ahora vamos a configurar el módulo Bluetooth a través de comandos AT enviados
desde el Monitor Serial del Arduino. El código del Arduino necesario tanto por el
módulo HC-05 como el HC-06 es el siguiente:
1 #include <SoftwareSerial.h> //Librería que permite establecer comunicación serie en otros pins
6 void setup()
7 {
10 }
12 void loop()
13 {
14 if(BT.available())
15 {
16 Serial.write(BT.read());
17 }
18
19 if(Serial.available())
20 {
21 BT.write(Serial.read());
22 }
23 }
Entre los dos modelos de módulo Bluetooth existen diferencias a la hora de enviar los
comandos AT:
HC-06
En el HC-06 solo se necesitan cuatro pins: Vcc, GND, TXD y RXD. El pin KEY no es
necesario.
Al enviar un comando AT no se debe enviar ningún carácter de LF (nueva línea) ni CR
(retorno de carro) al final del comando. En el Monitor Serial del Arduino tenemos que
poner No hay fin de línea.
Los comandos AT que se pueden enviar en este módulo son los siguientes:
En el HC-05 se pueden enviar muchos más comandos AT que en el HC-06. Aquí dejo un
archivo pdf con todos los comandos AT.
2 www.diymakers.es
4 Arduino + Bluetooth
6 */
8 #include <SoftwareSerial.h> //Librería que permite establecer comunicación serie en otros pins
12
13 int green=4;
14 int yellow=5;
15 int red=6;
19 void setup()
20 {
21 BT.begin(9600);
22 Serial.begin(9600);
23 pinMode(green,OUTPUT);
24 pinMode(yellow,OUTPUT);
25 pinMode(red,OUTPUT);
26 }
27
28 void loop()
29 {
31 if(BT.available())
32 {
34
36
37 //Cuando reciba una nueva línea (al pulsar enter en la app) entra en la función
38 if(dato=='\n')
39 {
41
42 //GREEN LED
43 if(strstr(cadena,"green on")!=0)
44 {
45 digitalWrite(green,HIGH);
47 if(strstr(cadena,"green off")!=0)
48 {
49 digitalWrite(green,LOW);
50 }
51 //YELLOW LED
52 if(strstr(cadena,"yellow on")!=0)
53 {
54 digitalWrite(yellow,HIGH);
55 }
56 if(strstr(cadena,"yellow off")!=0)
57 {
58 digitalWrite(yellow,LOW);
59 }
60 //RED LED
61 if(strstr(cadena,"red on")!=0)
62 {
63 digitalWrite(red,HIGH);
64 }
65 if(strstr(cadena,"red off")!=0)
66 {
67 digitalWrite(red,LOW);
68 }
69 //ALL ON
70 if(strstr(cadena,"on all")!=0)
71 {
72 digitalWrite(green,HIGH);
73 digitalWrite(yellow,HIGH);
75 }
76 //ALL OFF
77 if(strstr(cadena,"off all")!=0)
78 {
79 digitalWrite(green,LOW);
80 digitalWrite(yellow,LOW);
81 digitalWrite(red,LOW);
82 }
83
84 BT.write("\r"); //Enviamos un retorno de carro de la app. La app ya crea una línea nueva
86 }
87 }
88 }
89
90 //Limpia el array
91 void clean()
92 {
94 {
95 cadena[cl]=0;
96 }
97 i=0;
98 }
El código es bastante simple. Primero creamos un array de 256 posiciones tipo char
llamado cadena para almacenar los caracteres que recibiremos de la app. Cuando haya
datos disponibles los vamos guardando uno por uno en forma de carácter en la
variable dato. Después ponemos estos caracteres por orden en el array cadena.
Cuando reciba un carácter de fin de línea (\n), se compara el texto almacenado en el
Resultados a entregar:
1.- Implementa basado en el programa visto un control que encienda y apage motores
de C.D. de 9 v o 12 v. en lugar paralelo con los LEDs.
2.- Reporta el diagrama de conexiones, programa, y fotografías de tu aplicación.
3.- Investiga cómo desarrollar tus propias aplicaciones basadas en S.O. Android tales
como APPInventor.
Referencias en videotutoriales:
Bluetooth+Arduino
https://www.youtube.com/watch?v=idLocn4Hoho&feature=youtu.be