MANUAL DE INTRODUCCIN:

LPEZ DE NAVA LPEZ DIEGO OROPEZA LPEZ IRWIN JESS

MANUAL DE ARDUINO ndice

1 2 3 Introduccin Estructura de un programa Funciones Variables 3.1 delay () 3.2 milis () Aritmticas Entradas y salidas Digitales/Analgicas 5.1 pinMode(pin, mode) 5.2 digitalRead(pin) 5.3 digitalWrite(pin, value) 5.4 analogRead(pin) 5.5 analogWrite(pin, value) Constantes 6.1 (TRUE/FALSE) 6.2 HIGH/LOW 6.3 INPUT/OUTPUT Condicionales 7.1 if () 7.2 if else () 7.3 for() 7.4 while() 7.5 do while() 4 5 5 6 7 7 7 8 8 8 8 8 9 9 9 9 9 9 9 10 10 10 11 11 11 11 11 12 12 12 13 13 13 13 14 14 14 17 17 18 19 20

4 5

Variables especiales
8.1 Arrays[] 8.2 String 8.3 map() 8.4 switch (range) Comunicacin Serie 9.1 Serial.begin(rate) 9.2 Serial.println(data) 9.3 Serial.printnl(data, data type) 9.4 Serial.print(data, data type) 9.5 Serial.avaible() 9.6 Serial.Read() Subrutinas Comunicacin Arduino y mdulos PyC Ejemplos Unidad 5 Entradas y Salidas Activacin de seales Digitales Contador de pulsos Activacin de una entrada analgica Barra de Leds

10 11

5.1 5.2 5.3 5.4

Pgina 1 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
7.1 7.2 8.1 8.2 9.1 11.1 11.2 11.3 11.4 11.5 Unidad 7 Condicionales Encender/Apagar el LED de forma proporcional Control Analgico Unidad 8 Variables Especiales String Contador Binario Unidad 9 Comunicacin Serie Escritura analgica Unidad 11 Comunicacin Arduino y mdulos PyC Comunicacin Servo Servo potencimetro Servo Switch Modulo de Pasos Modulo de LCD Anexos Palabras reservadas del IDE de Arduino Programa para obtener los valores mximos de una entrada analgica 21 22 23 24 26 27 28 29 30 31 32 34

Pgina 2 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO INTRODUCCIN

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseada para facilitar el uso de la electrnica en proyectos multidisciplinares. El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida. Consta de 14 pins digitales configurables entrada I/O, salidas que operan a 5V. Cada pin puede proporcionar o recibir como mximo 40 mA. Los pines 3, 5, 6, 8, 10 y 11 pueden proporcionar una salida PWM. Si se conecta cualquier cosa a los pines 0 y 1, eso interferir con la comunicacin USB. Tambin tiene 6 entradas analgicas que proporcionan una resolucin de 10 bits. Por defecto miden de 0 hasta 5 voltios, aunque es posible cambiar el nivel ms alto, utilizando el pin Aref y algn cdigo de bajo nivel.

Arduino UNO R3

Pgina 3 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO 1.- Estructura de un programa en Arduino.

La estructura bsica del lenguaje de programacin de Arduino es bastante simple y se compone de 2 partes, las cuales encierran bloques que contienen declaraciones, instrucciones.
void setup() { Configuraciones; } void loop() { Instrucciones;

En el cual setup() es la parte encargada de recoger la configuracin y loop() es la que contiene el programa que se ejecutara cclicamente (de ah el trmino loop bucle-). Ambas instrucciones son necesarias para que el programa trabaje. La funcin de configuracin debe contener la declaracin de las variables. Es la primera funcin ejecutar en el programa, se ejecuta una sola vez, y se utiliza para configurar o inicializar pinMode (modo de trabajo de las E/S), configuracin de la comunicacin en serie y otras. Debe ser incluido en un programa aunque no haya declaracin que ejecutar. La funcin bucle (loop) siguiente contiene el cdigo que se ejecutara continuamente. Esta funcin es el ncleo de todos los programas Arduino y la realiza la mayor parte del trabajo.
void setup() { pinMode(1, OUTPUT); // configura el pin como salida } void loop() { digitalWrite(1, HIGH); // pone en 1 el pin delay(1000); //espera un segundo (1000 ms) digitalWrite(1, LOW); //pone en 0 el pin delay(1000); }

2.- Funciones
Una funcin es un bloque de cdigo que tiene un nombre y un conjunto de estamentos que son ejecutados cuando se llama a la funcin. Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamao de un programa. La funcin se declaran asociadas a un tipo de valor type. Este valor ser el que devolver la funcin, por ejemplo int se utilizara cuando la funcin devuelva un dato numrico de tipo entero. Si la funcin no devuelve ningn dato entonces se colocara la palabra voild. Despus de declarar el tipo de dato que devuelve la funcin se debe escribir el nombre de la funcin y entre parntesis se escribirn, si es necesario, los parmetros que se deben pasar a la funcin para que se ejecute.

Pgina 4 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
type nombrefuncion(parametros) { estamento; }

Las llaves sirven para definir el principio y el final de un bloque de instrucciones, y siempre que pongamos {deber llevar al final del bloque } para especificar el termino de este. El punto y coma ;, se utiliza para separar instrucciones en el lenguaje de programacin de Arduino. Tambin se utiliza para separar elementos en una instruccin de tipo bucle for. Los bloques de comentarios son reas de texto ignorados por el programa que se utilizan para descripciones del cdigo o comentarios que ayuden a comprender el programa, comienzan con /* y termina en */. Una lnea de comentario se utiliza igualmente para poner comentario pero inicia con un // y termina con la siguiente lnea de cdigo. Estos comentarios son ignorados por el programa y no ocupan espaci en la memoria.

3.- Variables
Una variable es una manera de nombrar y almacenar un valor numrico para su uso posterior por el programa. Como su nombre indica, las variables son nmeros que se puedan variar continuamente en contra de lo que ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser declarada o asignarle un valor.
int variableEntrada = 0; //declara una variable y le asigna el valor 0 variableEntrada = analogRead(2); //la variable recoge el valor analgico del PIN2

Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para declarar una variable se comienza por definir su tipo (int, long, floar, etc.), asignndoles siempre un nombre y/o un valor inicial. Esto debe hacerse solo una vez en un programa, pero el valor se puede cambiar cuando se necesite. Una variable puede ser declarada al inicio del programa (variable global), antes de la parte de configuracin setup(), a nivel local (variable local) dentro de las funciones o dentro de boques de bucles como for, if, etc. Los diferentes tipos de variables son: byte: Almacena un valor numrico de 8 bits sin decimales y tiene un rango de 0 a 255. int: Enteros son tipo de datos primarios que almacenan valores de 16 bits sin decimales comprendidos en el rango 32,767 a -32,768. long: El formato de variable numrica de tipo extendido long se refiere a nmeros enteros de 32 bits sin decimal que se encuentran dentro del rango -2,147,483,648 a 2,147,483,647.
Pgina 5 de 34 www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
float: El formato de dato tipo punto flotante se aplica a los nmeros con decimal. Tienen una resolucin de 32 bits con rango comprendido 3.4028235E +38 a -3.402823E-38.
int value; // value es visible para cualquier funcin void setup() { //no es necesario configurar } void loop() { for (int i=0; i<20) // i solo es visible dentro del bucle for { i++ } float f; f solo visible dentro del bucle }

3.1.- delay(ms)
Detiene la ejecucin del programa por la cantidad de tiempo en ms que se indica en la propia instruccin. De tal manera que 1000 equivale a 1s.

3.2.- millis()
Devuelve el nmero de ms transcurridos desde que inicio del programa Arduino hasta el momento actual, hasta un mximo de 9hr.

4.- Aritmtica
Los operadores aritmticos que se incluyen en el entorno de programacin son: suma, resta, multiplicacin y divisin. Estos devuelven la operacin de 2 operandos. Las asignaciones compuestas combinan una operacin aritmtica con una variable asignada. Estas asignaciones compuestas pueden ser:
x ++ // igual que x= x+1, o incrementar x en +1 x -- // igual que x= x-1, o decremento x en -1 x + = y //igual que x = x+y, o incrementa x en +y x - = y // iguala x = x-y, o decremento 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

Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales tipo if, para testear si una condicin es verdad.
x == y // x es igual a y x = y // x no es igual a y x < y // x es menor a y x > y // x es mayor a y x <= y //x es menor o igual que y x >= y // x es mayor o igual que y

Los operadores lgicos usualmente una forma de comparar dos expresiones y devolver un verdadero o falso dependiendo del operador. Existen tres operadores lgicos, AND (&&), OR (||), y NOT (!), que a menudo se utiliza en estamentos de tipo if.
Pgina 6 de 34 www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
Logical AND: if (x > 0 && x < 5) // cierto solo si las dos expresiones son ciertas Logical OR: if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es cierta Logical NOT: if (!x > 0) // cierto solo si la expresin es falsa

5.- Entradas y salidas Digitales/analgicas

El Arduino tiene 13 I/O digitales y 6 entradas analgicas las cuales pueden ser activadas mediante el programa dependiendo su funcin especfica. A continuacin se conocer la forma de activarlas.

5.1.- pinMode(pin, mode)

Esta instruccin es utilizada en la parte de configuracin setup() y sirve para configurar el modo de trabajo de un PIN pudiendo INPUT u OUTPUT.
pinMode(pin, OUTPUT); //configura pin como salida

Los pines Arduino por defecto vienen configurados como entradas. Estos pines tienen nivel interno una resistencia de 20 K ohm a las que se puede acceder mediante software. Estas resistencias se acceden de la siguiente manera.
pinMode(pin, INPUT); digitalWrite(pin, HIGH);

Las resistencias internas usualmente se utilizan para conectar las entradas a interruptores.

5.2.- digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH o LOW. El pin puede especificar ya sea como variable o constante (0-13).

5.3.- digitalWrite(pin, value)

Enva al pin definido previamente como OUTPUT el valor HIGHT o LOW. El pin se puede especificar ya sea como una variable o como una constante (0-13).

5.4.- analogRead(pin)
Lee el valor de un determinado pin definido como entrada analgico con una resolucin de 10 bits. Esta instruccin solo funciona en los pines (0-5). El rando de valor que podemos leer oscila de 0 a 1023.
valor = analogRead(pin);

Pgina 7 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
5.5.- analogWrite(pin, value)
Esta instruccin sirve para escribir un pseudo-valor analgico utilizado el procedimiento de modulacin por ancho de pulso (PWM) a uno de los pin de Arduino marcados como pin PWM.

6.- Constantes
El lenguaje de programacin de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan para hacer los programas fciles de leer. Las constantes se clasifican en grupos.

6.1.- (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, mientras que TRUE se asocia con 1, pero TRUE tambin puede ser cualquiera otra cosa excepto 0.Por lo tanto, en sentido booleano, -1, 2 y -200 tambin se define como TRUE. (esto es importante tenerlo en cuenta).

6.2.- HIGH/LOW
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la escritura digital para las plantillas. HIGH se define como en la lgica de nivel 1, ON (5V), mientras que LOW es la lgica nivel 0, OFF (0V).

6.3.- INPUT/OUTPUT
Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los pines mediante la instruccin pinMode de tal manera que el pin puede ser entrada o salida.

7.- Condicionales
Estos estamentos se usan frecuentemente en la programacin del Arduino y sirven principalmente para preguntar o validar una accin.

7.1.- if ()
if es un estamento que se utiliza para probar si una determinada condicin se ha alcanzado, mientras la condicin sea cierta realiza una serie de operaciones que se escriben entre llaves. Si es falso el programa salta y no ejecuta lo que esta entre llaves. El formato de if es el siguiente:
if (unavariable ?? valor) // Se compara una variable con otro valor { Ejecuta instrucciones; }

Pgina 8 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
Nota: Tenga en cuenta el uso de = ya que puede parecer correcto if (x=10) pero sin embargo no lo es ya que esa expresin sirve para asignar el valor 10 a x, por lo que se usa en la estructura if x==10 lo cual el programa lo traduce como si el valor de x es 10 entonces.

7.2.- if else ()
If else viene a ser una estructura que se ejecuta en respuesta a la idea si esto no se cumple haz el otro.
If (inputPIN == HIGH) // si el valor de la entrada inputPIN es alto { InstruccinA; //ejecuta si se cumple la condicin } Else { InstruccinB; //ejecuta si no se cumple la condicin }

7.3.- for
Esta declaracin se usa para repetir un bloque de sentencias entre llaves un nmero determinado de veces. Cada vez que se ejecute la instruccin del bucle se vuelve a testear la condicin.
For (inicializacin; condicin; expresin) { ejecutaInstruccin; }

La inicializacin de una variable local se ejecuta una sola vez y la condicin se testea cada vez se termina la ejecucin de las instrucciones dentro del bucle. Si la condicin sigue cumplindose, la instruccin dentro del bucle se vuelve a ejecutar. Cuando la condicin no se cumple, el bucle termina.
for (int i=0; i<20; i++) // declara i, prueba que es menor que 20, incrementa i en 1 { digitalWrite(13, HIGH); //enva un 1 al pin 13 delay(250); //espera seg. digitalWrite(13, LOW); //enva un 0 al pin 13 delay(250); //espera seg. }

7.4.- While
Un bucle del tipo while es un bucle de ejecucin continua mientras se cumpla la expresin colocada entre parntesis en la cabecera del bucle. La variable de prueba tendr que cambiar para salir del bucle. La situacin podr cambiar a expensas de una expresin dentro el cdigo del bucle por el cambio de un valor en una entrada.
While (unaVariable < 200) { Instrucciones; unaVariable++; }

Pgina 9 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
7.5.- do while
El bucle do while funciona de la misma manera que el bucle while, con salvedad de que la condicin se prueba al final del bucle, por lo que el bucle siempre se ejecutara al menos una vez.
Do { Instrucciones; } While (unaVariable ?? valor);

8.- Variables especiales

Este tipo de variables se utilizan en muchos casos para poder asignar valores analgicos o para hacer un men de opciones dependiendo de una entrada dada.

8.1.-Arrays[ ]
Un array es un conjunto de valores a los que se accede con un nmero ndice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el nmero 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 de la posicin 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada posicin antes de ser utilizado.
int miarray[] = {valor0, valor1, valor2,.}

Del mismo modo es posible declarar una matriz indicado el tipo de datos y tamaos y posteriormente, asignar a una posicin especifica:
int miarray[5]; //declara un array de enteros de 6 posiciones miarray[5]; //asigna 1 valor 10 a la posicin 4

Para leer de un array basta con escribir el nombre y la posicin a leer:

X = miarray[3]; //x ahora es igual a 10 que esta en la posicin 3 del array

8.2.-String
Este comando nos ayuda a ser cadenas de caracteres, para poder enviarlos de forma serial a un eslabn de caracteres de la forma siguiente.
Int val = 50; //asignamos el valor de 50 a la variable val String cad = SEV1WSA; //hacemos una cadena de SEV1WSA String cad2 = cad + val; //encadenamos cad + val Serial.println (cad2); //mostramos la cadena en pantalla SEV1SA50

8.3.- map()
Este comando nos permite hacer reducciones de valores a otros por ejemplo un valor analgico de 0 a 1020 podemos escalarlo a un valor de 0 a 180 para poderlo usar mas fcilmente.
Pgina 10 de 34 www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
Int val (val,0,1020,0,180); // escalamos un rango de 0,1020 a 0,180 y lo almacenamos en val

8.4.- switch (range)

El estamento switch nos da a escoger entre diferentes opciones dependiendo el rango de entrada.
switch (range) //selecciona el caso a aplicar dependiendo el numero de rango { case 0: //caso 1 Estamento; break; //termina el estamento switch case 1: Estamento; break; }

9.- Comunicacin Serie

Para hacer que dos dispositivos se comuniquen necesitamos un mtodo de comunicacin y un lenguaje o protocolo comn entre ambos dispositivos. La forma ms comn de establecer dicha comunicacin es utilizando la comunicacin serie. La comunicacin serie consiste en la transmisin y recepcin de pulsos digitales, a una misma velocidad. El transmisor enva pulsos que representan el dato enviado a una velocidad determinada, y el receptor escucha dichos pulsos a esa misma velocidad. Esta tcnica es conocida como comunicacin serie asncrona. Un caso prctico es el de un MODEM externo conectado a un PC. Por ejemplo, si tenemos dos dispositivos conectados y que intercambian datos a una velocidad de 9600 bits por segundo (tambin llamados baudios), el receptor capturar el voltaje que le est enviando el transmisor, y cada 1/9600 de un segundo, interpretar dicho voltaje como un nuevo bit de datos. Si el voltaje tiene valor HIGH (+5v en la comunicacin con Arduino), interpretar el dato como 1, y si tiene valor LOW (0v), interpretar el dato como 0. De esta forma, interpretando una secuencia de bits de datos, el receptor puede obtener el mensaje transmitido. Los dispositivos electrnicos usan nmeros para representar en bytes caracteres alfanumricos (letras y nmeros). Para ello se utiliza el cdigo estndar llamado ASCII (enlace), el cual asigna a cada nmero o letra el valor de un byte comprendido entre el rango de 0 a 127 ?. El cdigo ASCII es utilizado en la mayora de los dispositivos como parte de su protocolo de comunicaciones serie.

9.1.-Serial.begin(rate)
Abre el puerto serie y fija la velocidad en baudios para la transmisin de datos en serie. El valor tpico de velocidad para comunicarse con el ordenador es 9600, aunque otras velocidades pueden ser soportadas.
Void setup() {

Pgina 11 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
Serial.begin(9600); //abre el puerto serie y configura la velocidad en 9600 bps }

Nota: Cuando se utiliza la comunicacin serie los pins digitales 0 (RX) y 1 (TX) no puede utilizar al mismo tiempo.

9.2.- Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro automtico y salto de lnea. Este comando toma las misma forma que serial.print(), pero es mas fcil para la lectura de los datos monitor serie del software.

9.3.-Serial.println(data, data type)

Vuelca o enva un nmero o una cadena de caracteres al puerto serie, seguido de un carcter de retorno de carro CR y un carcter de salto de lnea LF. Toma la misma forma que el comando Serial.print(). Serial.println(b) : Vuelca o enva el valor de b como un nmero decimal en caracteres ASCII seguido de CR LF. Serial.println(b, DEC) :Vuelca o enva el valor de b como un nmero decimal en caracteres ASCII seguido de CR LF. Serial.println(b, HEX) :Vuelca o enva el valor de b como un nmero hexadecimal en caracteres ASCII seguido de CR LF. Serial.println(b, OCT) :Vuelca o enva el valor de b como un nmero octal en caracteres ASCII seguido de CR LF. Serial.println(b, BIN) :Vuelca o enva el valor de b como un nmero binario en caracteres ASCII seguido de CR LF. Serial.println(b, BYTE) :Vuelca o enva el valor de b como un byte seguido de CR LF. Serial.println(b, str) :Vuelca o enva la cadena de caracteres como una cadena ASCII seguido de CR y LF.

9.4.- Serial.print(data, data type)

Vuelca o enva un nmero o cadena de caracteres, al Puerto serie. Dicho comando puede tomar diferentes formas, dependiendo de los parmetros que utilicemos para definir el formato de volcado de los nmeros.

9.5.- Serial.avaible()
Obtiene un nmero entero con el nmero de bytes disponibles para leer o capturar desde el puerto serie. Equivaldra a la funcin serialAvailable(). Devuelve un entero con el nmero de bytes disponibles para leer el buffer serie, o 0 si no hay ninguno. Si hay algn dato disponible, SerialAvailable() ser mayor que 0. El buffer puede almacenar como mximo 64 bytes.

Pgina 12 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
9.6.- Serial.Read()
Lee o captura un byte desde el puerto serie.
int incomingByte = 0 // almacena el dato serie void setup() { Serial.begin(9600); } Void loop() { If (Serial.available() > 0) // enva datos solo si los recibe { incomingByte = Serial.read(); //lee el byte de entrada Serial.print(Recivido:); // lo vuelca a pantalla Serial.println(incomingbyte,DEC); } }

10.- Subrutinas
Las subrutinas son partes del programa que fasilitan el acomodo y la limpiesa del programa a realizar ya que solo es necesario ordenarlas dentro de su propio void y llamarlas cuando sea necesario. Un buen programa siempre lleva subrutinas para el mejor entendimiento del programa.
Void setup() { Estamentos; Limpiando_LCD() //llama a la subrutina limpiando LCD } Void loop() { Limpiando_LCD() //llama a la rutina limpiando LCD } Void Limpiando_LCD() { Estamentos; al terminar la rutina regresa al lugar donde fue llamada }

11.- Comunicacin Arduino y mdulos PyC

Para poder comunicar el Arduino con algn mdulo PyC es necesario conectar las entradas de comunicacin serie Tx y Rx, y en el programa en el setup activar la comunicacin serial mediante el siguiente comando.
void setup() { Serial.begin(9600); // activa la comunicacin serial a 9600 bps }

Para una comunicacin rpido con algn modulo es necesario usar el comando Serial.println(Comando del modulo). A continuacin exponemos un ejemplo en el cual se utiliza cada uno de los mdulos PyC existentes hasta ahora.

Pgina 13 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
void setup() { Serial.begin(9600); // Inicializamos el puerto Serie a 9600 Baudios ya que los mdulos estn configurados inicialmente a esa velocidad. delay(500); // delay de .5s. LIMPIANDO_DISPLAY(); //llama la subrutina para limpiar la LCD. SALVAR_CONFIGURACION(); //llama a la configuracin de los servos. Serial.println("MOT0CFQ4"); //configure la frecuencia de los motores de CD. Serial.println("STP0CFQ1"); //configure la frecuencia del motor a pasos. } void loop() { delay(1500); Serial.println("SEV1WSD0,SE0,SF0"); //enva los servos D,E y F a 0 . Serial.println("_LCDCCD"); //limpia la LCD. Serial.println("_LCDW02SD=0 SE=0"); //enva a la LCD la posicin de los servos en la lnea 1. Serial.println("_LCDW44SF=0"); //enva a la LCD la posicin de los servos en la lnea 2. delay(2000); Serial.println("MOT0WR1100,R2100"); //enciende los motores de cd a 100% de su velocidad y que se muevan a la derecha. Serial.println("_LCDCCD"); Serial.println("_LCDW00Motor 1=100 Der"); Serial.println("_LCDW40Motor 2=100 Der"); delay(2000); Serial.println("SEV1WSD180,SE180,SF180"); //mueve los servos a 180 . Serial.println("_LCDCCD"); Serial.println("_LCDW00SD=180 SE=180"); Serial.println("_LCDW44SF=180"); delay(2000); Serial.println("STP1WR150"); //mueve el motor a pasos 160 pasos Serial.println("_LCDCCD"); Serial.println("_LCDW00Pasos=50"); Serial.println("_LCDW40Sentido= Der"); delay(2000); Serial.println("SEV1WSD90,SE90,SF90"); //mueve los servos a 90 . Serial.println("_LCDCCD"); Serial.println("_LCDW00SD=90 SE=90"); Serial.println("_LCDW44SF=90"); delay(2000); Serial.println("MOT0WL1100,L2100"); //cambia el giro de los motores de dc y los mantiene a 100%. Serial.println("_LCDCCD"); Serial.println("_LCDW00Motor 1=100 Izq"); Serial.println("_LCDW40Motor 2=100 Izq"); delay(2000); Serial.println("SEV1WSD50,SE50,SF50"); //mueve los servos a 50 . Serial.println("_LCDCCD"); Serial.println("_LCDW00SD=50 SE=50"); Serial.println("_LCDW44SF=50"); delay(2000); Serial.println("STP1WL150"); //mueve el stepper a 150 pasos. Serial.println("_LCDCCD"); Serial.println("_LCDW00Pasos=50"); Serial.println("_LCDW40Sentido= Izq"); delay(2000); LIMPIANDO_DISPLAY(); //llama a la rutina limpiar LCD. }

Pgina 14 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
void LIMPIANDO_DISPLAY () //inicio de la subrutina de limpiar LCD. { delay(700); Serial.println("_LCDCCD"); //limpia LCD. Serial.println("_LCDW02BIENVENIDOS A "); //Enva el mensaje bienvenidos a a la LCD. Serial.println("_LCDW42LOS CURSOS PyC"); } void SALVAR_CONFIGURACION() //inicio de la subrutina de configuracin de los servos. { delay(500); Serial.println("SEV1CM18"); //establece el mnimo del primer conjunto de servos. Serial.println("SEV1CM28"); //establece el mnimo del segundo conjunto de servos. Serial.println("SEV1CD111"); //establece la diferencia del primer conjunto de servos. Serial.println("SEV1CD211"); //establece la diferencia del segundo conjunto de servos. Serial.println("SEV1CSC"); //salva la configuracin anterior de los servos. }

Pgina 15 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Ejemplos Unidad 5 Entradas y Salidas

5.1.- Activacin de seales Digitales.
Descripcin: En esta prctica veremos la forma de activar entradas y salidas digitales. Se utilizara lo siguiente: -Arduino con cable de conexin. -1 LED. -Protoboard. -Botn. -Cable. -2 Resistencia de 220 Ohms. Diagrama:

Programa:
int LED = 13; //nombra al LED como pin 13 int estBoton = 0; //variable para el estado del Led void setup() { pinMode (2,INPUT); //activa el pin 2 como entrada para el botn pinMode (LED,OUTPUT); //activa el LED como salida } void loop() { estBoton = digitalRead(2); //lee el estado del led if (estBoton == HIGH) //pregunta si esta activado el botn { digitalWrite(LED,HIGH); //si lo est prende el Led } if (estBoton == LOW) // pregunta si esta desactivado el botn { digitalWrite(LED,LOW); //si lo est apaga el LED } }

Pgina 16 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
5.2.- Contador de pulsos.
Descripcin: En esta prctica contaremos los pulsos enviados al Arduino mediante un pushbotton y al contar 5 veces encenderemos un led y al contar 8 veces el pulso el led se apagara. El material necesario para esta prctica es: -Arduino con cable de conexin. -1 LED. -Protoboard. -Botn. -Cable. Diagrama.

Programa.
int conta = 0; // variable q almacenara los pulsos del botn void setup() { Serial.begin(9600); //activa la comunicacin serial pinMode(2,INPUT); //activa el pin 2 como entrada pinMode(13,OUTPUT); //activa el pin 13 como salida } void loop() { if (digitalRead(2) == HIGH) //Pregunta si el botn esta activado { if (digitalRead(2) == LOW) //Pregunta si el botn esta desactivado //esto para asegurar que se presione 1 vez el botn { conta++; //aumenta en 1 el conteo Serial.println(conta); //lo muestra en el monitor serial de Arduino delay(100); //delay de .1 seg } } if (conta == 5) //si el contador es igual a 5 enciende el Led { digitalWrite(13,HIGH); } if (conta == 8) //si el contador es igual a 8 apaga el Led { digitalWrite(13,LOW); } }

Pgina 17 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
5.3.- Activacin de una entrada analgica.
Descripcin: En esta prctica activaremos una entrada analgica para variar el delay de parpadeo de un led como si fuera un pwm. El material necesario para esta prctica es el siguiente: -Arduino con cable de conexin. -1 LED. -Protoboard. -Potencimetro 10K Ohms. -Cable. -Resistencia de 220 Ohms. Diagrama:

Programa:
int Pot = A0; //variable del potencimetro analgico int Led = 13; // variable para el Led int valPot = 0; //variable para el almacenamiento del potencimetro void setup() { pinMode(Led, OUTPUT); // activa el pin del led como salida } void loop() { valPot = analogRead(Pot); //lee lo que hay en la entrada del potencimetro y lo almacena en su variable digitalWrite(Led, HIGH); // enciende el led. delay(valPot); //delay variable dependiendo del potencimetro digitalWrite(Led, LOW); //apaga el led delay(valPot); }

Pgina 18 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
5.4.- Barra de Leds.
Descripcin: Enciende una barra de leds consecutivos que prenderan dependiendo el valor del potencimetro. El material requerido es el siguiente: -Arduino con cable de conexin. - Leds al gusto. -Protoboard. -Potencimetro 10K Ohms. -Cable. -Resistencias de 220 Ohms al gusto. Diagrama:

Programa:
int pot = A0; // entrada analgica del potencimetro int ledCont = 8; // numero de leds int ledPins[] = { 2, 3, 4, 5, 6, 7,8,9 }; // un array para escoger el numero de led void setup() { for (int Led = 1; Led < ledCont; Led++) // Activa los pins de los LEDs como salida { pinMode(ledPins[Led], OUTPUT); } } void loop() { int valp = analogRead(pot); // Lee el valor del potencimetro int ledLevel = map(valp, 0, 1023, 0, ledCont); //escala el resultado a un valor entre 0 al nmero de Led for (int Led = 0; Led < ledCont; Led++) { if (Led < ledLevel) //enciende los leds menores al nivel del potencimetro { digitalWrite(ledPins[Led], HIGH); } else //apaga los leds mayores al valor del potencimetro { digitalWrite(ledPins[Led], LOW); } } }

Pgina 19 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Unidad 7 Condicionales

7.1.- Encender/Apagar el LED de forma proporcional.
Descripcin: En esta prctica mediante una seal PWM controlaremos la intensidad de un LED utilizando comparadores lgicos. El material necesario es: -1 R. 220 ohms. -1 LED. -Arduino. -Protoboard. Diagrama:

Programa:
int brillo = 0; int variacion = 5; int led =9; void setup() { pinMode(led, OUTPUT); //deja al pin 9 como salida } void loop() { analogWrite(led, brillo); brillo = brillo + variacion; // incrementa el brillo de 5 en 5 if(brillo == 0 || brillo == 255) { variacion= -variacion; // la variacin se vuelve negativa } delay(30); }

Pgina 20 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
7.2.- Control Analgico
Descripcin: En esta prctica controlaremos mediante potencimetros la salida analgica del Arduino para da un ejemplo de como obtener el control de un PWM para diferentes usos. Sera necesario para la elaboracin de esta prctica lo siguiente: -3 Potencimetros. -3 LEDs. -3 R. 220 Ohms. -Arduino. -Protoboard. Diagrama:

Programa:
int brillo0= (A0); int brillo1= (A1); int brillo2= (A2); void setup() { //configuramos los pines de pwm como salida pinMode(3, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); } void loop() { int val0=analogRead(brillo0); val0=map(val0, 0, 1020, 0, 255); //se elige la escala del pwm analogWrite(3,val0); //escribimos valor de pwm con el pot delay(50); int val1= analogRead(brillo1); val1=map(val1, 0, 1020, 0, 255); analogWrite(5,val1); delay(50); int val2= analogRead(brillo2); val2=map(val2, 0, 1020, 0, 255); analogWrite(6,val2); delay(50); }

Pgina 21 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Unidad 8 Variables Especiales

8.1.- String
Descripcin: En esta prctica se ver el uso del comando String mediante el serial monitor de Arduino. El material a usar en esta prctica es el siguiente: -Potencimetro de 10K ohms. -Arduino. -Protoboard. Diagrama:

Programa:
int pot = A0; int val = 0; int com = 0; void setup() { Serial.begin(9600); } void loop() { val = analogRead (pot); val = map(val, 0,1020, 0,100); if (val != com) //pregunta si son diferentes los valores de antes y despus del pot para mostrarlo sin repetir nmeros. { String cad = "Valor del Potencimetro:"; //se pone el valor de la primera cadena. String cad2 = cad + val; //encadena los 2 valores. com = val; Serial.println(cad2); //muestra la cadena final en el monitor. } }

Pgina 22 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
8.2-Contador Binario
Descripcin: En esta prctica utilizaremos un botn para ir contando de 0 a 16, y mediante el comando switch ir desplegando en la salida con 4 leds el nmero binario correspondiente. El material Utilizado es el siguiente: -4 Leds. -4 R. de 220 ohms. -Botn. -1 R. de 10K ohms. -1 Protoboard. -Arduino. Diagrama:

Programa:
//definimos las variables a utilizar int conta = -1; int accion; int ledPins[] = {3,4,5,6}; int ledCont = 7; void setup() { for (int Led = 3; Led < ledCont; Led++) //Activa los pins de los LED como salida { pinMode(ledPins[Led], OUTPUT); } pinMode (2,INPUT); Serial.begin(9600); } void loop() { if (digitalRead(2) == HIGH) //Pregunta si el botn esta activado { if (digitalRead(2) == LOW) //Pregunta si el botn esta desactivado //esto para asegurar que se presione 1 vez el botn { conta++; //aumenta en 1 el conteo Serial.println(conta); //lo muestra en el monitor serial de Arduino delay(50); //delay de .05 seg } } int rango= conta; //carga el valor de rango

switch (rango) //escoge una accin a realizar dependiendo del valor del contador { case 0: //pone en 0 binario la salida digitalWrite (3,LOW); digitalWrite (4,LOW);

Pgina 23 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
digitalWrite (5,LOW); digitalWrite (6,LOW); break; //termina switch y regresa al bucle case 1: //pone en 1 binario la salida digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,LOW); digitalWrite (6,LOW); break; case 2: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,LOW); break; case 3: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,LOW); break; case 4: digitalWrite (3,LOW); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,LOW); break; case 5: digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,LOW); break; case 6: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,HIGH); digitalWrite (6,LOW); break; case 7: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,HIGH); digitalWrite (6,LOW); break; case 8: digitalWrite (3,LOW); digitalWrite (4,LOW); digitalWrite (5,LOW); digitalWrite (6,HIGH); break; digitalWrite (4,LOW); digitalWrite (5,LOW); digitalWrite (6,HIGH); break; case 10: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,HIGH); break; case 11: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,HIGH); break; case 12: digitalWrite (3,LOW); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break; case 13: digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break; case 14: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break; case 15: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break; case 16: //reinicia el valor del contador para volver a iniciar. conta = -1; break; } }

case 9: digitalWrite (3,HIGH);

Pgina 24 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Unidad 9 Comunicacin Serie.

9.1.- Escritura analgica.
Descripcin: En esta prctica se ver la forma de escribir mediante la computadora para comunicarse con el Arduino. Los materiales necesarios para la prctica son: -Arduino. -1 Led. Diagrama:

Programa:
int led =13; char leer; //variable para la letra de lectura en carcter. boolean prendido = false; //bandera de estado del LED. void setup() { Serial.begin(9600); pinMode(led,INPUT); } void loop() { leer = Serial.read(); if ((leer == 'a') && (prendido == false)) //pregunta si hay una 'a' en el teclado y el valor de la bandera. { digitalWrite(led,HIGH); //prende el led. prendido = true; //cambia la bandera a 1. } else if ((leer == 'a') && (prendido == true)) { digitalWrite(led,LOW); //apaga el led. prendido = false; //cambia la bandera a 0. } }

Pgina 25 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Unidad 11 Comunicacin Arduino y mdulos PyC

11.1.- Comunicacin Servo.
Descripcin: La practica est basada en la comunicacin serie para poder controlar un servomotor mediante el modulo de Servo v1.0 de PyC. El material necesario para realizar la prctica es el siguiente: -Modulo Servos v1.0 -Arduino. -Protoboard. -Botn. -1 R. de 10K Ohms. -Servomotor. -Fuente externa. Diagrama:

Programa:
int boton = 2; void setup() { pinMode(boton,INPUT); Serial.begin(9600); // inicializa la comunicacin serie. Serial.println("SEV1CM112"); //define mnimo del modulo. Serial.println("SEV1CD18"); //define diferencia del modulo. } void loop() { int condicion = digitalRead(boton); if(condicion ==1) { Serial.println("SEV1WSA180"); //mueve el servo a 180 . } else { Serial.println("SEV1WSA10"); //mueve el servo a 10 . } }

Pgina 26 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
11.2.- Servo potencimetro
Descripcin: En esta prctica se ver el control de un servo motor por medio de un potencimetro y utilizando el modulo de servos v1.0 de PyC. Es necesario tener lo siguiente: -Servomotor. -Arduino. -Potencimetro. -Protoboard. -Modulo Servo v1.0. -Alimentacin externa. Diagrama:

Programa:
void setup() { Serial.begin(9600); Serial.println("SEV1CM112"); Serial.println("SEV1CD18"); } void loop() { int val = analogRead(A0); val = map(val,0,1023,0,179); String cad= "SEV1WSA"; String cad2= cad + val; Serial.println(cad2); delay(500); }

Pgina 27 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
11.3.- Servo Switch
Descripcin: Se reforzara el comando switch mediante esta prctica para poder mover un servomotor en 3 diferentes grados mediante un solo botn. El material necesario es el siguiente: -Modulo Servo v1.0 -Arduino. -Protoboard. -Botn. -1 R. de 10K Ohms. -Servomotor. Diagrama:

Programa:
int val=0; void setup() { pinMode (2,INPUT); Serial.begin(9600); Serial.println("SEV1CM112"); Serial.println("SEV1CD18"); } void loop() { if(digitalRead(2) == HIGH) { if (digitalRead(2) == LOW) { val++; Serial.println(val); delay(100); } } else { switch (val) { case 0: Serial.println("SEV1WSA0"); break; case 1: Serial.println("SEV1WSA60"); break; case 2: Serial.println("SEV1WSA120"); break; case 3: Serial.println("SEV1WSA180"); break; case 4: val = 0; break; } } }

Pgina 28 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO 11.4.- Modulo de Pasos

Descripcin: En esta prctica se mostrara como controlar el motor a pasos con 2 botones para moverlo 1 paso a la vez en ambos sentidos. El material necesario es el siguiente: -Modulo Stepper v1.0 -Arduino. -2 botones. -Protoboard. -2 R. de 10K Ohms. -Motor a pasos. Diagrama:

Programa:
int bot1 = 2; int bot2 = 3; int val1; int val2; void setup() { Serial.begin(9600); pinMode(bot1,INPUT); pinMode(bot2,INPUT); Serial.println("STP0CFQ3"); } void loop() { } val1 = digitalRead(bot1); val2 = digitalRead(bot2); if ((val1 == HIGH) && (val2 == LOW)) { Serial.println("STP0WR11"); delay(500); } if ((val1 == LOW) && (val2 == HIGH)) { Serial.println("STP0WL11"); delay(500); }

Pgina 29 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
11.5.- Modulo de LCD
Descripcin: Se demostrara el uso del modulo de LCD y lo fcil que es utilizarla con el modulo de LCD de PyC. Se requiere el siguiente material: -LCD. -Modulo adaptador para LCD serie v1.0 -Arduino. -Potencimetro. -Protoboard. Diagrama:

Programa:
void setup () { Serial.begin(9600); Limpiar_LCD(); //llama a subrutina. } void loop () { int val = analogRead(A0); val = map(val, 0,1020, 0,100); String cad = ("_LCDW05"); //posiciona el cursor en el lugar 05 de la LCD. String cad2 = ("% "); //unidad del valor String cad3 = cad + val + cad2; delay(100); Serial.println(cad3); } void Limpiar_LCD() //subrutina de limpiado de LCD. { delay(100); Serial.println("_LCDCCD"); Serial.println("_LCDW00Pot= "); }

Pgina 30 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO Anexos

Palabras reservadas del IDE de Arduino
Estas palabras son constante, variables y funciones que se definen en el lenguaje de programacin de Arduino. No se deben usar estas palabras clave para nombres de variables. # Constantes HIGH LOW INPUT OUTPUT SERIAL DISPLAY PI HALF_PI TWO_PI LSBFIRST MSBFIRST CHANGE FALLING RISING false true null # Variables de designacion de puertos y constantes DDRB PINB PORTB PB0 PB1 PB2 PB3 PB4 PB5 PB6 PB7 DDRC PINC PORTC PC0 PC1 PC2 private protected public return short signed static switch throw try unsigned void # Other abs acos += + [] asin = atan atan2 & | boolean byte case ceil char char class , // ?: constrain cos {} -default delay loop max
Pgina 31 de 34

millis min % /* * new null () PI return >> ; Serial Setup sin sq sqrt -= switch tan this true TWO_PI void while Serial begin read print write println available digitalWrite digitalRead pinMode analogRead analogWrite attachInterrupts detachInterrupts PC4
www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
PC5 PC6 PC7 DDRD PIND PORTD PD0 PD1 PD2 PD3 PD4 PD5 PD6 PD7 # Tipos de datos boolean byte char class default do double int long delayMicroseconds / /** . else == exp false float float floor for < <= HALF_PI if ++ != int << < <= log && ! || beginSerial serialWrite serialRead serialAvailable printString printInteger printByte printHex printOctal printBinary printNewline pulseIn shiftOut

Pgina 32 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011

MANUAL DE ARDUINO
Programa para obtener los valores mximos de una entrada analgica.
int val; void setup() { Serial.begin(9600); //active la comunicacin serial. } void loop() { val = analogRead(A0); // lectura analgica por la entrada A0. Serial.println(val); //despliega el valor en el monitor serial. }

Pgina 33 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011