Manual de Arduino

M NUAL DE

NTRODUCCI N:

LÓPEZ DE NAVA LÓPEZ DIEGO OROPEZA LÓPE IRWIN JESÚS

MANUAL DE ARDUINO Índice 1 2 3

4 5

6

7

8

9

10 11

Introducción Estructura de un programa Funciones Variables 3.1 delay () 3.2 milis () Aritméticas Entradas y salidas Digitales/Analógicas Digitales/ Analógicas 5.1 pinMode(pin, pinMode(pin , mode) 5.2 digitalRead(pin) digitalRe ad(pin) 5.3 digitalWrite(pin, digitalWrite(pin, value) 5.4 analogRead(pin) analogRead(pi n) 5.5 analogWrite(pin, analogWrite (pin, value) Constantes 6.1 (TRUE/FALSE) 6.2 HIGH/LOW 6.3 INPUT/OUTPUT Condicionales Condicionales 7.1 if () 7.2 if … else () 7.3 for() 7.4 while() 7.5 do …… while()

Variables especiales 8.1 Arrays[] 8.2 String 8.3 map() 8.4 switch (range) Comunicación Serie 9.1 Serial.begin(rate) Serial.begin( rate) 9.2 Serial.println(data) Serial.pri ntln(data) 9.3 Serial.printnl(data, Serial.pri ntnl(data, data type) 9.4 Serial.print(data, Serial.pri nt(data, data type) 9.5 Serial.avaible() Serial.avaib le() 9.6 Serial.Read() Serial.Read () Subrutinas Comunicación Arduino y módulos PyC

Ejemplos Unidad 5 Entradas y Salidas 5.1 5.2 5.3 5.4

Activación de señales Digitales Contador de pulsos Activación de una entrada analógica Barra de Leds

Página 1 de 34

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

www.ingenieriaenserie.com Marzo 2012 –DCI0011

MANUAL DE ARDUINO Índice 1 2 3

4 5

6

7

8

9

10 11

Introducción Estructura de un programa Funciones Variables 3.1 delay () 3.2 milis () Aritméticas Entradas y salidas Digitales/Analógicas Digitales/ Analógicas 5.1 pinMode(pin, pinMode(pin , mode) 5.2 digitalRead(pin) digitalRe ad(pin) 5.3 digitalWrite(pin, digitalWrite(pin, value) 5.4 analogRead(pin) analogRead(pi n) 5.5 analogWrite(pin, analogWrite (pin, value) Constantes 6.1 (TRUE/FALSE) 6.2 HIGH/LOW 6.3 INPUT/OUTPUT Condicionales Condicionales 7.1 if () 7.2 if … else () 7.3 for() 7.4 while() 7.5 do …… while()

Variables especiales 8.1 Arrays[] 8.2 String 8.3 map() 8.4 switch (range) Comunicación Serie 9.1 Serial.begin(rate) Serial.begin( rate) 9.2 Serial.println(data) Serial.pri ntln(data) 9.3 Serial.printnl(data, Serial.pri ntnl(data, data type) 9.4 Serial.print(data, Serial.pri nt(data, data type) 9.5 Serial.avaible() Serial.avaib le() 9.6 Serial.Read() Serial.Read () Subrutinas Comunicación Arduino y módulos PyC

Ejemplos Unidad 5 Entradas y Salidas 5.1 5.2 5.3 5.4

Activación de señales Digitales Contador de pulsos Activación de una entrada analógica Barra de Leds

Página 1 de 34

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


MANUAL DE ARDUINO Unidad 7 Condicionales 7.1 7.2

Encender/Apagar el LED de forma proporcional Control Analógico

21 22

8.1 8.2

String Contador Binario

23 24

9.1

Escritura analógica

26

11.1 11.2 11.3 11.4 11.5

Comunicación Servo Servo potenciómetro Servo Switch Modulo de Pasos Modulo de LCD

27 28 29 30 31

Unidad 8 Variables Especiales Unidad 9 Comunicación Serie

Unidad 11 Comunicación Arduino y módulos PyC

Anexos Palabras reservadas del IDE de Arduino Programa para obtener los valores máximos de una entrada analógica

Página 2 de 34

32 34


MANUAL DE ARDUINO INTRODUCCIÓN Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica 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 máximo 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 comunicación USB. También tiene 6 entradas analógicas que proporcionan una resolución de 10 bits. Por defecto miden de 0 hasta 5 voltios, aunque es posible cambiar el nivel más alto, utilizando el pin Aref y algún código de bajo nivel.

Arduino UNO R3

Página 3 de 34


MANUAL DE ARDUINO 1.- Estructura de un programa en Arduino. La estructura básica del lenguaje de programación 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 configuración y loop() es la que contiene el programa que se ejecutara cíclicamente (de ahí el término loop –bucle-). Ambas instrucciones son necesarias para que el programa trabaje. La función de configuración debe contener la declaración de las variables. Es la primera función ejecutar en el programa, se ejecuta una sola vez, y se utiliza para configurar o inicializar pinMode (modo de trabajo de las E/S), configuración de la comunicación en serie y otras. Debe ser incluido en un programa aunque no haya declaración que ejecutar. La función bucle (loop) siguiente contiene el código que se ejecutara continuamente. Esta función es el núcleo 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 función es un bloque de código que tiene un nombre y un conjunto de estamentos que son ejecutados cuando se llama a la función. Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. La función se declaran asociadas a un tipo de valor “type”. 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 dato entonces se colocara la palabra “voild”. 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.

Página 4 de 34


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 programación de Arduino. También se utiliza para separar elementos en una instrucción de tipo “bucle for”. Los bloques de comentarios son áreas de texto ignorados por el programa que se utilizan para descripciones del código o comentarios que ayuden a comprender el programa, comienzan con “/*” y termina en “*/”. Una línea de comentario se utiliza igualmente para poner comentario pero inicia con un “//” y termina con la siguiente línea de código. 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 numérico para su uso posterior por el programa. Como su nombre indica, las variables son números 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 analógico 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.), asignándoles 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 configuración 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 numérico 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 numérica de tipo extendido “long” se refiere a números enteros de 32 bits sin decimal que se encuentran dentro del rango -2,147,483,648 a 2,147,483,647. Página 5 de 34


MANUAL DE ARDUINO float: El formato de dato tipo “punto flotante” se aplica a los números con decimal. Tienen una resolución de 32 bits con rango comprendido 3.4028235E +38 a -3.402823E-38. int value; // ´value´ es visible para cualquier función 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 ejecución del programa por la cantidad de tiempo en ms que se indica en la propia instrucción. De tal manera que 1000 equivale a 1s.

3.2.- millis() Devuelve el número de ms transcurridos desde que inicio del programa Arduino hasta el momento actual, hasta un máximo de 9hr.

4.- Aritmética Los operadores aritméticos que se incluyen en el entorno de programación son: suma, resta, multiplicación y división. Estos devuelven la operación de 2 operandos. Las asignaciones compuestas combinan una operación aritmética 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 condición 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 lógicos usualmente una forma de comparar dos expresiones y devolver un verdadero o falso dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||), y NOT (!), que a menudo se utiliza en estamentos de tipo if. Página 6 de 34


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 expresión es falsa

5.- Entradas y salidas Digitales/analógicas El Arduino tiene 13 I/O digitales y 6 entradas analógicas las cuales pueden ser activadas mediante el programa dependiendo su función específica. A continuación se conocerá la forma de activarlas.

5.1.- pinMode(pin, mode) Esta instrucción es utilizada en la parte de configuración setup() y sirve para configurar el modo de trabajo de un PIN pudiendo 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) Envía 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 analógico con una resolución de 10 bits. Esta instrucción solo funciona en los pines (0-5). El rando de valor que podemos leer oscila de 0 a 1023. valor = analogRead(pin);

Página 7 de 34


MANUAL DE ARDUINO 5.5.- analogWrite(pin, value) Esta instrucción sirve para escribir un pseudo-valor analógico utilizado el procedimiento de modulación por ancho de pulso (PWM) a uno de los pin de Arduino marcados como “pin PWM”.

6.- Constantes El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan para hacer los programas fáciles 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 también puede ser cualquiera otra cosa excepto 0.Por lo tanto, en sentido booleano, -1, 2 y -200 también 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 lógica de nivel 1, ON (5V), mientras que LOW es la lógica 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 instrucción pinMode de tal manera que el pin puede ser entrada o salida.

7.- Condicionales Estos estamentos se usan frecuentemente en la programación del Arduino y sirven principalmente para preguntar o validar una acción.

7.1.- if ()

if es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, mientras la condición 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; }

Página 8 de 34


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 expresión 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 { InstrucciónA; //ejecuta si se cumple la condición } Else { InstrucciónB; //ejecuta si no se cumple la condición }

7.3.- for Esta declaración se usa para repetir un bloque de sentencias entre llaves un número determinado de veces. Cada vez que se ejecute la instrucción del bucle se vuelve a testear la condición. For (inicialización; condición; expresión) { ejecutaInstrucción; }

La inicialización de una variable local se ejecuta una sola vez y la condición se testea cada vez se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, la instrucción dentro del bucle se vuelve a ejecutar. Cuando la condición 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); //envía un 1 al pin 13 delay(250); //espera ¼seg. digitalWrite(13, LOW); //envía un 0 al pin 13 delay(250); //espera ¼seg. }

7.4.- While Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle por el cambio de un valor en una entrada. While (unaVariable < 200) { Instrucciones; unaVariable++; }

Página 9 de 34


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 condición 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 analógicos 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 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 de la posición 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado. int miarray[] = {valor0, valor1, valor2,….}

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

Para leer de un array basta con escribir el nombre y la posición a leer: X = miarray[3]; //x ahora es igual a 10 que esta en la posición 3 del array

8.2.-String Este comando nos ayuda a ser cadenas de caracteres, para poder enviarlos de forma serial a un eslabón 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 analógico de 0 a 1020 podemos escalarlo a un valor de 0 a 180 para poderlo usar mas fácilmente. Página 10 de 34


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.- Comunicación Serie Para hacer que dos dispositivos se comuniquen necesitamos un método de comunicación y un lenguaje o protocolo común entre ambos dispositivos. La forma más común de establecer dicha comunicación es utilizando la comunicación serie. La comunicación serie consiste en la transmisión y recepción de pulsos digitales, a una misma velocidad. El transmisor envía pulsos que representan el dato enviado a una velocidad determinada, y el receptor escucha dichos pulsos a esa misma velocidad. Esta técnica es conocida como comunicación serie asíncrona. Un caso práctico 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 (también 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 comunicación 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 electrónicos usan números para representar en bytes caracteres alfanuméricos (letras y números). Para ello se utiliza el código estándar llamado ASCII (enlace), el cual asigna a cada número o letra el valor de un byte comprendido entre el rango de 0 a 127 ¿?. El código ASCII es utilizado en la mayoría 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 transmisión de datos en serie. El valor típico de velocidad para comunicarse con el ordenador es 9600, aunque otras velocidades pueden ser soportadas. Void setup() {

Página 11 de 34


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

Nota: Cuando se utiliza la comunicación 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 automático y salto de línea. Este comando toma las misma forma que serial.print(), pero es mas fácil para la lectura de los datos monitor serie del software.

9.3.-Serial.println(data, data type) Vuelca o envía un número o una cadena de caracteres al puerto serie, seguido de un carácter de retorno de carro “CR” y un carácter de salto de línea “LF”. Toma la misma forma que el comando Serial.print().

Serial.println(b) : Vuelca o envía el valor de b como un número decimal en caracteres ASCII seguido de “CR” “LF”. Serial.println(b, DEC) : Vuelca o envía el valor de b como un número decimal en caracteres ASCII seguido de “CR” “LF”. Serial.println(b, HEX) : Vuelca o envía el valor de b como un número hexadecimal en caracteres ASCII seguido de “CR” “LF”. Serial.println(b, OCT) : Vuelca o envía el valor de b como un número octal en caracteres ASCII seguido de “CR” “LF”. Serial.println(b, BIN) : Vuelca o envía el valor de b como un número binario en caracteres ASCII seguido de “CR” “LF”. Serial.println(b, BYTE) : Vuelca o envía el valor de b como un byte seguido de “CR” “LF”. Serial.println(b, str) : Vuelca o envía la cadena de caracteres como una cadena ASCII seguido de “CR” y “LF”.

9.4.- Serial.print(data, data type) Vuelca o envía un número o cadena de caracteres, al Puerto serie. Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que utilicemos para definir el formato de volcado de los números.

9.5.- Serial.avaible() Obtiene un número entero con el número de bytes disponibles para leer o capturar desde el puerto serie. Equivaldría a la función serialAvailable(). Devuelve un entero con el número de bytes disponibles para leer el buffer serie, o 0 si no hay ninguno. Si hay algún dato disponible, SerialAvailable() será mayor que 0. El buffer puede almacenar como máximo 64 bytes.

Página 12 de 34


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) // envía 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.- Comunicación Arduino y módulos PyC Para poder comunicar el Arduino con algún módulo PyC es necesario conectar las entradas de comunicación serie Tx y Rx, y en el programa en el setup activar la comunicación serial mediante el siguiente comando. void setup() { Serial.begin(9600); // activa la comunicación serial a 9600 bps }

Para una comunicación rápido con algún modulo es necesario usar el comando Serial.println(“Comando del modulo”). A continuación exponemos un ejemplo en el cual se utiliza cada uno de los módulos PyC existentes hasta ahora.

Página 13 de 34


MANUAL DE ARDUINO void setup() { Serial.begin(9600 ); // Inicializamos el puerto Serie a 9600 Baudios ya que los módulos están configurados inicialmente a esa velocidad. delay(500); // delay de .5s. LIMPIANDO_DISPLAY(); //llama la subrutina para limpiar la LCD. SALVAR_CONFIGURACION(); //llama a la configuración 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"); //envía los servos D,E y F a 0° . Serial.println("_LCDCCD"); //limpia la LCD. Serial.println("_LCDW02SD=0 SE=0"); //envía a la LCD la posición de los servos en la línea 1. Serial.println("_LCDW44SF=0"); //envía a la LCD la posición de los servos en la línea 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. }

Página 14 de 34


MANUAL DE ARDUINO void LIMPIANDO_DISPLAY () //inicio de la subrutina de limpiar LCD. { delay(700); Serial.println("_LCDCCD"); //limpia LCD. Serial.println("_LCDW02BIENVENIDOS A "); //Envía el mensaje “bienvenidos a” a la LCD. Serial.println("_LCDW42LOS CURSOS PyC"); } void SALVAR_CONFIGURACION() //inicio de la subrutina de configuración de los servos. { delay(500); Serial.println("SEV1CM18"); //establece el mínimo del primer conjunto de servos. Serial.println("SEV1CM28"); //establece el mínimo 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 configuración anterior de los servos. }

Página 15 de 34


MANUAL DE ARDUINO Ejemplos Unidad 5 Entradas y Salidas 5.1.- Activación de señales Digitales.

Descripción: En esta práctica veremos la forma de activar entradas y salidas digitales. Se utilizara lo siguiente: -Arduino con cable de conexión. -1 LED. -Protoboard. -Botón. -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 botón 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 botón { digitalWrite(LED,HIGH); //si lo está prende el Led } if (estBoton == LOW) // pregunta si esta desactivado el botón { digitalWrite(LED,LOW); //si lo está apaga el LED } }

Página 16 de 34


MANUAL DE ARDUINO 5.2.- Contador de pulsos.

Descripción: En esta práctica 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 práctica es: -Arduino con cable de conexión. -1 LED. -Protoboard. -Botón. -Cable.

Diagrama.

Programa. int conta = 0; // variable q almacenara los pulsos del botón void setup() { Serial.begin(9600); //activa la comunicación serial pinMode(2,INPUT); //activa el pi n 2 como entrada pinMode(13,OUTPUT); //activa el pin 13 como salida } void loop() { if (digitalRead(2) == HIGH) //Pregunta si el botón esta activado { if (digitalRead(2) == LOW) //Pregunta si el botón esta desactivado //esto para asegurar que se presione 1 vez el botón { 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); } }

Página 17 de 34


MANUAL DE ARDUINO 5.3.- Activación de una entrada analógica.

Descripción: En esta práctica activaremos una entrada analógica para variar el delay de parpadeo de un led como si fuera un pwm. El material necesario para esta práctica es el siguiente: -Arduino con cable de conexión. -1 LED. -Protoboard. -Potenciómetro 10K Ohms. -Cable. -Resistencia de 220 Ohms.

Diagrama:

Programa: int Pot = A0; //variable del potenciómetro analógico int Led = 13; // variable para el Led int valPot = 0; //variable para el almacenamiento del potenciómetro 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 potenciómetro y lo almacena en su variable digitalWrite(Led, HIGH); // enciende el led. delay(valPot); //delay variable dependiendo del potenciómetro digitalWrite(Led, LOW); //apaga el led delay(valPot); }

Página 18 de 34


MANUAL DE ARDUINO 5.4.- Barra de Leds.

Descripción: Enciende una barra de leds consecutivos que prenderan dependiendo el valor del potenciómetro. El material requerido es el siguiente: -Arduino con cable de conexión. - Leds al gusto. -Protoboard. -Potenciómetro 10K Ohms. -Cable. -Resistencias de 220 Ohms al gusto.

Diagrama:

Programa: int pot = A0; // entrada analógica del potenciómetro 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 l os LEDs como salida { pinMode(ledPins[Led], OUTPUT); } } void loop() { int valp = analogRead(pot); // Lee el valor del potenciómetro int ledLevel = map(valp, 0, 1023, 0, ledCont); //escala el resultado a un valor entre 0 al número de Led for (int Led = 0; Led < ledCont; Led++) { if (Led < l edLevel) //enciende los leds menores al nivel del potenciómetro { digitalWrite(ledPins[Led], HIGH); } else //apaga los leds mayores al valor del potenciómetro { digitalWrite(ledPins[Led], LOW); } } }

Página 19 de 34


MANUAL DE ARDUINO Unidad 7 Condicionales 7.1.- Encender/Apagar el LED de forma proporcional.

Descripción: En esta práctica mediante una señal PWM controlaremos la intensidad de un LED utilizando comparadores lógicos. 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; // i ncrementa el brillo de 5 en 5 if(brillo == 0 || brillo == 255) { variacion= -variacion; // la variación se vuelve negativa } delay(30); }

Página 20 de 34


MANUAL DE ARDUINO 7.2.- Control Analógico

Descripción: En esta práctica controlaremos mediante potenciómetros la salida analógica del Arduino para da un ejemplo de como obtener el control de un PWM para diferentes usos. Sera necesario para la elaboración de esta práctica lo siguiente: -3 Potenciómetros. -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); }

Página 21 de 34


MANUAL DE ARDUINO Unidad 8 Variables Especiales 8.1.- String

Descripción: En esta práctica se verá el uso del comando String mediante el serial monitor de Arduino. El material a usar en esta práctica es el siguiente: -Potenciómetro 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 después del pot para mostrarlo sin repetir números. { String cad = "Valor del Potenciómetro:"; //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. } }

Página 22 de 34


MANUAL DE ARDUINO 8.2-Contador Binario

Descripción: En esta práctica utilizaremos un botón para ir contando de 0 a 16, y mediante el comando switch ir desplegando en la salida con 4 leds el número binario correspondiente. El material Utilizado es el siguiente: -4 Leds. -4 R. de 220 ohms. -Botón. -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;

//esto para asegurar que se presione 1 vez el botón { conta++; //aumenta en 1 el conteo Serial.println(conta); //lo muestra en el monitor serial de Arduino

void setup() { for (int Led = 3; Led < ledCont; Led++) //Activa los pins de los LED como salida

delay(50); //delay de .05 seg } } int rango= conta; //carga el valor de rango

{ pinMode(ledPins[Led], OUTPUT); } pinMode (2,INPUT); Serial.begin(9600); } void loop() { if (digitalRead(2) == HIGH) //Pregunta si el botón esta activado { if (digitalRead(2) == LOW) //Pregunta si el botón esta desactivado

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

Página 23 de 34


MANUAL DE ARDUINO digitalWrite (5,LOW); digitalWrite (6,LOW); break; //termina switch y regresa al bucle

digitalWrite (4,LOW); digitalWrite (5,LOW); digitalWrite (6,HIGH); break;

case 1: //pone en 1 binario la salida digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,LOW); digitalWrite (6,LOW); break;

case 10: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,HIGH); break;

case 2: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,LOW); break;

case 11: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,HIGH); break;

case 3: digitalWrite (3,HIGH); digitalWrite (4,HIGH); digitalWrite (5,LOW); digitalWrite (6,LOW); break;

case 12: digitalWrite (3,LOW); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break;

case 4: digitalWrite (3,LOW); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,LOW); break;

case 13: digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,HIGH); break;

case 5: digitalWrite (3,HIGH); digitalWrite (4,LOW); digitalWrite (5,HIGH); digitalWrite (6,LOW); break;

case 14: digitalWrite (3,LOW); digitalWrite (4,HIGH); digitalWrite (5,HIGH); digitalWrite (6,HIGH); 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;

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

Página 24 de 34


MANUAL DE ARDUINO Unidad 9 Comunicación Serie. 9.1.- Escritura analógica.

Descripción: En esta práctica se verá la forma de escribir mediante la computadora para comunicarse con el Arduino. Los materiales necesarios para la práctica son: -Arduino. -1 Led.

Diagrama:

Programa: int led =13; char leer; //variable para la l etra de lectura en carácter. 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. } }

Página 25 de 34


MANUAL DE ARDUINO Unidad 11 Comunicación Arduino y módulos PyC 11.1.- Comunicación Servo.

Descripción: La practica está basada en la comunicación serie para poder controlar un servomotor mediante el modulo de Servo v1.0 de PyC. El material necesario para realizar la práctica es el siguiente: -Modulo Servos v1.0 -Arduino. -Protoboard. -Botón. -1 R. de 10K Ohms. -Servomotor. -Fuente externa.

Diagrama:

Programa: int boton = 2; void setup() { pinMode(boton,INPUT); Serial.begin(9600); // inicializa la comunicación serie. Serial.println("SEV1CM112"); //define mínimo 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°. } }

Página 26 de 34


MANUAL DE ARDUINO 11.2.- Servo potenciómetro

Descripción: En esta práctica se verá el control de un servo motor por medio de un potenciómetro y utilizando el modulo de servos v1.0 de PyC. Es necesario tener lo siguiente: -Servomotor. -Arduino. -Potenciómetro. -Protoboard. -Modulo Servo v1.0. -Alimentación 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); }

Página 27 de 34


MANUAL DE ARDUINO 11.3.- Servo Switch

Descripción: Se reforzara el comando switch mediante esta práctica para poder mover un servomotor en 3 diferentes grados mediante un solo botón. El material necesario es el siguiente: -Modulo Servo v1.0 -Arduino. -Protoboard. -Botón. -1 R. de 10K Ohms. -Servomotor.

Diagrama:

Programa: int val=0;

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;

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

} } }

Página 28 de 34


MANUAL DE ARDUINO 11.4.- Modulo de Pasos Descripción: En esta práctica 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;

val1 = di gitalRead(bot1); val2 = di gitalRead(bot2); if ((val1 == HIGH) && (val2 == LOW)) { Serial.println("STP0WR11"); delay(500); }

void setup() { Serial.begin(9600); pinMode(bot1,INPUT); pinMode(bot2,INPUT); Serial.println("STP0CFQ3"); } void loop() {

if ((val1 == LOW) && (val2 == HIGH)) { Serial.println("STP0WL11"); delay(500); } }

Página 29 de 34


MANUAL DE ARDUINO 11.5.- Modulo de LCD

Descripción: Se demostrara el uso del modulo de LCD y lo fácil que es utilizarla con el modulo de LCD de PyC. Se requiere el siguiente material: -LCD. -Modulo adaptador para LCD serie v1.0 -Arduino. -Potenciómetro. -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= "); }

Página 30 de 34


MANUAL DE ARDUINO Anexos Palabras reservadas del IDE de Arduino Estas palabras son constante, variables y funciones que se definen en el lenguaje de programación 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 Página 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

Página 32 de 34

<< < <= log && ! || beginSerial serialWrite serialRead serialAvailable printString printInteger printByte printHex printOctal printBinary printNewline pulseIn shiftOut


Manual de Arduino

Recommend Documents