99665621 Manual de Arduino

7/29/2019 99665621 Manual de Arduino

1/35

MANUAL DE INTRODUCCIN:

LPEZ DE NAVA LPEZ DIEGO OROPEZA LPEZ IRWIN JESS


2/35

MANUAL DE ARDUINO ndice1 2 3 Introduccin Estructura de un programa Funciones Variables 3.1 delay () 3.2milis () 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 77 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 1414 17 17 18 19 20

4 5

6

7

8

Variables especiales8.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 seles Digitales Contador de pulsos Activacin de una entrada analgica Barra de Leds

910 11

5.1 5.2 5.3 5.4

Pgina 1 de 34

www.ingenieriaenserie.com Marzo 2012 DCI0011


3/35

MANUAL DE ARDUINO7.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 Modlo de Pasos Modulo de LCD Anexos Palabras reservadas del IDE de Arduino Programapara obtener los valores mximos de una entrada analgica 21 22 23 24 26 27 28 29 30 31 32 34

Pgina 2 de 34



4/35

MANUAL DE ARDUINO INTRODUCCINArduino 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 digitalesconfigurables entrada I/O, salidas que operan a 5V. Cada pin puede proporcionaro recibir como mximo 40 mA. Los pines 3, 5, 6, 8, 10 y 11 pueden proporcionar unasalida 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 resolucinde 10 bits. Por defecto miden de 0 hasta 5 voltios, aunque es posible cambiar elnivel ms alto, utilizando el pin Aref y algn cdigo de bajo nivel.

Arduino UNO R3

Pgina 3 de 34



5/35

MANUAL DE ARDUINO 1.- Estructura de un programa en Arduino.La estructura bsica del lenguaje de programacin de Arduino es bastante simple y secompone 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 deconfiguracin 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 enserie 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.- FuncionesUna 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 program

a. La funcin se declaran asociadas a un tipo de valor type. Este valor ser el que dvolver la funcin, por ejemplo int se utilizara cuando la funcin devuelva un dato nco 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 escriir el nombre de la funcin y entre parntesis se escribirn, si es necesario, los parmtros que se deben pasar a la funcin para que se ejecute.

Pgina 4 de 34



6/35

MANUAL DE ARDUINOtype 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 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 unainstruccin de tipo bucle for. Los bloques de comentarios son reas de texto ignoradopor 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 comerio 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 noocupan espaci en la memoria.

3.- VariablesUna 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 unavez 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 de16 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 bitsin 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


7/35

MANUAL DE ARDUINOfloat: 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 y// x es mayor a y x = y // x es mayor o igual que y

Los operadores lgicos usualmente una forma de comparar dos expresiones y devolverun 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


8/35

MANUAL DE ARDUINOLogical 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/analgicasEl 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. Elpin 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 valorque podemos leer oscila de 0 a 1023.valor = analogRead(pin);

Pgina 7 de 34www.ingenieriaenserie.com Marzo 2012 DCI0011


9/35

MANUAL DE ARDUINO5.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 marcadoscomo pin PWM.

6.- ConstantesEl lenguaje de programacin de Arduino tiene unos valores predeterminados, que sonllamados 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 con0, mientras que TRUE se asocia con 1, pero TRUE tambin puede ser cualquiera otracosa excepto 0.Por lo tanto, en sentido booleano, -1, 2 y -200 tambin se definecomo TRUE. (esto es importante tenerlo en cuenta).

6.2.- HIGH/LOWEstas constantes definen los niveles de salida altos o bajos y se utilizan parala lectura o la escritura digital para las plantillas. HIGH se define como en lalgica 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 modode funcionamiento de los pines mediante la instruccin pinMode de tal manera que el pin puede ser entrada o salida.

7.- CondicionalesEstos 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 seescriben 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



10/35

MANUAL DE ARDUINONota: 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 elvalor 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 estono 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.- forEsta declaracin se usa para repetir un bloque de sentencias entre llaves un nmerodeterminado de veces. Cada vez que se ejecute la instruccin del bucle se vuelve atestear 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 lacondicin 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


11/35

MANUAL DE ARDUINO7.5.- do whileEl 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 especialesEste 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 tamaosy 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.-StringEste 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


12/35

MANUAL DE ARDUINOInt 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 SeriePara hacer que dos dispositivos se comuniquen necesitamos un mtodo de comunicaciny 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 deun segundo, interpretar dicho voltaje como un nuevo bit de datos. Si el voltajetiene 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 caracteresalfanumricos (letras y nmeros). Para ello se utiliza el cdigo estndar llamado ASCI(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



13/35

MANUAL DE ARDUINOSerial.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 ysalto de lnea. Este comando toma las misma forma que serial.print(), pero es masfcil 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 foel comando Serial.print(). Serial.println(b) : Vuelca o enva el valor de b comoun nmero decimal en caracteres ASCII seguido de CR LF. Serial.println(b, DEC) :Vueo enva el valor de b como un nmero decimal en caracteres ASCII seguido de CR LFal.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 o un nmero octal en caracteres ASCII seguido de CR LF. Serial.println(b, BIN) :Vueo enva el valor de b como un nmero binario en caracteres ASCII seguido de CR LFal.println(b, BYTE) :Vuelca o enva el valor de b como un byte seguido de CR LF. Sel.println(b, str) :Vuelca o enva la cadena de caracteres como una cadena ASCII se

guido 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 puedealmacenar como mximo 64 bytes.

Pgina 12 de 34



14/35

MANUAL DE ARDUINO9.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.- SubrutinasLas 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 PyCPara 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



15/35

MANUAL DE ARDUINOvoid 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 laLCD 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 ala 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 . Seria

l.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 rutinalimpiar LCD. }

Pgina 14 de 34



16/35

MANUAL DE ARDUINOvoid 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 losservos. { delay(500); Serial.println("SEV1CM18"); //establece el mnimo del primerconjunto de servos. Serial.println("SEV1CM28"); //establece el mnimo del segundoconjunto de servos. Serial.println("SEV1CD111"); //establece la diferencia delprimer 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



17/35

MANUAL DE ARDUINO Ejemplos Unidad 5 Entradas y Salidas5.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) //preguntasi 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



18/35

MANUAL DE ARDUINO5.2.- Contador de pulsos.Descripcin: En esta prctica contaremos los pulsos enviados al Arduino mediante unpushbotton y al contar 5 veces encenderemos un led y al contar 8 veces el pulsoel led se apagara. El material necesario para esta prctica es: -Arduino con cablede 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 2como 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



19/35

MANUAL DE ARDUINO5.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 parael 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 loalmacena 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



20/35

MANUAL DE ARDUINO5.4.- Barra de Leds.Descripcin: Enciende una barra de leds consecutivos que prenderan dependiendo elvalor del potencimetro. El material requerido es el siguiente: -Arduino con cablede 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 numerode led void setup() { for (int Led = 1; Led < ledCont; Led++) // Activa los pins de los LEDs como salida { pinMode(ledPins[Led], OUTPUT); } } void loop() { intvalp = 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 Ledfor (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



21/35

MANUAL DE ARDUINO Unidad 7 Condicionales7.1.- Encender/Apagar el LED de forma proporcional.Descripcin: En esta prctica mediante una seal PWM controlaremos la intensidad de unLED utilizando comparadores lgicos. El material necesario es: -1 R. 220 ohms. -1LED. -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



22/35

MANUAL DE ARDUINO7.2.- Control AnalgicoDescripcin: En esta prctica controlaremos mediante potencimetros la salida analgicadel 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



23/35

MANUAL DE ARDUINO Unidad 8 Variables Especiales8.1.- StringDescripcin: 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: -Potencimetrode 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



24/35

MANUAL DE ARDUINO8.2-Contador BinarioDescripcin: 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 siel 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 monitorserial 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



25/35

MANUAL DE ARDUINOdigitalWrite (5,LOW); digitalWrite (6,LOW); break; //termina switch y regresa albucle 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



26/35

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



27/35

MANUAL DE ARDUINO Unidad 11 Comunicacin Arduino y mdulos PyC11.1.- Comunicacin Servo.Descripcin: La practica est basada en la comunicacin serie para poder controlar unservomotor 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



28/35

MANUAL DE ARDUINO11.2.- Servo potencimetroDescripcin: 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



29/35

MANUAL DE ARDUINO11.3.- Servo SwitchDescripcin: Se reforzara el comando switch mediante esta prctica para poder moverun servomotor en 3 diferentes grados mediante un solo botn. El material necesarioes 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



30/35

MANUAL DE ARDUINO 11.4.- Modulo de PasosDescripcin: 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 elsiguiente: -Modulo Stepper v1.0 -Arduino. -2 botones. -Protoboard. -2 R. de 10KOhms. -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"); } voidloop() { } 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



31/35

MANUAL DE ARDUINO11.5.- Modulo de LCDDescripcin: Se demostrara el uso del modulo de LCD y lo fcil que es utilizarla conel 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



32/35

MANUAL DE ARDUINO AnexosPalabras reservadas del IDE de ArduinoEstas 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_PILSBFIRST 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 DDRCPINC 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 maxPgina 31 de 34

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


33/35

MANUAL DE ARDUINOPC5 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 <


34/35

MANUAL DE ARDUINOPrograma 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



35/35

Documents

99665621 Manual de Arduino