Upload
cristhian-garcia-villarroel
View
195
Download
7
Embed Size (px)
Citation preview
v1.3
DISEÑO DE SISTEMAS DIGITALES I
PROBLEMAS DE ARDUINO
SEMESTRE 2 - 2013
Luis Roberto Agreda Corrales [email protected]
2
1.- Parpadeo de un LED en el pin 10:
Sin variables:
void setup()
{
pinMode(10,OUTPUT); // Se configura el pin 10 como salida
}
void loop()
{
digitalWrite(10,HIGH); // Se envía un nivel lógico “1” (5V), al pin 10
delay(300); // Retardo de 300 ms
digitalWrite(10,LOW); // Se envía un nivel lógico “0” (0V), al pin 10
delay(1500); // Retardo de 1500 ms
}
Nota.- En el primer diagrama digitalWrite(10,HIGH) enciende al LED y en el segundo diagrama
apaga al LED.
Con variables:
int led = 10;
int retardo1 = 300;
int retardo2 = 1500;
void setup()
{
pinMode(led,OUTPUT);
}
void loop()
{
digitalWrite(led,HIGH);
delay(retardo1);
digitalWrite(led,LOW);
delay(retardo2);
}
3 2.- Parpadeo de un LED en el pin 10, usando el monitor serial:
2a) Se envían datos (cadenas de caracteres) a la PC
int led = 10; El diagrama en Proteus:
int retardo1 = 300;
int retardo2 = 1500;
void setup()
{
pinMode(led,OUTPUT);
Serial.begin(9600);
}
void loop()
{
digitalWrite(led,HIGH);
Serial.println("ON");
delay(retardo1);
digitalWrite(led,LOW);
Serial.println("OFF");
delay(retardo2);
}
Nota.- En el IDE de Arduino, la ventana del monitor serie, se inicia desde el menú
HERRAMIENTAS – MONITOR SERIE.
En Proteus, para simular la PC con conexión serial, se usa el objeto VIRTUAL TERMINAL.
4
2b) Se envían datos (valores) a la PC
int led = 10; El diagrama en Proteus:
int retardo = 1000;
int estado = 1;
void setup()
{
pinMode(led,OUTPUT);
Serial.begin(9600);
}
void loop()
{
Serial.print(estado);
digitalWrite(led,estado);
delay(retardo);
estado=!estado;
}
5
2c) Se reciben datos (caracteres) de la PC
int led = 10; El diagrama en Proteus:
char caracter;
void setup()
{
pinMode(led,OUTPUT);
Serial.begin(9600);
}
void loop()
{
if (Serial.available()>0)
{
caracter = toupper(Serial.read());
Serial.println(caracter); // Eco
if(caracter=='E')
{
digitalWrite(led,HIGH);
Serial.println("Encendido");
}
if (caracter=='A')
{
digitalWrite(led,LOW);
Serial.println("Apagado");
}
}
}
6 3.- Se enciende el LED del pin 10 con pulsador del pin 6 y se apaga con pulsador del pin 7:
int Sw6 = 6;
int Sw7 = 7;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT); // pin 6 como entrada
digitalWrite(Sw6,HIGH); // Activa resistor interno 20kΩ
pinMode(Sw7,INPUT); // pin 7 como entrada
digitalWrite(Sw7,HIGH); // Activa resistor interno 20kΩ
pinMode(Led,OUTPUT); // pin 10 como salida
digitalWrite(Led,LOW); // valor inicial del pin 10
}
void loop()
{
if(digitalRead(Sw6)==0)
digitalWrite(Led,HIGH);
if(digitalRead(Sw7)==0)
digitalWrite(Led,LOW);
}
7 TAREA.- Modificar el anterior programa, de tal manera que mientras se presione
simultáneamente los pulsadores conectados a los pines 6 y 7 de la placa Arduino UNO,
parpadee el LED cada 100 ms.
SOLUCIÓN.-
int Sw6 = 6;
int Sw7 = 7;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT_PULLUP); // pin 6 como entrada y se activa resistor interno 20kΩ
pinMode(Sw7,INPUT_PULLUP); // pin 7 como entrada y se activa resistor interno 20kΩ
pinMode(Led,OUTPUT); // pin 10 como salida
digitalWrite(Led,LOW); // valor inicial del pin 10
}
void loop()
{
if(digitalRead(Sw6)==0 && digitalRead(Sw7)==1)
digitalWrite(Led,HIGH);
if(digitalRead(Sw7)==0 && digitalRead(Sw6)==1)
digitalWrite(Led,LOW);
if(digitalRead(Sw6)==0 && digitalRead(Sw7)==0)
{
digitalWrite(Led,HIGH);
delay(100);
digitalWrite(Led,LOW);
delay(100);
}
}
8 4.- Se enciende y apaga el LED del pin 10 con el pulsador en pin 6:
4a) Se conmuta al pulsar y se usa la función delay()
int Sw6 = 6;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT_PULLUP); // pin 6 entrada y pullup ON
pinMode(Led,OUTPUT); // pin 10 salida
digitalWrite(Led,LOW); // valor inicial del Led: Apagado
}
void loop()
{
if(digitalRead(Sw6)==0)
{
delay(20);
if(digitalRead(Led)==0)
digitalWrite(Led,HIGH);
else
digitalWrite(Led,LOW);
while(digitalRead(Sw6)==0) {}
delay(20);
}
}
9
4b) Se conmuta al soltar y se usa la función delay()
int Sw6 = 6;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT_PULLUP); // pin 6 entrada y pullup ON
pinMode(Led,OUTPUT); // pin 10 salida
digitalWrite(Led,LOW); // valor inicial del Led: Apagado
}
void loop()
{
if(digitalRead(Sw6)==0)
{
delay(20);
while(digitalRead(Sw6)==0) {}
if(digitalRead(Led)==0)
digitalWrite(Led,HIGH);
else
digitalWrite(Led,LOW);
delay(20);
}
}
4c) Se conmuta al presionar, se usa la función delay() y el operador booleano !
int Sw6 = 6;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT_PULLUP); // pin 6 entrada y pullup ON
pinMode(Led,OUTPUT); // pin 10 salida
digitalWrite(Led,LOW); // valor inicial del Led: Apagado
}
void loop()
{
if(!digitalRead(Sw6))
{
delay(20);
digitalWrite(Led,!digitalRead(Led));
while(digitalRead(Sw6)==0) {}
delay(20);
}
}
10 4d) Se conmuta al soltar, se usa la función delay() y el operador booleano !
int Sw6 = 6;
int Led = 10;
void setup()
{
pinMode(Sw6,INPUT_PULLUP); // pin 6 entrada y pullup ON
pinMode(Led,OUTPUT); // pin 10 salida
digitalWrite(Led,LOW); // valor inicial del Led: Apagado
}
void loop()
{
if(!digitalRead(Sw6))
{
delay(20);
while(!digitalRead(Sw6)) {}
digitalWrite(Led,!digitalRead(Led));
delay(20);
}
}
5.- Se incrementa un contador con el pulsador en pin 6, tomando una muestra cada ms:
5a) Se incrementa al presionar el pulsador
11
int sw6 = 6;
int Led = 10;
int contador = 0;
void setup()
{
Serial.begin(9600);
pinMode(sw6,INPUT_PULLUP); // Pin 6 como entrada y pullup ON
}
void loop()
{
int db_cnt; // contador rebote
for (db_cnt = 0; db_cnt <= 10; db_cnt++) // se espera a que sw6=0 (pulsado)
{
delay(1); // retardo de 1 ms
if (digitalRead(sw6)== 1) // si hay rebote (sw6=1)
db_cnt = 0; // restart count // contador rebote a cero
} // hasta que sw6 esté en 0, durante 10 lecturas sucesivas
contador++; // se incrementa contador
Serial.println(contador); // se muestra en pantalla
for (db_cnt = 0; db_cnt <= 10; db_cnt++) // se espera a que sw6=1 (soltado)
{
delay(1); // retardo de 1 ms
if (digitalRead(sw6)== 0) // si hay rebote (sw6=0)
db_cnt = 0; // contador rebote a cero
} // hasta que sw6 esté en 1, durante 10 lecturas sucesivas
}
5b) Se incrementa al soltar el pulsador
int sw6 = 6;
int Led = 10;
int contador = 0;
void setup()
{
Serial.begin(9600);
pinMode(sw6,INPUT); // Pin 6 como entrada
digitalWrite(sw6,HIGH); // Pullup del pin 6 ON
}
void loop()
{
int db_cnt; // contador rebote
for (db_cnt = 0; db_cnt <= 10; db_cnt++) // se espera a que sw6=0 (pulsado)
{
delay(1); // retardo de 1 ms
if (digitalRead(sw6)== 1) // si hay rebote (sw6=1)
db_cnt = 0; // restart count // contador rebote a cero
} // hasta que sw6 esté en 0, durante 10 lecturas sucesivas
for (db_cnt = 0; db_cnt <= 10; db_cnt++) // se espera a que sw6=1 (soltado)
{
delay(1); // retardo de 1 ms
if (digitalRead(sw6)== 0) // si hay rebote (sw6=0)
12 db_cnt = 0; // contador rebote a cero
} // hasta que sw6 esté en 1, durante 10 lecturas sucesivas
contador++; // se incrementa contador
Serial.println(contador); // se muestra en pantalla
}
MÓDULO BLUETOOTH
Instalar el driver del conversor USB/USART (disponible como archivo ejecutable en
http://www.ftdichip.com/Drivers/VCP.htm); luego, conectar el conversor a un puerto USB de la
PC. Verificar en el Administrador de Dispositivos, en Puertos (COM y LPT), el número del
puerto virtual COM del conversor, por ejemplo:
El driver del conversor USB/USART, también se lo puede descargar de
https://www.sugarsync.com/pf/D8070664_871_712817605.
A continuación, conectar el módulo bluetooth HC-06 al conversor USB/USART y sin emparejarlo
con el módulo bluetooth de la PC, proceder a verificar los comandos AT, usando el software
de comunicación serial Tera Term (descargar en sus versiones para instalar y portable de
http://ttssh2.sourceforge.jp/ ó https://www.sugarsync.com/pf/D8070664_871_712849502).
TERA TERM (SOFTWARE DE COMUNICACIÓN SERIAL)
Configurar Tera Term como se muestra en las siguientes figuras:
13
CONEXIÓN COMPUTADORA – CONVERSOR USB/USART Y MÓDULO BLUETOOTH
COMANDOS AT
Los parámetros por defecto del módulo bluetooth HC-06 son:
Baud rate:9600N81, ID: linvor, Password:1234
AT+BAUD4
AT+NAMElinvor
AT+PIN1234
1.- Prueba de comunicación:
Enviar: AT Respuesta: OK
2.- Selección de velocidad de transferencia de datos:
Enviar: AT+BAUD4 Respuesta: OK9600
1---------1200
2---------2400
3---------4800
4---------9600 (Por Defecto)
5---------19200
6---------38400
7---------57600
8---------115200
9---------230400
A---------460800
B---------921600
C---------1382400
3.- Cambiar el nombre del módulo bluetooth:
Enviar: AT+NAMEnombre Respuesta: OKnombre
nombre está limitado a 20 caracteres
4.- Cambiar la contraseña de emparejamiento del módulo bluetooth:
Enviar: AT+PINxxxx Respuesta: OKsetpin
xxxx, es un número de 4 dígitos. El valor por defecto es 1234
14
6.- Comunicación inalámbrica entre la PC y Arduino UNO + módulo Bluetooth:
Nota.- No existe el modelo del módulo bluetooth en Proteus v7.1
// Conexión PC y ARDUINO+BLUETOOTH
int Led = 10;
int i=0;
char caracter;
void setup()
{
pinMode(Led,OUTPUT);
Serial.begin(9600);
}
void loop()
{
// Mientras el puerto serie del módulo bluetooth está disponible
while (Serial.available())
{
// Guardamos en la variable dato el carácter (mayúscula), leído por el modulo bluetooth
caracter= toupper(Serial.read());
Serial.println(caracter); // Eco
// Comprobamos el carácter
switch(caracter)
{
// Si recibimos una 'E' encendemos el led 10 y enviamos para mostrar
// en Teraterm “Led encendido”
15 case 'E':
{
digitalWrite(Led,HIGH);
Serial.println("Led encendido");
break;
}
// Si recibimos una 'A' apagamos el led 10 y enviamos para mostrar
// en Teraterm “Led apagado”
case 'A':
{
digitalWrite(Led,LOW);
Serial.println("Led apagado");
break;
}
// Si recibimos una 'I' encendemos y apagamos el led siete veces
// y mostramos en Teraterm “Led intermitente”
case 'I':
{
for (i=0; i <= 7; i++)
{
digitalWrite(Led,HIGH);
delay(300);
digitalWrite(Led,LOW);
delay(300);
}
Serial.println("Led intermitente");
break;
}
}
}
}
Nota.- Con la función Serial.println(caracter); se produce el Eco en la ventana del Tera
Term.
16
7.- Contador ascendente y descendente con dos pulsadores. Pantalla LCD 16x2:
Librería: http://arduino.cc/es/Reference/LiquidCrystal
////////////////////////////////////////////////////////////////////////////////////////////
/// En este ejemplo leemos dos pulsadores para aumentar y disminuir una variable.
/// En todo momento, visualizaremos en el LCD, el estado de los pulsadores, como el valor
/// de la variable.
////////////////////////////////////////////////////////////////////////////////////////////
int contador=0; // Variable que sw1 aumenta y sw2 disminuye
int pin_sw1=6;
long int tiempo_inicial_1=0; // guarda el contenido de millis() en la lectura de sw1
boolean Lectura_pin_sw1_realizada=false; // Variable para saber si ya se ha leído sw1
int pin_sw2=7;
long int tiempo_inicial_2=0; // guarda el contenido de millis() en la lectura de sw2
boolean Lectura_pin_sw2_realizada=false; // Variable para saber si ya se ha leído sw2
int estado_sw1=1; // almacena el estado del pulsador 1. Pulsado-->0 Sin pulsar-->1.
int estado_sw2=1; // almacena el estado del pulsador 2. Pulsado-->0 Sin pulsar-->1.
#include <LiquidCrystal.h> //incluimos la librería LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);//inicializamos los pines
void setup()
{
pinMode(pin_sw1,INPUT_PULLUP); // configurado como entrada y Pullup ON
pinMode(pin_sw2, INPUT_PULLUP);// configurado como entrada y Pullup ON
lcd.begin(16,2);
lcd.clear(); // Función que borra todo el el LCD.
lcd.setCursor(1,0); // cursor en la columna 1 - fila 0.
lcd.print("SW1=");
17 lcd.setCursor(9,0);; // cursor en la columna 9 - fila 0.
lcd.print("SW2=");
lcd.setCursor(1,1); // cursor en la columna 1 - fila 1.
lcd.print("Variable=");
}
void loop()
{
///Leemos el pulsador 1
if(digitalRead(pin_sw1)==0 && Lectura_pin_sw1_realizada==false)
{
Lectura_pin_sw1_realizada=true;
tiempo_inicial_1=millis();
estado_sw1=0;
}
if(millis()-tiempo_inicial_1 > 20 && Lectura_pin_sw1_realizada==true)
{
tiempo_inicial_1=0;
Lectura_pin_sw1_realizada=false;
if(digitalRead(pin_sw1)==HIGH)
{
contador++;
estado_sw1=1;
}
}
///Leemos el pulsador 2
if(digitalRead(pin_sw2)==0 && Lectura_pin_sw2_realizada==false)
{
Lectura_pin_sw2_realizada=true;
tiempo_inicial_2=millis();
estado_sw2=0;
}
if(millis()-tiempo_inicial_2 > 20 && Lectura_pin_sw2_realizada==true)
{
tiempo_inicial_2=0;
Lectura_pin_sw2_realizada=false;
if(digitalRead(pin_sw2)==HIGH)
{
contador--;
estado_sw2=1;
}
}
Actualizar_LCD(); // Función que muestra información por el LCD.
}
void Actualizar_LCD()
{
lcd.setCursor(5,0); // cursor en la posición columna 5 - fila 0.
lcd.print(estado_sw1); // se muestra el valor de una variable entera.
lcd.setCursor(13,0);; // cursor en la posición columna 13 - fila 0.
lcd.print(estado_sw2); // se muestra el valor de una variable entera.
lcd.setCursor(10,1); // cursor en la posición columna 10 - fila 1.
lcd.print(contador); // se muestra la variable contador.
lcd.print(" "); // espacios en blanco.
}
18
8.- Menú con función y modo. Se usa librería Bounce, para rebote de contactos:
8a) Se usa el modelo de Arduino para Proteus que se obtuvo de
http://microcontrolandos.blogspot.com/2012/12/arduino-componentes-para-o-proteus.html
19
8b) Simulación con el modelo SIMULINO UNO para Proteus:
#include <Bounce.h> // incluimos la librería para rebotes
#include <LiquidCrystal.h> // incluimos la librería LCD
int led = 10;
int sw6_funcion = 6;
int sw7_modo = 7;
boolean ledValue=LOW;
Bounce entrada6 = Bounce(sw6_funcion,20); // tiempo de 20 ms
Bounce entrada7 = Bounce(sw7_modo,20); // tiempo de 20 ms
int funcion = 0; // función
int modo = 0; // modo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //inicializamos los pines
void setup()
{
pinMode(sw6_funcion,INPUT_PULLUP); // configuramos como entrada el pin del pulsador 6.
pinMode(sw7_modo,INPUT_PULLUP); // configuramos como entrada el pin del pulsador 7.
pinMode(led,OUTPUT);
lcd.begin(16,2);
lcd.clear(); // Función que borra todo el el LCD.
}
20
void loop()
{
///Leemos el pulsador 6
if(entrada6.update())
{
if(entrada6.read() == LOW)
{
funcion++;
if(funcion > 3)
funcion = 0;
}
}
///Leemos el pulsador 7
if(entrada7.update())
{
if(entrada7.read() == LOW)
{
modo++;
{
if(modo > 1)
{ modo = 0; }
}
}
}
if (funcion == 0)
{
modo = 0;
lcd.setCursor(1,0);
lcd.print(" MENU ");
lcd.setCursor(1,1);
lcd.print(" ");
}
if (funcion == 1)
{
switch(modo)
{
case 0: lcd.setCursor(1,0);
lcd.print(" LED ON OFF ");
lcd.setCursor(1,1);
lcd.print(" ");
break;
case 1: fun_1();
funcion = 0;
break;
}
}
if (funcion == 2)
{
switch(modo)
{
case 0: lcd.setCursor(1,0);
lcd.print(" FUNCION_2 ");
lcd.setCursor(1,1);
lcd.print(" ");
break;
case 1: fun_2();
21 funcion = 0;
break;
}
}
if (funcion == 3)
{
switch(modo)
{
case 0: lcd.setCursor(1,0);
lcd.print(" FUNCION_3 ");
lcd.setCursor(1,1);
lcd.print(" ");
break;
case 1: fun_3();
funcion = 0;
break;
}
}
}
void fun_1()
{
int i = 0;
for(i=0; i<=4; i++)
{
lcd.setCursor(8,1);
lcd.print(i);
digitalWrite(led,HIGH);
delay(250);
digitalWrite(led,LOW);
delay(250);
}
}
void fun_2()
{
lcd.setCursor(1,0);
lcd.print(" CODIGO fun_2() ");
delay(2000);
}
void fun_3()
{
lcd.setCursor(1,0);
lcd.print(" CODIGO fun_3() ");
delay(2000);
}