MANUAL DE PROGRAMACIÓN PARA ARDUINO - … de programación... · Miguel Ángel Asensio Hernández 3 Manual de consulta rápida sobre los comandos básicos y la sintaxis del lenguaje

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


Manual de consulta rápida sobre los comandos básicos y la sintaxis del

lenguaje de programación de Arduino.

IDE de Arduino.



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.


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);

}


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;


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).


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


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.


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.


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


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


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.


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

}

}


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


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;

}


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

}


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.


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);



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

}


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.


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)


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.


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) */


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.


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


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

}

}




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.


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.


C:\Program Files (x86)\Arduino

IDE DE ARDUINO. Entorno de trabajo.









17 Prácticas con ARDUINO


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

+



Encender un LED con pulsador CURSO 2013/2014

Condicional if/else

Estado de un pulsador.

Leer una entrada digital y escribir una salida digital.


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


{

pinMode(pulsador, INPUT); //Configura el pulsador como entrada

pinMode(led,OUTPUT); //Configurar el LED como salida

}


{

//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



Lectura Serial de una entrada digital

CURSO 2013/2014

Manejar una entrada digital

Monitor Serial

Leer una entrada digital y escribir por Monitor Serial


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


int boton=2; //Pin donde se encuentra el pulsador, entrada



{

pinMode(boton,INPUT);

//Configura el botón como una entrada

Serial.begin(9600);

//Inicializa comunicación serial

}


{

//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.




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


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.




Escritura Serial CURSO 2013/2014

Entrada por consola(terminal)

Variables booleanas

Estado de un LED


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

//------------------------------------


{

Serial.begin(9600); //Inicia comunicación serial

pinMode(led, OUTPUT); //Configurar el LED como una salida

}

//------------------------------------

//Funcion ciclicla

//------------------------------------


{

//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


PRÁCTICOS



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


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

//------------------------------------


{

Serial.begin(9600); //Inicia comunicación serie

}

//------------------------------------

//Funcion ciclicla

//------------------------------------


{

//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.


Una salida analógica del tipo PWM tiene

un rango de 0 a 255 (resolución 8bits).



Analog_In_Out_Serial (entrada analógica, salida pwm, salida serial) CURSO 2013/2014

Manejar una salida PWM

Mapear un valor

If/else


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); }


PRÁCTICOS



Lectura puerto serie CURSO 2013/2014

Lectura de un valor introducido por teclado

Enviar datos al microcontrolador

Serial.available()


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.




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”)


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.




Control de tres LEDs con fotocélula CURSO 2013/2014




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++) {


delay(tiempo);

}

}

if (luz<=511 && luz>=256) {

for (n=0;n<3;n++) {


delay(tiempo);

}

}

if (luz<=255 && luz>=0) {

for (n=0;n<3;n++) {


delay(tiempo);

}

}

}



Control de tres LEDs con fotocélula de forma proporcional CURSO 2013/2014




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++) {


}

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);

}

}



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


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


PRÁCTICOS


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(maxC);


Serial.print(maxF);

Serial.print("\nMedidas minimas\n");


Serial.print(minC);


Serial.print(minF);

Serial.print("\n\n");

delay(2000);

//Usamos un retardo de 2 segundos entre lectura y lectura

}

//FIN DE PROGRAMA



Encendido progresivo de varios LED con fotocélula CURSO 2013/2014

Una aplicación Domótica


Ajustar umbral de oscuridad


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.


/* LUZ DE LEDs EN FUNCIÓN DE LA OSCURIDAD */


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);


}

//Si está algo menos, se encienden dos LEDs


{

for (i=8;i<=9;i++) { digitalWrite(i, HIGH);}


}

//Si está algo menos, se encienden tres LEDs


{



}

//Si está algo menos, se encienden cuatro LEDs


{


digitalWrite(12, LOW);

}

//Si el entorno está muy oscuro, se encienden los cinco LEDs

else

{


}

}

CÓDIGO DE PROGRAMA



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


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


//EJEMPLO 12.3

// Cambio de tipo de datos

int numero=100;

long resultado;

void setup()

{

Serial.begin(9600);

resultado=numero*1000;


}

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;


}

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(){}


//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”);

}

}



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


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

//------------------------------------


//------------------------------------

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


PRÁCTICOS



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.


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



Salida PWM + Motor + L293 CURSO 2013/2014

Control de motores DC mediante driver L293

Empleo de salidas PWM


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



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(speedPin1, OUTPUT);

//Control Motor 2



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


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





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





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





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);

}

}



Cruce de semáforos. CURSO 2013/2014

Familiarizarse con el entorno de programación.

Aprender a declarar variables tipo lista de valores.


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);


delay (tiempo1);

digitalWrite (leds[5],LOW);


delay (tiempo2);

difitalWrite[leds[0],LOW);




delay (tiempo1);


digitalWrite(leds[1],HIGH);

delay (tiempo2);

}




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.


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++) {


}

}

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--) {


delay(tiempo);


delay(tiempo);

}

}


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++)

{


}

}

void loop()

{

for (n=0;n<7;n++)

{


delay(tiempo);

digitalWrite(leds[n+1],HIGH);

delay(tiempo);


delay(tiempo*2);

}

for (n=6;n>=0;n--)

{


delay(tiempo);

digitalWrite(leds[n-1],HIGH);

delay(tiempo);


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


Documents

MANUAL DE PROGRAMACIÓN PARA ARDUINO - … de programación... · Miguel Ángel Asensio Hernández 3 Manual de consulta rápida sobre los comandos básicos y la sintaxis del lenguaje