View
238
Download
5
Category
Preview:
Citation preview
Adaptado por Miguel Ángel Asensio Hernández, profesor de electrónica de comunicaciones
Arduino
programming
notebook
Basado en un manual de
Brian W. Evans
MANUAL DE PROGRAMACIÓN PARA ARDUINO
Miguel Ángel Asensio Hernández 2
Miguel Ángel Asensio Hernández 3
Manual de consulta rápida sobre los comandos básicos y la sintaxis del
lenguaje de programación de Arduino.
IDE de Arduino.
Miguel Ángel Asensio Hernández 4
Miguel Ángel Asensio Hernández 5
Estructura de un programa
La estructura básica del lenguaje de programación de Arduino es bastante simple y se
compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques
que contienen declaraciones e instrucciones.
void setup() //Configuración
{
instrucciones;
}
void loop() //Bucle de programa
{
instrucciones;
}
setup()
La función de configuración, setup(), debe contener la declaración de variables. Es la primera
función a ejecutar en el programa y se ejecuta sólo una vez. Se utiliza para configurar pinMode
(E/S) e inicializar las comunicaciones serie.
loop()
La función bucle, loop(), contiene el código que se ejecuta continuamente de manera cíclica:
leyendo entradas, activando salidas, ejecutando funciones, etc.
Miguel Ángel Asensio Hernández 6
setup()
Se utiliza para inicializar los modos de trabajo de los pines, o el puerto serie. Debe ser incluido
en un programa aunque no haya declaración que ejecutar. Así mismo se puede utilizar para
establecer el estado inicial de las salidas de la placa.
void setup()
{
pinMode(pin, OUTPUT); //configura el 'pin' como salida
digitalWrite(pin, HIGH); //pone el ‘pin’ en estado HIGH
}
loop()
Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se
ejecuta de forma cíclica, lo que posibilita que el programa este respondiendo continuamente
ante los eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin,HIGH); //pone en uno (on, 5v)el pin
delay(1000); //espera un segundo (1000 ms)
digitalWrite(pin,LOW); //pone en cero (off, 0v.)el pin
delay(1000);
}
Miguel Ángel Asensio Hernández 7
Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que
son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha
hablado.
Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el
tamaño de un programa.
tipo nombreFunción(parámetros)
{
instrucciones;
}
Las funciones se declaran asociadas a un tipo de valor.
Este valor será el que devolverá la función, por ejemplo 'int' se utilizara cuando la función
devuelva un dato numérico de tipo entero.
Si la función no devuelve ningún valor entonces se colocara delante la palabra “void”, que
significa “función vacía”.
Después de declarar el tipo de dato que devuelve la función se debe escribir el nombre de la
función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben pasar a
la función para que se ejecute.
Para hacer uso de la función anterior, tan solo habrá que llamarla desde cualquier parte del
programa. Esta llamada a la función se realiza de la siguiente manera:
void loop()
{
int i =2;
Miguel Ángel Asensio Hernández 8
int j =3;
int k;
k = multiplicar (i,j); //llama a la función multiplicar pasándole los
//parámetros “i” y “j”
}
La siguiente función de ejemplo, delayVal() muestra cómo se asigna un valor de retraso en un
programa que lee una variable desde un potenciómetro conectado a una entrada analógica de
Arduino.
int delayVal()
{
int v; //crea una variable temporal 'v'
v= analogRead(pot); //lee el valor del potenciómetro
v /= 4; //convierte 0-1023 a 0-255
return v; //devuelve el valor final
}
Al principio se declara como una variable local, ´v´ recoge el valor leído del potenciómetro que
estará comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un margen
comprendido entre 0 y 255, finalmente se devuelve el valor ´v´ y se retornaría al programa
principal.
Llaves {}
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan
para los bloques de programación setup(), loop(), if.., etc.
type funcion()
{
instrucciones;
}
Una llave de apertura “{“siempre debe ir seguida de una llave de cierre “}”, si no es así el
compilador dará errores.
El entorno de programación de Arduino incluye una herramienta de gran utilidad para
comprobar el total de llaves. Solo tienes que hacer click en el punto de inserción de una llave
abierta e inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).
Miguel Ángel Asensio Hernández 9
Punto y coma (;)
El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación de
Arduino. También se utiliza para separar elementos en una instrucción de tipo “bucle for”.
int x = 13; //declara la variable 'x' como tipo
//entero de valor 13
Bloque de comentarios /*… */
Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el
programa que se utilizan para las descripciones del código o comentarios que ayudan a
comprender el programa.
Comienzan con / * y terminan con * / y pueden abarcar varias líneas.
/* esto es un bloque de comentario y como podemos comprobar es posible
colocar un comentario en varias líneas */
Debido a que los comentarios son ignorados por el compilador estos no ocupan espacio en la
memoria de Arduino.
Línea de comentarios //
Una línea de comentario empieza con / / y terminan con la siguiente línea de código. Al igual
que los comentarios de bloque, los de línea también son ignorados por el programa y no
ocupan espacio en la memoria.
//esto es un comentario
Miguel Ángel Asensio Hernández 10
VARIABLES
Una variable es una manera de nombrar y almacenar un valor numérico para su uso posterior
por el programa.
Como su nombre indica, las variables son números que se pueden variar continuamente en
contra de lo que ocurre con las constantes cuyo valor nunca cambia.
Una variable debe ser declarada y, opcionalmente, asignarle un valor.
El siguiente código de ejemplo declara una variable llamada miVariable y luego le asigna el
valor obtenido en la entrada analógica del PIN 2:
int miVariable = 0; //declara una variable y le
//asigna el valor 0
miVariable = analogRead(2); //la variable recoge el
// valor analógico del PIN2
Como ejemplo ilustrativo veamos tres operaciones útiles con variables:
el siguiente código prueba si la variable “entradaVariable” es inferior a 100, si es cierto se
asigna el valor 100 a “entradaVariable” y, a continuacion, establece un retardo (delay)
utilizando como valor “entradaVariable” que ahora será como mínimo de valor 100:
if (entradaVariable < 100) //pregunta si la variable
{ //es menor de 100
entradaVariable = 100; //si es cierto asigna
} //el valor 100
delay(entradaVariable); //usa el valor como retardo
Nota: Las variables deben tomar nombres descriptivos, para hacer el código más legible.
Miguel Ángel Asensio Hernández 11
Declaración de variables
Todas las variables tienen que declararse antes de que puedan ser utilizadas.
Para declarar una variable se comienza por definir su tipo como int (entero), long (largo),
float (coma flotante), etc, asignándoles siempre un nombre, y opcionalmente, un valor
inicial.
Esto solo debe hacerse una vez en el programa, pero el valor se puede cambiar en cualquier
momento usando aritmética y asignaciones diversas.
Ámbito de una variable
Una variable puede ser declarada al inicio del programa antes de la parte de configuración
setup(), lo que le confiere la característica de variable global, o puede ser declarada a nivel
local dentro de las funciones, y, a veces, dentro de un bucle del tipo if.., for.., etc.
Miguel Ángel Asensio Hernández 12
Ejemplo de diferentes tipos de variables:
int value; //'value' es visible para cualquier función
void setup()
{
//no es necesario configurar nada en este ejemplo
}
void loop()
{ //'i' solo es visible dentro del bucle for
for(int i=0; i<20;)
{
i++
}
float f; // 'f' es visible solo dentro de loop()
}
Tipos de datos
byte miVariable = 180; //declara ‘miVariable' como
//de tipo byte
int miVariable = 1500; //declara ‘miVariable' como
//una variable de tipo entero
Miguel Ángel Asensio Hernández 13
long miVariable = 90000; //declara ‘miVariable' como
//de tipo long
float unaVariable = 3.14; //declara 'unaVariable' como
// de tipo flotante
Cuadro resumen de algunos Tipos de Variables
Miguel Ángel Asensio Hernández 14
Un array es un conjunto de valores del mismo tipo a los que se accede con un número índice.
Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del
índice.
El primer valor de la matriz es el que esta indicado con el índice 0, es decir el primer valor del
conjunto es el de la posición 0. Un array tiene que ser declarado y opcionalmente asignados
valores a cada posición antes de ser utilizado.
Existen varias formas de crear un array:
int miarray_1[5]//array de 6 posiciones
int miarray_2[]={2,8,9,3,5,11} //array de 6 posiciones
0,1,2,3,4, 5 //inicializadas
int miarray_3[5]={7,5,3,1,0,9} //mezcla de las
//anteriores
Para leer de un array basta con escribir el nombre y la posición del dato a leer:
int miArray[5]; //declara un array de enteros de 6
//posiciones
miArray[3] = 10; //asigna el valor 10 a la posición 4
x = miArray[3]; //x ahora es igual a 10 que está en
//la posición 3 del array
Nota: es importante tener en cuenta el índice del array, ya que si se intenta acceder a una
posición más allá del índice de una matriz, se está accediendo a otras direcciones de memoria,
posiblemente en uso, y los valores recuperados serán incorrectos.
Miguel Ángel Asensio Hernández 15
El tipo de dato char almacena un carácter, para lo cual emplea un byte de memoria. Son
inicializados indicando su valor entre comillas simples (‘A’).
Este tipo de datos son almacenados como números, empleando la codificación ASCII (esto
significa que son susceptibles de realizar con ellos operaciones aritméticas).
El tipo de dato char es almacenado como un entero con signo, que varía desde -128 a +127.
char caracter = ‘A’;
char caracter_2= 65; //ambos son equivalentes
El siguiente ejemplo usa una matriz para el parpadeo de un LED:
Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la
posición de índice 0 en la serie que hemos escrito dentro del array parpadeo[ ], en este caso
180, que se envía a la salida analógica tipo PWM configurada en el PIN10, se hace una pausa
de 200ms y a continuación se pasa al siguiente valor que asigna el índice “i”.
int ledPin = 10; //LED en el PIN 10
byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60};
//array de 8 valores
void setup()
{
pinMode(ledPin, OUTPUT); //configura la salida
}
void loop()
{
for(int i=0; i<7; i++)
{
analogWrite(ledPin, parpadeo[i]);
delay(200); //espera 200ms
}
}
Miguel Ángel Asensio Hernández 16
Operadores aritméticos
Los operadores aritméticos que se incluyen en el entorno de programación son: suma, resta,
multiplicación y división. Estos devuelven la suma, diferencia, producto, o cociente
(respectivamente) de dos operandos.
y = y + 3; x = x - 7; i = j * 6; r = r / 5;
La operación se efectúa teniendo en cuenta el tipo de datos que hemos definido para los
operandos (int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”,
9 / 4 devuelve de resultado 2 en lugar de 2,25.
Nota: Utiliza el operador (int) para convertir un tipo de variable a otro sobre la marcha. Por
ejemplo, i = (int) 3,6 establecerá i = 3.
Asignaciones aritméticas
x ++ //igual que x = x +1, o incremento de x en +1
x -- //igual que x = x - 1, o decremento de x en -1
x += y //igual que x = x + y, o incremento de x en +y
x -= y //igual que x = x - y, o decremento de x en -y
x *= y //igual que x = x * y, o multiplica x por y
x /= y //igual que x = x / y, o divide x por y
Operadores de comparación
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
Miguel Ángel Asensio Hernández 17
Operadores lógicos (realizan comparaciones booleanas).
Lógica AND (&&):
if (x > 0 && x < 5) //cierto sólo si las dos
//expresiones son ciertas
Lógica OR (||):
if (x > 0 || y > 0) //cierto si una cualquiera de
//las expresiones es cierta
Lógica NOT (!):
if (!x > 0) //cierto solo si la expresión es falsa
CONSTANTES
El lenguaje de programación de Arduino permite definir constantes, se utilizan para hacer los
programas más fáciles de leer y se clasifican en grupos.
Cierto/falso (TRUE/FALSE)
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos
se refieren al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se
asocia con 1, pero TRUE también puede ser cualquier otra cosa excepto cero.
if (b == TRUE);
{
ejecutar las instrucciones;
}
Miguel Ángel Asensio Hernández 18
HIGH/LOW
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la
escritura digital de las patillas.
digitalWrite(13, HIGH); //activa la salida 13 con un
//nivel alto (5v.)
IMPUT/OUTPUT
Estas constantes son utilizadas para definir el modo de funcionamiento de los pines, mediante
la instrucción pinMode, de tal manera que un determinado pin puede ser una entrada INPUT o
una salida OUTPUT.
pinMode(13, OUTPUT); //designamos que el PIN 13 es
//una salida
ESTRUCTURAS DE CONTROL DE FLUJO
Condicionales.
if (Si condicional)
La sentencia if, se complementa con los operadores de comparación, comprueba si cierta
condición se cumple o no y actúa en consecuencia. El formato para if es el siguiente:
if (miVariable > 50) //si se cumple esta condición
{
ejecutaInstrucciones;
}
If…else (Si…, sino…)
La estructura if, se complementa con la palabra else, que permite realizar una comprobación
que da respuesta a la siguente idea: “si esto no se cumple haz esto otro”.
if (Variable < 100) //si se cumple esta condición
{
ejecutaInstruccion A; //ejecuta esto
}
else
{
ejecutaInstruccion B; //ejecuta esto otro
}
Miguel Ángel Asensio Hernández 19
Nota: es posible realizar comprobaciones anidadas o adicionales.
Bucles.
for
Los bucles for son empleados para repetir un número determinado de veces un código o
bloque de programa. Un bucle for tiene tres partes o argumentos en su inicialización:
for (inicialización; condición; incremento)
{
Instrucciones;
}
1. La inicialización sólo se ejecuta
una vez.
2. Cada vez que se va a repetir el
bucle se comprueba la condición.
3. Cada vez que se ejecuta el código
encerrado entre llaves, se
incrementa la variable de la
condición.
Miguel Ángel Asensio Hernández 20
while
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión
colocada entre paréntesis.
int variable = 0;
while(variable < 200)
{
//ejecutar algo 200 veces;
var++;
}
do… while
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la
condición se prueba al final del bucle, por lo que el bucle siempre se ejecutara al menos una
vez.
do
{
Instrucciones;
} while (condición);
Miguel Ángel Asensio Hernández 21
Miguel Ángel Asensio Hernández 22
Funciones específicas de Arduino
E/S digitales.
pinMode(pin, modo)
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. Los pines
configurados como entrada quedan, bajo el punto de vista eléctrico, como entradas en estado
de alta impedancia.
Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede acceder
mediante software.
pinMode(pin, INPUT); //configura el ‘pin’ como entrada
digitalWrite(pin, HIGH); //activa las resistencias
//internas
digitalWrite(pin, valor)
La función digitalWrite() escribe un valor (HIGH (alto) o LOW (bajo)) en un pin digital. Si el pin
ha sido configurado como OUTPUT su valor será de 5V para HIGH y de 0V (GND) para LOW.
Si el pin es configurado como INPUT, y se activa su valor a HIGH habilitará la resistencia interna
pull-up de 20K, mientras que si se activa su valor a LOW inhabilitará dicha resistencia.
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe
en el ´pin´ de salida, LED:
int led = 13; // asigna a led el valor 13
int boton = 7; // asigna a botón el valor 7
int valor = 0; // define valor y le asigna el valor 0
void setup()
{
pinMode(led, OUTPUT); //configura el led(pin13) como salida
pinMode(boton, INPUT); //configura botón(pin7) como entrada
}
Miguel Ángel Asensio Hernández 23
void loop()
{
valor = digitalRead(boton); // lee el estado de la
// entrada botón
digitalWrite(led, valor); // envía a la salida led el
// valor leído
}
digitalRead(pin)
Lee el valor de un pin (definido como 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.
E/S analógicas.
analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica con una resolución de 10
bits. Esta instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila
de 0 a 1023.
valor = analogRead(pin); // asigna a valor lo que lee
// en la entrada pin
Nota: Los pines analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declarados
como INPUT u OUPUT ya que son siempre INPUT´s.
Miguel Ángel Asensio Hernández 24
analogWrite(pin, value)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de
modulación por ancho de pulso (PWM) a uno de los pines de Arduino marcados como “pin
PWM”.
El valor que se puede enviar a estos pines de salida analógica puede darse en forma de
variable o constante, pero siempre con un margen de 0-255.
analogWrite(pin, valor); //escribe 'valor' en el 'pin'
//definido como analógico
Debido a que esta es una función de hardware, en el pin de salida analógica (PWN) se generará
una onda constante después de ejecutada la instrucción analogWrite hasta que se llegue a
ejecutar otra instrucción analogWrite (o una llamada a digitalRead o digitalWrite en el mismo
pin).
La frecuencia de la señal para los pines 3, 9, 10, 11 es de aproximadamente 490Hz, y para los
pines 5 y 6 es de 977Hz. Es posible no obstante modificar la frecuencia PWM.
analogWrite(pin, valor);
pin: entero que representa el pin sobre el que se realiza el PWM.
valor: ciclo de trabajo (entre 0 y 255)
Miguel Ángel Asensio Hernández 25
Funciones de tiempo
delay(ms)
Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia
instrucción. De tal manera que 1000 equivale a 1seg.
delay(1000); //espera 1 segundo
millis()
Devuelve el número de milisegundos transcurrido desde el inicio del programa en Arduino
hasta el momento actual. Dado que Arduino emplea un palabra doble (32bits) para su
almacenamiento, se desbordará a los 49,71 días.
Es posible implementar temporizadores de forma sencilla con esta función.
Serial.print(“Tiempo: “);
time = millis(); //imprime el tiempo desde que
//se inició el programa
Serial.println(time);
Funciones de cálculo
min(x, y)
Calcula el mínimo de dos números para cualquier tipo de datos devolviendo el número más
pequeño.
valor = min(valor, 100); //asigna a valor el más
//pequeño de los dos números especificados.
Si 'valor' es menor que 100 valor recogerá su propio valor. Si valor es mayor que 100 valor
pasara a valer 100.
max(x, y)
Calcula el máximo de dos números para cualquier tipo de datos devolviendo el numero mayor
de los dos.
valor = max(valor, 100); //asigna a valor el mayor de
//los dos números 'valor' y 100.
De esta manera nos aseguramos de que valor será como mínimo100.
Miguel Ángel Asensio Hernández 26
map (value,fromLow,fromHigh,toLow,toHigh)
La función map() mapea un número desde un rango hasta otro. Esto significa que un valor
(value) con respecto al rango fromLow-fromHigh será remapeado al rango toLow-toHigh.
La función map() crea por tanto una recta de interpolación con números enteros de la forma:
/* Mapea un valor analógico de 10bits (1024) a un valor de 8bits (255) */
Miguel Ángel Asensio Hernández 27
Comunicación serie
La comunicación serie de Arduino se basa en el empleo de la librería Serial. Es importante
tener en cuenta que la comunicación serie en Arduino UNO se basa en el envío de datos a
través de su puerto serie, que es el mismo canal de comunicación empleado para la
comunicación USB. Por tanto, es muy importante no usar estos pines como E/S cuando se
quiere comunicar vía serial port.
En Arduino Leonardo este inconveniente ya no supone un problema, puesto que dispone de
puertos serie independientes.
Para el uso de la librería Serial es conveniente conocer las funciones fundamentales:
Serial.begin(rate)
Abre e inicializa el puerto serie y fija la velocidad en baudios para la transmisión de datos en
serie.
void setup()
{
Serial.begin(9600); // abre el Puerto serie
} // configurando la velocidad en 9600 bps
Serial.print() y Serial.println()
Serial.print() Imprime datos en el puerto serie en formato ASCII.
Serial.print(78); //Imprime 78
Serial.print(1.23456); //Imprime 1.23
Serial.print('N'); //Imprime N
Serial.print("Hola Mundo."); //Imprime Hola Mundo.
Miguel Ángel Asensio Hernández 28
Es posible especificar, mediante un segundo parámetro, el formato de escritura de los datos
por el monitor serie, mediante los valores BIN (binario, o base 2), OCT (octal, o base 8), DEC
(decimal, o base 10), HEX (o base 16).
Igualmente, para los números en coma flotante, pueden especificarse el número de posiciones
decimales a imprimir:
Serial.print(78, BIN) //Devuelve 1001110
Serial.print(78, OCT) //Devuelve 116
Serial.print(78, DEC) //Devuelve 78
Serial.print(78, HEX) //Devuelve 4E
Serial.println(1.23456, 0) //Devuelve 1
Serial.println(1.23456, 2) //Devuelve 1.23
Serial.println(1.23456, 4) //Devuelve 1.2346
La función Serial.println() funciona de igual forma que Serial.print() pero añade al final un
retorno automático de carro seguido de un salto de línea.
Serial.available()
Devuelve un entero con el número de bytes disponibles para leer desde el buffer serie, o 0 si
no hay ninguno. Si hay algún dato disponible, Serial.available() será mayor que 0. El buffer
serie puede almacenar como máximo 64 bytes.
int Serial.available() // Obtiene un número entero
Ejemplo:
void loop() {
if (Serial.available() > 0) // envía datos sólo si
{ // los recibe
Miguel Ángel Asensio Hernández 29
Serial.read()
La función Serial.read() lee o captura un byte (datos entrantes) vía puerto serie, tomándolos
del buffer de entrada. El método de lectura del buffer es FIFO (First In, First Out).
incomingByte = Serial.read(); //Lee un byte de entrada
En el siguiente ejemplo podemos ver varias funciones Serial:
void setup()
{
Serial.begin(9600); //abre el puerto serie
}
int incomingByte=0; //Definimos variable
void loop()
{
if (Serial.available() > 0) //envía datos solo si los recibe
{
incomingByte = Serial.read(); //Lee el byte de entrada
//y lo muestra por pantalla
Serial.print("Dato recibido: ");
Serial.println(incomingByte, DEC); //Imprime el dato recibido
//transformado a decimal
}
}
Miguel Ángel Asensio Hernández 30
Miguel Ángel Asensio Hernández 31
Miguel Ángel Asensio Hernández 32
Instalación y Entorno de programación
Página oficial de Arduino: http://www.arduino.cc
Descarga del IDE de Arduino
La descarga del IDE de Arduino se realiza desde la pestaña “Download” (Descargar), donde se
pueden encontrar diferentes versiones según el sistema operativo que usemos.
El paquete con el IDE contiene también los drivers de Arduino.
En mi caso descargaré el software de Arduino desde Windows installer.
Miguel Ángel Asensio Hernández 33
Una vez descargado el instalador, ejecutar haciendo doble clic:
Advertencia de Windows indicando que la versión instalada en el equipo será sustituida por la
nueva y que ello no afectará a los sketches y librerías creados anteriormente.
Miguel Ángel Asensio Hernández 34
C:\Program Files (x86)\Arduino
IDE DE ARDUINO. Entorno de trabajo.
Miguel Ángel Asensio Hernández 35
Miguel Ángel Asensio Hernández 36
Miguel Ángel Asensio Hernández 37
Miguel Ángel Asensio Hernández 38
Miguel Ángel Asensio Hernández 39
Miguel Ángel Asensio Hernández 40
Miguel Ángel Asensio Hernández 41
Miguel Ángel Asensio Hernández 42
17 Prácticas con ARDUINO
Miguel Ángel Asensio Hernández 43
INTRODUCCIÓN A LA PLACA ARDUINO.
“HOLA MUNDO” – Blink CURSO 2013/2014
Activar una salida digital.
Temporizar una señal de salida.
Primera toma de contacto con la sintaxis de un programa para Arduino.
UNIDAD DE TRABAJO - Nº 1 TEMPORALIZACIÓN:
Este es el ejemplo básico equivalente al “hola mundo” de cualquier lenguaje de programación.
/*
Hola Mundo Enciende un LED por un segundo y lo apaga
durante el mismo tiempo.
*/
// Declaración de variables
int ledPin=13; // LED conectado en el pin 13
// Función principal
void setup() // Configuración
{
pinMode(ledPin, OUTPUT);
//configura el pin 13 como salida
}
void loop() // Bucle de programa
{
digitalWrite(ledPin, HIGH); // activa el LED
delay(1000); // espera 1 segundo
digitalWrite(ledPin, LOW); // desactiva el LED
delay(1000); // espera 1 segundo
}
//Fin de programa
El “Hola mundo” de Arduino es el Sketch más sencillo que podemos cargar y ejecutar en nuestra placa Arduino. Se trata de hacer que un led se encienda y apague según unos intervalos definidos en el código del Sketch. Todo lo necesario para este primer ejercicio es una placa Arduino UNO y un LED. ¿Por qué lo llamamos sketch y no programa? El IDE de Arduino viene de Processing y en este lenguaje de programación enfocado al mundo gráfico cada código es considerado un boceto, en inglés “sketch”, y al heredar Arduino el IDE de Processing y su forma de guardar el código generado (.dpe) ha heredado también el nombre para los programas. SUGERENCIA: Desde el IDE entra en Archivo\Ejemplos\01.Basics\Fade
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
+
Miguel Ángel Asensio Hernández 44
INTRODUCCIÓN A LA PLACA ARDUINO.
Encender un LED con pulsador CURSO 2013/2014
Condicional if/else
Estado de un pulsador.
Leer una entrada digital y escribir una salida digital.
UNIDAD DE TRABAJO - Nº 2 TEMPORALIZACIÓN:
Este montaje enciende un LED mientras se mantenga pulsado el pulsador.
Configuración pull-up
//Declaración de variables
int pulsador=2; //Pin donde se encuentra el pulsador (entrada)
int led=13; //Pin donde se encuentra el LED (salida)
//Función principal
void setup() //Configuración
{
pinMode(pulsador, INPUT); //Configura el pulsador como entrada
pinMode(led,OUTPUT); //Configurar el LED como salida
}
void loop() //Bucle de programa
{
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH)
{
//Pulsador oprimido
digitalWrite(led, LOW); // Apaga el LED
}
else
{
//Pulsador NO oprimido
digitalWrite(led, HIGH); // Enciende el LED
}
}
//Fin de programa
Lista de materiales: Un LED Un pulsador Una resistencia de 1K
------------------------------
CÓDIGO DE PROGRAMA CONSEJOS
PRÁCTICOS
Miguel Ángel Asensio Hernández 45
INTRODUCCIÓN A LA PLACA ARDUINO.
Lectura Serial de una entrada digital
CURSO 2013/2014
Manejar una entrada digital
Monitor Serial
Leer una entrada digital y escribir por Monitor Serial
UNIDAD DE TRABAJO - Nº 3 TEMPORALIZACIÓN:
Leer una entrada digital y mostrar por Monitor Serial el estado del pulsador. Una resistencia pull-up
sirve para leer valores digitales sin que el valor de entrada sea indeterminado.
Pull-up
Pull-down
//Declaración de variables
int boton=2; //Pin donde se encuentra el pulsador, entrada
//Función principal
void setup() //Configuración
{
pinMode(boton,INPUT);
//Configura el botón como una entrada
Serial.begin(9600);
//Inicializa comunicación serial
}
void loop() //Bucle de programa
{
//Guardar en una variable entera el valor del botón 0 ó 1
int estado = digitalRead(boton);
//Condicional para saber el estado del pulsador
if (estado==1)
{
Serial.println("NO Pulsado"); //NO Pulsado
}
else
{
Serial.println("Pulsado"); //Pulsado
}
delay(100);
//Retardo para la visualización de datos en la consola
}
//Fin programa
Es muy importante tener en cuenta el conexionado externo de las Entradas/Salidas así como el tratamiento que Arduino hace de los valores, para poder activar una salida en función de si lo está o no una entrada. La función digitalRead(), que emplearemos aquí, devuelve el valor HIGH si la tensión en un determinado pin es igual a 5V, o LOW si el mismo está a 0V. Si un pin se deja sin conectar (flotante), el valor devuelto por la función anterior es indeterminado, y puede ser igualmente HIGH o LOW. Es aconsejable, por tanto, conectar en las entradas digitales resistencias pull-up o pull-down según interese, para evitar valores de entrada indeterminados.
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Miguel Ángel Asensio Hernández 46
INTRODUCCIÓN A LA PLACA ARDUINO.
Comunicación serie. El monitor serie de Arduino CURSO 2013/2014
Comunicación serie
Monitor serial desde el IDE de Arduino
Uso de la librería Serial
UNIDAD DE TRABAJO - Nº 4 TEMPORALIZACIÓN:
La comunicación serie de Arduino se basa en el empleo de la librería Serial. Es importante tener en
cuenta que la comunicación serie en el Arduino UNO se basa en el envío de datos a través de su puerto
serie (RX(0) y TX(1)) al igual que a través del USB. Por tanto, es muy importante no usar estos pines
como E/S a la hora de comunicar vía Serial Port con el PC.
Monitor Serial
/* Declaración e inicialización de una variable global
llamada "mivariable" */
int mivariable=555;
void setup()
{
Serial.begin(9600); //Inicializa la comunicación serie
}
void loop()
{
Serial.println(mivariable);
mivariable=mivariable+1;
delay (250);
}
// Fin de programa
Cargamos el programa en la placa, abrimos el “Serial monitor” y observamos que va apareciendo en tiempo real muchos números uno detrás de otro, empezando por el 555 y siguiendo por el 556, 557, 558, 559, etc…, aumentando sin parar.
La función Serial.begin() establece la velocidad en baudios para la transmisión de datos entre la placa Arduino y dispositivos externos. La sintaxis más habitual es Serial.begin(velocidad); La función Serial.print() imprime datos al puerto serie en formato ASCII. Las cifras se imprimen empleando un carácter ASCII para cada número, al igual que los números en coma flotante, con un redondeo por defecto a 2 decimales. Por ejemplo, si escribimos: Serial.print(78); //Imprime 78 Serial.print(1.2345); //Imprime 1.23 Serial.print(‘N’); //Imprime N Serial.print(“Hola Mundo”) //Imprime Hola Mundo La función Serial.println() añade al final de carácter una nueva línea.
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Miguel Ángel Asensio Hernández 47
INTRODUCCIÓN A LA PLACA ARDUINO.
Escritura Serial CURSO 2013/2014
Entrada por consola(terminal)
Variables booleanas
Estado de un LED
UNIDAD DE TRABAJO - Nº 5 TEMPORALIZACIÓN:
Consiste en escribir por la pantalla del computador (consola serial) una letra predeterminada, la primera
vez que se escriba esta un LED se enciende, si se vuelve a escribir por segunda vez el LED se apaga.
//--------------------------------------------------
//Declara puertos de entradas/salidas y variables
//--------------------------------------------------
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean encendido=false; //Estado LED la primera vez, apagado
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Configuración
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Bucle de programa
{
//Guardar en una variable el valor de la consola serial
leer=Serial.read();
// Si es la letra 'a' y además el LED está apagado
if ((leer=='a') && (encendido==false))
{
digitalWrite(led,HIGH); // Enciende el LED
encendido=true; // Actualiza el estado del LED }
// Si es la letra 'a' y además el LED está encendido
else if ( (leer=='a') && (encendido==true) )
{
digitalWrite(led,LOW); // Apaga el LED
encendido=false; // Actualiza el estado del LED
}
}
//Fin programa
CÓDIGO DE PROGRAMA CONSEJOS
PRÁCTICOS
Miguel Ángel Asensio Hernández 48
INTRODUCCIÓN A LA PLACA ARDUINO.
Lectura Serial de una Entrada Analógica CURSO 2013/2014
Manejar una entrada analógica
Visualizar los múltiples estados de un potenciómetro
Leer una entrada analógica
UNIDAD DE TRABAJO - Nº 6 TEMPORALIZACIÓN:
Lee una entrada analógica (A0) y muestra por pantalla (Monitor Serial) el valor leído al girar un
potenciómetro. Conviene recordar que la placa Arduino dispone de un conversor analógico-digital que
solo permite manejar valores de 0 a 1023, por lo que el valor máximo leído a través del potenciómetro
(5V) es convertido al valor 1023, mientras que el valor mínimo (0V) lógicamente corresponde a 0.
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Configuración
{
Serial.begin(9600); //Inicia comunicación serie
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Bucle de programa
{
//Guardar en una variable de tipo entero el valor del
//potenciómetro 0 a 1023.
Int valor= analogRead(A0);
//Imprime en Monitor Serial el valor de la variable
Serial.println(valor);
//Retardo para la visualización de datos en la consola
Delay(100);
}
//Fin de programa
Afortunadamente, como en este caso particular los mínimos de ambos rangos son 0, en vez de la función map(), que solo devuelve valores enteros, podemos escribir una simple regla de proporcionalidad. int valorPot=0; float voltajePot=0; void setup() { Serial.begin(9600); } void loop() { valorPot=analogRead(A2); voltajePot=valorPot*(5.0/1023.0); Serial.print(voltajePot); Serial.println(“ V”); delay(100); } De esta forma podemos observar todos los voltajes posibles.
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Una salida analógica del tipo PWM tiene
un rango de 0 a 255 (resolución 8bits).
Miguel Ángel Asensio Hernández 49
INTRODUCCIÓN A LA PLACA ARDUINO.
Analog_In_Out_Serial (entrada analógica, salida pwm, salida serial) CURSO 2013/2014
Manejar una salida PWM
Mapear un valor
If/else
UNIDAD DE TRABAJO - Nº 7 TEMPORALIZACIÓN:
Lee una entrada analógica (A0), mapea el resultado a un rango de 0 a 255 y utiliza el resultado para
ajustar la modulación de ancho de pulso (PWM) de una salida pseudoanalógica.
const int analogInPin=A0; //Entrada analógica desde Pot.
const int analogOutPin=9; //Salida analógica hacia LED
int sensorValue=0; //Valor leído desde el Pot inicializado
int outputValue=0; //Valor de salida PWM inicializada
void setup() {
Serial.begin(9600); //Inicia comunicación serie
}
void loop() {
sensorValue=analogRead(analogInPin); //Lectura analógica
//mapeo del rango de entrada desde lectura analógica:
outputValue=map(sensorValue,0,1023,0,255);
//cambiar valor analógico de salida:
analogWrite(analogOutPin, outputValue);
//imprimir resultados en Monitor Serial:
Serial.print(“Sensor= “);
Serial.print(sensorValue);
Serial.print(“\t output= “);
Serial.println(outputValue);
delay(2); //espera 2ms hasta la próxima lectura
}
//Fin de programa
Introduce en el código de la izquierda la siguiente modificación para que actúe la salida a partir de cierto valor de la entrada: //si el valor es mayor o igual a 500 if (sensorValue>=500) { digitalWrite(9,HIGH); //enciende el LED } //si el valor es menos a 500 else
{ digitalWrite(9,LOW); //apaga el LED } delay(100); }
CÓDIGO DE PROGRAMA CONSEJOS
PRÁCTICOS
Miguel Ángel Asensio Hernández 50
INTRODUCCIÓN A LA PLACA ARDUINO.
Lectura puerto serie CURSO 2013/2014
Lectura de un valor introducido por teclado
Enviar datos al microcontrolador
Serial.available()
UNIDAD DE TRABAJO - Nº 8 TEMPORALIZACIÓN:
Encendido y apagado de un LED por pulsación de una variable introducida por teclado.
int valor;
void setup(){
pinMode(13, HIGH);
Serial.begin(9600);
}
void loop(){
if(Serial.available()>0)
{
Valor=Serial.read();
}
if(valor==’a’)
{
digitalWrite(13,HIGH);
}
if(valor==’b’)
{
digitalWrite(13,LOW);
}
}
//Fin de programa
Serial.available(): devuelve el número de bytes disponibles para ser leídos que provienen del exterior a través del canal serie (TX/RX). Estos bytes ya han llegado al microcontrolador y permanecen almacenados temporalmente en una pequeña memoria de 64bytes (tipo buffer) que tiene el chip UART hasta que son procesados mediante la instrucción Serial.read(). Si no hay bytes para leer, esta instrucción devuelve un 0.
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Miguel Ángel Asensio Hernández 51
INTRODUCCIÓN A LA PLACA ARDUINO.
Control de un LED con fotocélula CURSO 2013/2014
Control de un LED por PWM
Leer entrada analógica por fotocécula
Ajustar una entrada analógica a una salida pwm (“analógica”)
UNIDAD DE TRABAJO - Nº 9 TEMPORALIZACIÓN:
Encendido y apagado de un LED de manera proporcional en función de la luz que recibe una fotocélula.
220
10k
/* LUZ DE LED EN FUNCIÓN DE LA LUZ */
int led=9;
int ldr=0;
int luz;
void setup(){
pinMode(9,OUTPUT);
Serial.begin(9600);
}
void monitoriza(){
Serial.print("El valor de luz es...");
Serial.println(luz);
delay(500);
}
void loop(){
luz=analogRead(ldr);
monitoriza();
if(luz<512&&luz>=0){analogWrite(led, 255);}
if(luz>=512&&luz<=1024){analogWrite(led, 64);}
}
Este código hace lucir un LED más o menos en función de la luz externa. Para ello conectamos una LDR a la entrada analógica A0 y un LED al pin 9. Cuando la luz se encuentre entre 0 y 512 el LED debe colocarse en el nivel de potencia máxima (255), si la luz se encuentra entre valores 512 y 1024 el LED debe lucir al nivel de potencia 64. Además es posible visualizar el valor de la LUZ recibida en la entrada analógica (valor entre 0 y 1023) en una consola Monitor serial.
Versión 2, del código anterior, pero ahora con tres LEDs: Para ello conectaremos una LDR a la entrada analógica 0 y los LEDs a los pines 9,10 y 11. Cuando la luz se encuentre entre 768 y 1023 los LEDs deben colocarse en el nivel de potencia 64, si la luz se encuentra entre valores 512 y 767 los LEDs deben lucir al nivel de potencia 127, si la luz se encuentra entre valores 256 y 511 los LEDs deben lucir al nivel de potencia 191, si la luz se encuentra entre valores 0 y 255 los LEDs deben lucir al nivel de potencia 255. Además se deberá visualizar el valor de LUZ en la entrada analógica (valor entre 0 y 1024) en una consola del Monitor Serial.
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Miguel Ángel Asensio Hernández 52
INTRODUCCIÓN A LA PLACA ARDUINO.
Control de tres LEDs con fotocélula CURSO 2013/2014
Control de un LED por PWM
Leer entrada analógica por fotocécula
Ajustar una entrada analógica a una salida pwm (“analógica”)
UNIDAD DE TRABAJO - Nº 9
Solución al ejercicio planteado:
int leds[]={9,10,11};
int tiempo=300;
int ldr=0;
int n=0;
int luz=0;
void setup(){
for(n=0;n<3;n++) {
pinMode(leds[n],OUTPUT);
}
Serial.begin(9600);
}
void monitoriza() {
Serial.print("El valor de la luz es ...");
Serial.println(luz);
delay(1000);
}
void loop(){
luz=analogRead(ldr);
monitoriza();
if (luz<=1023 && luz>=768) {
for (n=0;n<3;n++) {
analogWrite(leds[n],64);
delay(tiempo);
}
}
if (luz<=767 && luz>=512) {
for (n=0;n<3;n++) {
analogWrite(leds[n],127);
delay(tiempo);
}
}
if (luz<=511 && luz>=256) {
for (n=0;n<3;n++) {
analogWrite(leds[n],191);
delay(tiempo);
}
}
if (luz<=255 && luz>=0) {
for (n=0;n<3;n++) {
analogWrite(leds[n],255);
delay(tiempo);
}
}
}
Miguel Ángel Asensio Hernández 53
INTRODUCCIÓN A LA PLACA ARDUINO.
Control de tres LEDs con fotocélula de forma proporcional CURSO 2013/2014
Control de un LED por PWM
Leer entrada analógica por fotocécula
Ajustar una entrada analógica a una salida pwm (“analógica”)
UNIDAD DE TRABAJO - Nº 9
Luz de LEDs proporcional a la LUZ recibida. Versión 3.
El valor de la entrada analógica A0 está comprendido entre 0 y 1024, y el valor de la luminosidad de los leds entre 0 y 255. Los leds deben lucir entre 0 y 255 en función del valor de la entrada analógica A0, siendo su valor inversamente proporcional al valor de la entrada analógica A0 (de 0 a 1024), o sea a más luz menor intensidad luminosa de los leds. int ldr=0;
int leds[]={9,10,11};
int n=0;
int medida=0;
int luzled=0;
void setup(){
for (n=0;n<3;n++) {
pinMode(leds[n],OUTPUT);
}
Serial.begin(9600);
}
void monitoriza(){
Serial.print("La medida de luz es ...");
Serial.println(medida);
Serial.print("La luz a dar en los leds es ...");
Serial.println(luzled);
delay(200);
}
void loop(){
medida=analogRead(ldr);
luzled=255-(medida/4);
monitoriza();
for (n=0;n<3;n++){
analogWrite(leds[n],luzled);
delay(200);
}
}
Miguel Ángel Asensio Hernández 54
INTRODUCCIÓN A LA PLACA ARDUINO.
Sensor de Temperatura CURSO 2013/2014
Tecnología de estado sólido para medir temperatura
Empleando el LM35 como sensor de temperatura
Lectura de datos por consola Serial
UNIDAD DE TRABAJO - Nº 10 TEMPORALIZACIÓN:
Programa para testear el sensor de temperatura LM35. El código de programa muestra por el canal serie
de Arduino la temperatura ambiente leída por el sensor.
/* Sketch de ejemplo para testear el sensor de temperatura
analógico LM35 */
/*
MODO DE CONEXIÓN DEL SENSOR
Conectamos el pin 1 que corresponde a la alimentación del
sensor con los 5V del Arduino
Conectamos el pin 2 que corresponde al pin de datos del
sensor con cualquier pin analógico del Arduino A0
Conectamos el pin 3 que corresponde al pin de masa (GND)
del sensor con el pin GND del Arduino
*/
int temp = A0; //Pin donde conectaremos el pin de datos del
sensor LM35
float maxC = 0, minC = 100, maxF = 0, minF = 500;
//Variables para ir comprobando maximos y minimos
void setup()
{
Serial.begin(9600); //Iniciamos comunicación serie
}
void loop()
{
float gradosC, gradosF; //Declaramos variables tipo
float para guardar los valores de lectura
gradosC = (5.0*analogRead(temp)*100.0)/1024;
//Esta es la funcion con la que obtenemos la medida del
sensor en ºC
gradosF = (gradosC*1.8)+32;
//Multiplicando los ºC por1.8 y luego sumando 32 obtenemos
CÓDIGO DE PROGRAMA CONSEJOS
PRÁCTICOS
Miguel Ángel Asensio Hernández 55
grados Fahrenheit
//Mostramos mensaje con valores actuales de temperatura,
//asi como maximos y minimos de cada uno de ellos
Serial.print("Medidas actuales\n");
Serial.print("C: ");
Serial.print(gradosC);
Serial.print("\tF: ");
Serial.print(gradosF);
//Comprobacion de maximos y minimos de temperatura
if (maxC < gradosC)
maxC = gradosC;
if (gradosC < minC)
minC = gradosC;
if (maxF < gradosF)
maxF = gradosF;
if (gradosF < minF)
minF = gradosF;
Serial.print("\nMedidas maximas\n");
Serial.print("C: ");
Serial.print(maxC);
Serial.print("\tF: ");
Serial.print(maxF);
Serial.print("\nMedidas minimas\n");
Serial.print("C: ");
Serial.print(minC);
Serial.print("\tF: ");
Serial.print(minF);
Serial.print("\n\n");
delay(2000);
//Usamos un retardo de 2 segundos entre lectura y lectura
}
//FIN DE PROGRAMA
Miguel Ángel Asensio Hernández 56
INTRODUCCIÓN A LA PLACA ARDUINO.
Encendido progresivo de varios LED con fotocélula CURSO 2013/2014
Una aplicación Domótica
Leer entrada analógica por fotocécula
Ajustar umbral de oscuridad
UNIDAD DE TRABAJO - Nº 11 TEMPORALIZACIÓN:
La idea es iluminar nuestro entorno con LEDs a medida que vaya oscureciendo. Utilizaremos varios LEDs
controlados por señales digitales, de manera que se iluminen más LEDs a medida que se detecte más
oscuridad.
La gran novedad de este circuito es el uso de un voltaje de referencia (AREF) controlado por un
potenciómetro, permitiendo que nuestro circuito se adapte a entornos con diferentes extremos de
iluminación.
Miguel Ángel Asensio Hernández 57
/* LUZ DE LEDs EN FUNCIÓN DE LA OSCURIDAD */
//Declaración de variables
int valorLDR = 0;
byte i;
void setup()
{
//utilizaremos 5 LEDs, conectados a los pines 8,9,10,11 y 12
for (i=8;i<=12;i++) { pinMode(i, OUTPUT);}
analogReference(EXTERNAL);
}
void loop()
{
valorLDR = analogRead(0);
/*Si el entorno está muy iluminado -según la referencia marcada por
el potenciómetro-, no se enciende nigún LED*/
if(valorLDR >= 1023)
{
for (i=8;i<=12;i++) { digitalWrite(i, LOW);}
}
//Si está algo menos, se enciende un LED
else if(valorLDR >= 823)
{
digitalWrite(8, HIGH);
for (i=9;i<=12;i++) { digitalWrite(i, LOW);}
}
//Si está algo menos, se encienden dos LEDs
else if(valorLDR >= 623)
{
for (i=8;i<=9;i++) { digitalWrite(i, HIGH);}
for (i=10;i<=12;i++) { digitalWrite(i, LOW);}
}
//Si está algo menos, se encienden tres LEDs
else if(valorLDR >= 423)
{
for (i=8;i<=10;i++) { digitalWrite(i, HIGH);}
for (i=11;i<=12;i++) { digitalWrite(i, LOW);}
}
//Si está algo menos, se encienden cuatro LEDs
else if(valorLDR >= 223)
{
for (i=8;i<=11;i++) { digitalWrite(i, HIGH);}
digitalWrite(12, LOW);
}
//Si el entorno está muy oscuro, se encienden los cinco LEDs
else
{
for (i=8;i<=12;i++) { digitalWrite(i, HIGH);}
}
}
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 58
INTRODUCCIÓN A LA PLACA ARDUINO.
Lenguaje ARDUINO. Comunicación serie CURSO 2013/2014
Cambio de tipo de datos numéricos
Control de tipo de dato en el cálculo matemático
Monitor Serial
UNIDAD DE TRABAJO - Nº 12 TEMPORALIZACIÓN:
No se puede cambiar nunca el tipo de una variable: si esta se declara de un tipo concreto, seguirá siendo
de ese tipo a lo largo de todo el sketch. Pero si se puede cambiar “al vuelo” en un momento concreto el
tipo de valor que contiene.
//EJEMPLO 12.1
// Dato tipo float y byte
float variablefloat=3.4;
byte variablebyte=126;
void setup()
{
Serial.begin(9600);
Serial.println(byte(variablefloat));
Serial.println(int(variablefloat));
Serial.println(word(variablefloat));
Serial.println(long(variablefloat));
Serial.println(char(variablefloat));
Serial.println(float(variablefloat));
Serial.println(byte(variablebyte));
}
void loop()
{
//no ejecutamos nada aquí
}
//EJEMPLO 12.2
// Cálculo matemático
/* si se ejecuta este código, se puede observar que el resultado
Obtenido es 2 cuando debería ser 2,5. */
float resultado;
int numerador=5;
int denominador=2;
void setup()
{
Serial.begin(9600);
resultado=numerador/denominador;
Serial.println(resultado);
}
void loop() {}
/* para solucionar el problema del código anterior debemos hacer un cambio de tipo
“al vuelo” */
resultado=float(numerador)/denominador;
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 59
//EJEMPLO 12.3
// Cambio de tipo de datos
int numero=100;
long resultado;
void setup()
{
Serial.begin(9600);
resultado=numero*1000;
Serial.println(resultado);
}
void loop() {}
/* se están multiplicando dos valores de tipo “int”, y el resultado por tanto
sobrepasa el rango aceptado por este tipo de datos. Para evitar esto, lo más fácil
sería forzar a que alguno de los elementos presentes en el cálculo sea del mismo
tipo de dato que el de la variable “resultado”, puesto que, el tipo del número
resultante es el mismo que el tipo de dato del operando con mayor capacidad */
int numero=100;
long resultado;
void setup()
{
Serial.begin(9600);
resultado=long(numero)*1000;
Serial.println(resultado);
}
void loop() {}
//EJEMPLO 12.4
/* Como hemos podido observar en el Monitor Serial, los datos se muestran en sus
correspondientes caracteres ASCII. Es así porque el propio “monitor serie” realiza
en tiempo real dicha traducción. Gracias a este comportamiento, podemos ver en todo
momento el carácter asociado al byte enviado.*/
//OPCIÓN 12.4.1
char cadena[]=”hola”;
byte bytesDevueltos;
void setup()
{
Serial.begin(9600);
bytesDevueltos=Serial.Write(cadena);
Serial.println(bytesDevueltos);
//el código devuelve el valor “hola4”. El 4 representa el número de bytes devueltos
}
Void loop() {}
//OPCIÓN 12.4.2
//El array ha de ser de tipo “byte” (o char)
byte arraybytes[]={65,66,67,68};
void setup() {
Serial.begin(9600);
//Se envían solo los dos primeros elementos de ese array
Serial.write(arraybytes,2);
}
Void loop(){}
Miguel Ángel Asensio Hernández 60
//EJEMPLO 12.5
//recibiendo datos desde el exterior
byteRecibido=0;
void setup() {
Serial.begin(9600);
}
Void loop(){
if(Serial.available() > 0 {
byteRecibido = Serial.read();
Serial.write(“Byte recibido: “);
Serial.write(byteRecibido);
}
}
//el código siguiente utiliza Serial.find() para leer continuamente los datos
//presentes el buffer de entrada.
boolean encontrado;
void setup(){
Serial.begin(9600);
}
void loop(){
encontrado=Serial.find(“hola”);
if (encontrado ==true){
Serial.println(“Encontrado”);
}
}
Miguel Ángel Asensio Hernández 61
INTRODUCCIÓN A LA PLACA ARDUINO.
Control ON/OFF de un motor DC CURSO 2013/2014
Condicional If/else
Conectar un motor DC por transistor
Condicional a partir del estado de un pulsador
UNIDAD DE TRABAJO - Nº 13 TEMPORALIZACIÓN:
Accionamiento de un motor con pulsador. Mientras se mantenga pulsado el motor estará encendido
(ON) de lo contrario el motor debe estar apagado (OFF).
R1=R2=1K
/* Programa que hace uso de un motor y un pulsador,
mientras se mantenga pulsado, el motor debe
estar encendido (ON) de lo contrario debe estar
apagado (OFF) */
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int pulsador =7; //Declara Pin del pulsador
int motor=3; //Declara Pin del motor
//------------------------------------
//Función principal
//------------------------------------
void setup()
{
pinMode(pulsador,INPUT); //El pulsador es entrada
pinMode(motor,OUTPUT); //El motor como es salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop()
{
// Si el pulsador se encuentra oprimido
if(digitalRead(pulsador) == HIGH)
{ digitalWrite(motor,HIGH);}//Enciende el motor
else
{ digitalWrite(motor,LOW);}
//si el pulsador no está oprimido. Apaga el motor
}
// Fin programa
BD137
CÓDIGO DE PROGRAMA CONSEJOS
PRÁCTICOS
Miguel Ángel Asensio Hernández 62
INTRODUCCIÓN A LA PLACA ARDUINO.
Control PWM de un motor CURSO 2013/2014
Leer datos de la Consola Serial
Manejo de la función map()
Variar PWM para producir 5 velocidades diferentes.
UNIDAD DE TRABAJO - Nº 14 TEMPORALIZACIÓN:
Programa que hace uso de un motor y la Consola Serial de Arduino para configurar 5 velocidades
distintas al motor. Desde el teclado se selecciona la velocidad deseada configurando 5 PWM diferentes.
int motor=3; //Declara el pin del motor
void setup()
{
Serial.begin(9600); //Inicializa la comunicación serial
}
void loop()
{ //Si hay algún valor en la consola serial
if(Serial.available())
{ //Variable que guarda el carácter enviado desde teclado
char a=Serial.read();
//Si el carácter introducido está entre 0 y 5
if(a>='0' && a<='5')
{ //Variable para escalar el valor introducido a rango PWM
int velocidad= map(a, '0', '5', 0, 255);
//Escritura de PWM al motor
analogWrite(motor, velocidad);
//Mensaje para el usuario
Serial.print("El motor está girando a la velocidad seleccionada ");
Serial.println(a);
}
else //Si el carácter introducido NO está entre 0 y 5
{ Serial.print("Velocidad invalida "); //Mensaje para el usuario
Serial.println(a);}
}
}
// Fin de programa
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 63
INTRODUCCIÓN A LA PLACA ARDUINO.
Salida PWM + Motor + L293 CURSO 2013/2014
Control de motores DC mediante driver L293
Empleo de salidas PWM
UNIDAD DE TRABAJO - Nº 15 TEMPORALIZACIÓN:
Control de la velocidad de giro y el sentido de giro de un motor de corriente continua (DC) mediante un
driver integrado del tipo L293.
int valor=0;
int motorAvance=10;
int motorRetroceso=11;
void setup(){
}
void loop()
{
analogWrite(motorAvance, 0); //Motor hacia adelante...velocidad ++
for(valor=0; valor<=255; valor+=5)
{
analogWrite(motorAvance, valor);
delay(30);
}
for(valor=255; valor>=0; valor-=5) //Velocidad --
{
analogWrite(motorAvance, valor);
delay(30);
}
analogWrite(motorRetroceso, 0); //Motor hacia atrás...velocidad ++
for(valor=0; valor<=255; valor+=5)
{
analogWrite(motorRetroceso, valor);
delay(30);
}
for(valor=255; valor>=0; valor-=5) //Velocidad --
{
analogWrite(motorRetroceso, valor);
delay(30);
}
}
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 64
INTRODUCCIÓN A LA PLACA ARDUINO.
Control de 2 motores con Driver L293 CURSO 2013/2014
Controlar 2 motores con control de velocidad y giro con un L293
//Programa para controlar 2 motores con control de velocidad y giro con un L293
int switchPin = 7; // switch para cambiar el sentido de giro de los motores
int motor1Pin1 = 3; // Motor 1 adelante
int motor1Pin2 = 4; // Motor 1 atras
int speedPin1 = 9; // Motor 1 aceleracion (PWM) Pin enable del L293
int potPin = 0; // Potenciometro para controlar velocidad motor 1
int ledPin = 13; // LED
int motor2Pin1 = 5; // Motor 2 adelante
int motor2Pin2 = 6; // Motor 2 atrás
int speedPin2 = 10; // Motor 2 aceleración (PWM) Pin Enable del L293
int potPin2 = 1; // Potenciómetro para controlar velocidad motor 2
int speedpin = 0; // tasa de velocidad a la que Arduino envía los datos
void setup() {
Serial.begin (9600);
//configuracion de pines
pinMode(switchPin, INPUT);
//pinMode(switchPin2, INPUT); //no usado
// Control Motor 1
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(speedPin1, OUTPUT);
//Control Motor 2
pinMode(motor2Pin1, OUTPUT);
pinMode(motor2Pin2, OUTPUT);
pinMode(speedPin2, OUTPUT);
pinMode(ledPin, OUTPUT);
// Establece speedPinX en modo High para poder controlar la velocidad
digitalWrite(speedPin1, HIGH);
digitalWrite(speedPin2, HIGH);
// comprobación de reseteo, si el led parpadea solo 3 veces, todo esta bien
// si vuelve a parpadear, significa que ha hecho un reset, revisar conexiones
// por si hubiera un corto
blink(ledPin, 3, 100);
}
void loop() {
//Si el switch no está pulsado, gira en una dirección, si no en la contraria
if (digitalRead(switchPin) >0) {
digitalWrite(motor1Pin1, LOW); // Establece el sentido de giro del motor 1
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 65
digitalWrite(motor1Pin2, HIGH); //
speedpin = analogRead(potPin); // Lectura del valor del potenciómetro
speedpin = 800 + (speedpin/6); // Para establecer la velocidad de giro
analogWrite (speedPin1, speedpin); //
Serial.print("motor 1 = "); //
Serial.println(speedpin); //
delay (50); //
digitalWrite(motor2Pin1, LOW); // Establece el sentido de giro del motor 2
digitalWrite(motor2Pin2, HIGH); //
speedpin = analogRead(potPin2); // Lectura del valor del potenciómetro
speedpin = 800 + (speedpin/6); // Para establecer la velocidad de giro
analogWrite (speedPin2, speedpin); //
Serial.print("motor 2 = "); //
Serial.println(speedpin); //
delay(50); //
}
else {
digitalWrite(motor1Pin1, HIGH); // Establece el sentido de giro del motor 1
digitalWrite(motor1Pin2, LOW); //
speedpin = analogRead(potPin); // Lectura del valor del potenciómetro
speedpin = 800 + (speedpin/6); // Para establecer la velocidad de giro
analogWrite (speedPin1, speedpin); //
Serial.print("motor 1 = "); //
Serial.println(speedpin); //
delay (50); //
digitalWrite(motor2Pin1, HIGH); // Establece el sentido de giro del motor 2
digitalWrite(motor2Pin2, LOW); //
speedpin = analogRead(potPin2); // Lectura del valor del potenciómetro
speedpin = 800 + (speedpin/6); // Para establecer la velocidad de giro
analogWrite (speedPin2, speedpin); //
Serial.print("motor 2 = "); //
Serial.println(speedpin); //
delay(50); //
}
}
/*
Parpadeo del led, Significa que ha ejecutado la función setup()
si todo va bien, solo parpadea tres veces, si hay algún error que resetee el
arduino, volverá a verse el parpadeo del led
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
int i = 0;
for ( i = 0; i < howManyTimes; i++) {
digitalWrite(whatPin, HIGH);
delay(milliSecs/2);
digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}
Miguel Ángel Asensio Hernández 66
INTRODUCCIÓN A LA PLACA ARDUINO.
Cruce de semáforos. CURSO 2013/2014
Familiarizarse con el entorno de programación.
Aprender a declarar variables tipo lista de valores.
UNIDAD DE TRABAJO - Nº 16 TEMPORALIZACIÓN:
Se trata de un cruce de semáforos controlado por Arduino, para ello utilizaremos en el primer semáforo los pines 3 (led rojo), 4 (led ámbar), 5 (led verde), en el segundo semáforo utilizaremos los pines 6 (led rojo), 7 (led ámbar) y 8 (led verde). La secuencia de funcionamiento debe ser: rojo 1 – verde 2 durante 3 segundos, rojo 1 – ámbar 2 durante 500 ms, verde 1 – rojo 2 durante 3 segundos, ámbar 1 - , rojo 2 durante 500 ms.
PARA REALIZAR CON ARDUBLOCK
int leds[]={3,4,5,6,7,8);
int tiempo1=3000;
int tiempo2=500;
int n;
void setup() {
for (n=0;n<6;n++) {
pinMode (leds[n],OUTPUT);}
}
void loop () {
digitalWrite (leds[0],HIGH);
digitalWrite (leds[5],HIGH);
delay (tiempo1);
digitalWrite (leds[5],LOW);
digitalWrite (leds[4],HIGH);
delay (tiempo2);
difitalWrite[leds[0],LOW);
digitalWrite (leds[2],HIGH);
digitalWrite (leds[4],LOW);
digitalWrite (leds[3],HIGH);
delay (tiempo1);
digitalWrite (leds[2],LOW);
digitalWrite(leds[1],HIGH);
delay (tiempo2);
}
CÓDIGO DE PROGRAMA CONSEJOS PRÁCTICOS
Miguel Ángel Asensio Hernández 67
INTRODUCCIÓN A LA PLACA ARDUINO.
Efecto Coche Fantástico. CURSO 2013/2014
Familiarizarse con el entorno de programación.
Repasar declaración de variables tipo lista de valores.
Repasar órdenes de control de programa como: for.
UNIDAD DE TRABAJO - Nº 17 TEMPORALIZACIÓN:
Se trata de encender y apagar 7 leds secuencialmente. Los leds deben estar conectados a los pines 5, 6, 7, 8, 9, 10 y 11. Se deben encender y apagar los leds desde el pin 5 al 11, con un tiempo de encendido y apagado de 50 ms, más tarde se deben encender y apagar los leds desde el pin 11 al 5, con un tiempo de encendido y apagado de 50 ms. La secuencia se debe repetir indefinidamente. El efecto del programa es el de las luces delanteras de nuestro querido "Coche fantástico".
VERSIÓN 1.
int leds[]={5,6,7,8,9,10,11};
int n=0;
int tiempo=50;
void setup() { //comienza la configuración
for (n=0;n<7;n++) {
pinMode(leds[n],OUTPUT);
}
}
void loop() {
for (n=0;n<7;n++) {
digitalWrite (leds[n],HIGH);
delay(tiempo);
digitalWrite (leds[n],LOW);
delay(tiempo);
}
for (n=6;n>=0;n--) {
digitalWrite (leds[n],HIGH);
delay(tiempo);
digitalWrite (leds[n],LOW);
delay(tiempo);
}
}
Miguel Ángel Asensio Hernández 68
VERSIÓN 2.
int leds[]={5,6,7,8,9,10,11};
int n=0;
int tiempo=30;
void setup() //comienza la configuración
{
for (n=0;n<7;n++)
{
pinMode(leds[n],OUTPUT);
}
}
void loop()
{
for (n=0;n<7;n++)
{
digitalWrite (leds[n],HIGH);
delay(tiempo);
digitalWrite(leds[n+1],HIGH);
delay(tiempo);
digitalWrite (leds[n],LOW);
delay(tiempo*2);
}
for (n=6;n>=0;n--)
{
digitalWrite (leds[n],HIGH);
delay(tiempo);
digitalWrite(leds[n-1],HIGH);
delay(tiempo);
digitalWrite (leds[n],LOW);
delay(tiempo*2);
}
}
VERSIÓN 3.
int n=0;
int tiempo=50;
void setup() { //comienza la
configuración
for (n=5;n<12;n++) {
pinMode(n,OUTPUT);
}
}
void loop() {
for (n=5;n<12;n++) {
digitalWrite (n,HIGH);
delay(tiempo);
digitalWrite (n,LOW);
delay(tiempo);
}
for (n=11;n>=5;n--) {
digitalWrite (n,HIGH);
delay(tiempo);
digitalWrite (n,LOW);
delay(tiempo);
}
}
CÓDIGO DE PROGRAMA
Miguel Ángel Asensio Hernández 69
Recommended