Dci-0011 Manual de Arduino PDF

Manual Bsico de Arduino
Y
Comunicacin con Mdulos PYC

MANUAL DE ARDUINO
Pgina 1 de 35 www.ingenieriaenserie.com
Julio 2012 DCI0011

ndice
Introduccin 4
1 Estructura de un programa 5
2 Funciones 5
3 Variables 6
3.1 delay () 7
3.2 milis () 7
4 Aritmticas 7
5 Entradas y salidas Digitales/Analgicas 8
5.1 pinMode(pin, mode) 8
5.2 digitalRead(pin) 8
5.3 digitalWrite(pin, value) 8
5.4 analogRead(pin) 8
5.5 analogWrite(pin, value) 9
6 Constantes 9
6.1 (TRUE/FALSE) 9
6.2 HIGH/LOW 9
6.3 INPUT/OUTPUT 9
7 Condicionales 9
7.1 if () 9
7.2 if else () 10
7.3 for() 10
7.4 while() 10
7.5 do while() 11
8 Variables especiales 11
8.1 Arrays[] 11
8.2 String 11
8.3 map() 11
8.4 switch (range) 12
8.5 12
8.6 12
9 Comunicacin Serie 13
9.1 Serial.begin(rate) 13
9.2 Serial.println(data) 14
9.3 Serial.printnl(data, data type) 14
9.4 Serial.print(data, data type) 14
9.5 Serial.avaible() 14
9.6 Serial.Read() 14
10 Subrutinas 15
11 Comunicacin Arduino y mdulos PyC 15
Ejemplos 18
Unidad 5 Entradas y Salidas
5.1 Activacin de seales Digitales 18
5.2 Contador de pulsos 19
5.3 Activacin de una entrada analgica 20
5.4 Barra de Leds 21

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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.

MANUAL DE ARDUINO
Julio 2012 DCI0011

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.

MANUAL DE ARDUINO
Julio 2012 DCI0011

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.

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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.

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

8.5.- attachInterrupt(interrupcin, funcin, modo)

Funcin para llamar una interrupcin previamente asignada, mientras est activa la
interrupcin, las funciones delay() y millis() no funcionaran y si recibe datos seriales puede
que se pierdan datos. Arduino UNO cuenta con 2 interrupciones externas, 0(pin2) y
1(pin3).

Modos:
-LOW: dispara la interrupcin cuando es bajo.
-CHANGE: dispara la interrupcin cuando tiene cambios de estado.
-RISING: dispara la interrupcin cuando cambia de bajo a alto.
-FALLING: dispara la interrupcin cuando cambia de alto a bajo.

int conta=0;

void setup()
{
Serial.begin(57600); //habilita comunicacin serial.
attachInterrupt(0, Revo, RISING); //habilita interrupcin 0 cuando va de bajo a alto.
}

void loop()
{}

void Revo() //llamado de la interrupcin
{
conta++;

Serial.println(conta);
}

8.6.- detachInterrupt(interrupcion)
Deshabilita la interrupcin deseada 0 o 1.

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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
Serial.println(b, BIN) :Vuelca o enva el valor de b como un nmero binario en caracteres
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.

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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.

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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("_LCDW00SD=180 SE=180");
Serial.println("_LCDW44SF=180");
delay(2000);

Serial.println("STP1WR150"); //mueve el motor a pasos 160 pasos
Serial.println("_LCDW00Pasos=50");
Serial.println("_LCDW40Sentido= Der");
delay(2000);

delay(2000);

Serial.println("MOT0WL1100,L2100"); //cambia el giro de los motores de dc y los mantiene a 100%.
Serial.println("_LCDW00Motor 1=100 Izq");
Serial.println("_LCDW40Motor 2=100 Izq");
delay(2000);

delay(2000);

Serial.println("STP1WL150"); //mueve el stepper a 150 pasos.
Serial.println("_LCDW00Pasos=50");
Serial.println("_LCDW40Sentido= Izq");
delay(2000);

LIMPIANDO_DISPLAY(); //llama a la rutina limpiar LCD.
}

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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:

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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:

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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:

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

}

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

break; //termina switch y regresa al bucle

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

case 2:
break;

case 3:
break;

case 4:
break;

case 5:
break;

case 6:
break;

case 7:
break;

case 8:
break;

case 9:
break;

case 10:
break;

case 11:
break;

case 12:
break;

case 13:
break;

case 14:
break;

case 15:
break;

case 16: //reinicia el valor del contador para volver
a iniciar.

conta = -1;
break;
}
}

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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:
break;
case 2:
break;
case 3:
break;
case 4:
val = 0;
break;
}
}
}

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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("_LCDW00Pot= ");
}

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

MANUAL DE ARDUINO
Julio 2012 DCI0011

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

Dci-0011 Manual de Arduino PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Dci-0011 Manual de Arduino PDF

Uploaded by

Copyright:

Available Formats

Manual Bsico de Arduino

You might also like