Professional Documents
Culture Documents
Contenido
EL HARDWARE DE LA PLACA ARDUINO ................................................................................ 5
Programacin ........................................................................................................................ 7
5.-INTALACION DEL IDE ARDUINO UNO en WINDOWS 7 ........................................ 7
2 | Descarga el IDE de Arduino.................................................................................... 7
3 | Conecta la placa ....................................................................................................... 8
4 | Instala los drivers ...................................................................................................... 8
5 | Ejecuta la Aplicacin Arduino y abre el ejemplo Blink (Parpadeo) ................... 8
6 | Selecciona tu placa .................................................................................................. 8
7 | Selecciona tu puerto serie ....................................................................................... 8
8 | Sube el sketch a la placa ......................................................................................... 9
6.-LENGUAJE C (PROGRAMACION ARDUINO)....................................................................... 9
2
1.-PREFACIO:
2.-HISTORIA DE ARDUINO:
3
Cada vez que un nuevo puerto de entrada o salida es aadido al Arduino, un
nuevo conjunto de libreras especializadas en ese puerto es suministrada y
mantenida por los desarrolladores del nuevo puerto.
4
Software ampliable y de cdigo abierto- El software Arduino esta
publicado bajo una licencia libre y preparado para ser ampliado por
programadores experimentados. El lenguaje puede ampliarse a travs
de libreras de C++, y si se est interesado en profundizar en los
detalles tcnicos, se puede dar el salto a la programacin en el
lenguaje AVR C en el que est basado. De igual modo se puede
aadir directamente cdigo en AVR C en tus programas si as lo
deseas.
Hardware ampliable y de Cdigo abierto - Arduino est basado en los
microcontroladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los
planos de los mdulos estn publicados bajo licencia Creative
Commons, por lo que diseadores de circuitos con experiencia
pueden hacer su propia versin del mdulo, amplindolo u
optimizndolo. Incluso usuarios relativamente inexpertos pueden
construir la versin para placa de desarrollo para entender cmo
funciona y ahorrar algo de dinero.
4.-INTRODUCCIN
5
Alimentacin
Las placas pueden ser alimentadas por medio de la conexin USB o con una
fuente de alimentacin externa de entre 6 a 20 V, aunque el rango
recomendado es de 7 a 12 V.
Las fuentes de alimentacin externas (no-USB) pueden ser tanto un
transformador como una batera. El transformador se puede conectar usando
un conector macho de 2.1 mm con centro positivo en el conector hembra de
la placa. Los cables de la batera pueden conectarse a los pines Gnd y Vin
en los conectores de alimentacin (POWER).
Entradas y Salidas
Cada uno de los 14 pines digitales (de 0 a 13) pueden utilizarse como
entradas o como salidas usando las funciones pinMode(), digitalWrite() y
digitalRead(). Las E/S operan a 5 V. Cada pin puede proporcionar o recibir
una intensidad mxima de 40 mA.
Los pines 3, 5, 6, 9, 10, y 11 proporcionan una salida PWM (modulacin por
anchura de pulsos) de 8 bits de resolucin (valores de 0 a 255) mediante la
funcin analogWrite().
El pin digital 13 lleva conectado un LED integrado en la propia placa. Se
encender cuando dicho pin se configura como salida y adopte un valor
HIGH.; con valor LOW se apaga.
La placa tiene 6 entradas analgicas, y cada una de ellas proporciona una
resolucin de 10 bits (1024 valores).
Comunicaciones
La placa Arduino proporciona comunicacin va serie a travs de los pines
digitales 0 (RX) y 1 (TX). Un chip integrado en la placa canaliza esta
comunicacin serie a travs del puerto USB. El software de Arduino incluye
un monitor de puerto serie que permite enviar y recibir informacin textual
6
hacia y desde la placa Arduino. Los leds RX y TX de la placa parpadearn
cuando se detecte comunicacin transmitida a travs de la conexin USB.
Programacin
La placa Arduino se puede programar a travs del IDE (Entorno de
Desarrollo Integrado) de Arduino. Primero hay que decirle al IDE nuestro tipo
de placa. Para ello, selecciona bien "Arduino Duemilanove w/ ATmega328" o
bien Arduino Uno del menu Herramientas > Tarjeta. Tambin hay que
decirle al IDE en qu puerto USB hemos conectado la placa. Lo haremos a
travs del men Herramientas > Puerto Serial. Aparecen una serie de
puertos denominados COMx, donde x es un nmero. Para saber cul es,
desconecta y conecta el cable USB del ordenador, y el que desaparezca y
vuelva a aparecer es nuestro puerto.
Para poder empezar a utilizar Arduino no basta con tener la placa, tambin
se requiere el entorno de programacin donde construiremos la parte lgica
de nuestro proyecto. Para este tutorial nos apoyamos de la informacin
existente en la web oficial de Arduino. Puede seguir los pasos completos
desde ella o leer nuestra versin resumida.
7
ver una serie de ficheros y carpetas ah dentro.
3 | Conecta la placa
6 | Selecciona tu placa
8
8 | Sube el sketch a la placa
https://www.youtube.com/watch?v=cwNcKnKDj_M
void setup()
{
estamentos;
}
void loop()
{
estamentos;
}
9
6.2 setup()
La funcin setup() se invoca una sola vez cuando el programa empieza. Se
utiliza para inicializar los modos de trabajo de los pins, o el puerto serie.
Debe ser incluido en un programa aunque no haya declaracin que ejecutar.
Asi mismo se puede utilizar para
establecer el estado inicial de las salidas de la placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como
Salida
digitalWrite(pin, HIGH); // pone el pin en estado
// HIGH
}
6.3.-loop()
Despus de llamar a setup(), la funcin loop() hace precisamente lo que
sugiere su nombre, se ejecuta de forma ciclica, lo que posibilita que el
programa este respondiendo continuamente ante los eventos que se
produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) elpin
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el
delay(1000); // pin
}
6.4 funciones
Una funcion es un bloque de cdigo que tiene un nombre y un conjunto de
instrucciones que son ejecutadas cuando se llama a la funcin. Son
funciones setup() y loop() de las que ya se ha hablado.
Las funciones de usuario pueden ser escritas para realizar tareas repetitivas
y para reducir el tamao de un programa. Las funciones se declaran
asociadas a un tipo de valor. 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 valor entonces se colocara delante
la palabra void, que significa funcin vaca. Despus de declarar el tipo de
dato que devuelve la funcin se debe escribir el nombre de la funcin y entre
10
parntesis se escribirn, si es necesario, los parmetros que se deben pasar
a la funcin para que se ejecute.
tipo nombreFuncin(parmetros)
{
instrucciones;
}
int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potencimetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}
type funcion()
{
instrucciones;
}
Nota: Si olvidas poner fin a una lnea con un punto y coma se producir en
un error de compilacin. El texto de error puede ser obvio, y se referir a la
falta de un punto y coma, o puede que no. Si se produce un error raro y de
difcil deteccin lo primero que
debemos hacer es comprobar que los puntos y comas estn colocados al
final de las instrucciones.
// lnea de comentarios
Una lnea de comentario empieza con / / y terminan con la siguiente lnea de
cdigo. Al igual que los comentarios de bloque, los de lnea son ignoradas
por el programa y no ocupan espacio en la memoria. // esto es un comentario
6.8 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 pueden variar continuamente en contra de lo que
ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser
declarada y, opcionalmente, asignarle un valor. El siguiente cdigo de
12
ejemplo declara una variable llamada variableEntrada y luego le asigna el
valor obtenido en la entrada analgica del PIN2: int variableEntrada = 0; //
declara una variable y le // asigna el valor 0 variableEntrada =
analogRead(2); // la variable recoge //el valor analgico del PIN2
'variableEntrada' es la variable en s.
La primera lnea declara quesera de tipo entero int. La segunda lnea fija a
la variable el valor correspondiente a la entrada analgica PIN2. Esto hace
que el valor
de PIN2 sea accesible en otras partes del cdigo.
Una vez que una variable ha sido asignada, o re-asignada, usted puede
probar su valor para ver si cumple ciertas condiciones, o puede utilizar
directamente su valor. Como ejemplo ilustrativo veamos tres operaciones
tiles con variables:
Nota: Las variables deben tomar nombres descriptivos, para hacer el cdigo
ms legible. Los nombres de variables pueden ser contactoSensor o
pulsador, para ayudar al programador y a cualquier otra persona a leer el
cdigo y entender lo que representa
la variable. Nombres de variables como var o valor, facilitan muy poco que
el cdigo sea inteligible. Una variable puede ser cualquier nombre o palabra
que no sea una palabra reservada en el entorno de Arduino.
13
Una variable puede ser declarada en una serie de lugares del programa y en
funcin del lugar en donde se lleve a cabo la definicin esto determinara en
que partes del programa se podr hacer uso de ella.
14
Byte almacena un valor numrico de 8 bits sin decimales. Tienen un rango
entre 0 y 255.
byte unaVariable = 180; // declara 'unaVariable' como // de tipo byte
int
Enteros son un tipo de datos primarios que almacenan valores numricos de
16 bits sin decimales comprendidos en el rango 32,767 to -32,768. int
unaVariable = 1500; // declara 'unaVariable' como // una variable de tipo
entero
Nota: Las variables de tipo entero int pueden sobrepasar su valor mximo o
mnimo como consecuencia de una operacin. Por ejemplo, si x = 32767 y
una posterior declaracin agrega 1 a x, x = x + 1 entonces el valor se x
pasara a ser -32.768. (algo as como que el valor da la vuelta).
long
El formato de variable numrica de tipo extendido long se refiere a nmeros
enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -
2147483648 a 2147483647.
long unaVariable = 90000; // declara 'unaVariable' como // de tipo long.
float
El formato de dato del tipo punto flotante float se aplica a los nmeros con
decimales. Los nmeros de punto flotante tienen una mayor resolucin que
los de 32 bits con un rango comprendido
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 est
indicado con el ndice 0, es decir el primer valor
del conjunto es el de la posicin 0. Un array tiene que ser declarado y
opcionalmente asignados valores a cada posicin antes de ser utilizado.
Del mismo modo es posible declarar una matriz indicando el tipo de datos y
el tamao y posteriormente, asignar valores a una posicin especifica:
15
int miArray[5]; // declara un array de enteros de 6
// posiciones
miArray[3] = 10; // asigna l 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 est en
// la posicin 3 del array
Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que
la variable de incremento del contador del bucle se utiliza como ndice o
puntero del array. El siguiente ejemplo usa una matriz para el parpadeo de
un LED.
6.12 aritmtica
Los operadores aritmticos que se incluyen en el entorno de programacin
son suma, resta, multiplicacin y divisin. Estos devuelven la suma,
diferencia, producto, o cociente (respectivamente) de dos operando.
y = y + 3; x = x - 7; i = j * 6; r = r / 5;
16
2,25 ya que el 9 y 4 se valores de tipo entero int (enteros) y no se
reconocen los decimales con este tipo de
Datos.
Nota: Utilice el operador (int) para convertir un tipo de variable a otro sobre la
marcha. Por ejemplo, i = (int) 3,6 establecer i igual a 3.
Lgica AND:
if (x > 0 && x < 5) // cierto slo si las dos
Expresiones // son ciertas
Lgica OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las
// Expresiones es cierta
Lgica NOT:
if (!x > 0) // cierto solo si la expresin es
// Falsa
6.16 Constantes
El lenguaje de programacin de Arduino tiene unos valores predeterminados,
que son llamados constantes. Se utilizan para hacer los programas ms
fciles de leer. Las constantes se clasifican en grupos.
if (b == TRUE);
{
Ejecutar las instrucciones;
}
6.18 high/low
Estas constantes definen los niveles de salida altos o bajos y se utilizan para
la lectura o la escritura digital para las patillas. ALTO se define como en la
18
lgica de nivel 1, ON, o 5 voltios, mientras que BAJO es lgica nivel 0, OFF,
o 0 voltios.
6.19 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 una entrada INPUT o una salida OUTPUT.
if (unaVariable ?? valor)
{
Ejecuta Instrucciones;
}
Nota: Tenga en cuenta el uso especial del smbolo '=', poner dentro de if (x =
10), podra parecer que es vlido pero sin embargo no lo es ya que esa
expresin asigna el valor 10 a la variable x, por eso dentro de la estructura if
se utilizara X==10 que en este caso lo que
Hace el programa es comprobar si el valor de x es 10. Ambas cosas son
distintas por lo tanto dentro de las estructuras if, cuando se pregunte por un
valor se
Debe poner el signo doble de igual ==.
6.21 for
La declaracin for se usa para repetir un bloque de sentencias encerradas
entre llaves un nmero determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condicion. La declaracin for
tiene tres partes separadas por (;), vemos el ejemplo de su sintaxis:
6.22while
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 o tambin
por el cambio de un valor en una entrada de un sensor.
6.23 do while
El bucle do while funciona de la misma manera que el bucle while, con la
salvedad de que la condicion se prueba al final del bucle, por lo que el bucle
siempre se ejecutara al menos una vez.
do
{
Instrucciones;
} while (unaVariable ?? valor);
do
{
25
x = leeSensor();
delay(50);
} while (x < 100);
22
Las resistencias internas normalmente se utilizan para conectar las entradas
a interruptores. En el ejemplo anterior no se trata de convertir un pin en
salida, es simplemente un mtodo para activar las resistencias interiores.
Los pins configurado como OUTPUT (salida) se dice que estn en un estado
de baja impedancia estado y pueden proporcionar 40 mA (miliamperios) de
corriente a otros dispositivos y circuitos. Esta corriente es suficiente para
alimentar un diodo LED (no olvidando poner una resistencia en serie), pero
no es lo suficiente grande como para alimentar cargas de mayor consumo
como rels, solenoides, o motores. Un cortocircuito en las patillas Arduino
provocara una corriente elevada que puede daar o destruir el chip Atmega.
A menudo es 27 una buena idea conectar en la OUTUPT (salida) una
resistencia
externa de 470 o de 1000 .
6.25 digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto)
o LOW (bajo). El pin se puede especificar ya sea como una variable o una
constante (0-13).
valor = digitalRead(Pin); // hace que 'valor sea igual // al estado ledo en Pin
24
Nota: Las salidas analgicas a diferencia de las digitales, no necesitan ser
declaradas como INPUT u OUTPUT.
6.30 millis()
Devuelve el nmero de milisegundos transcurrido desde el inicio del
programa en Arduino hasta el momento actual. Normalmente ser un valor
grande (dependiendo del tiempo que est en marcha la aplicacin despus
de cargada o despus de la ltima vez que se
pulso el botn reset de la tarjeta).
6.32 max(x, y)
Calcula el mximo de dos nmeros para cualquier tipo de datos devolviendo
el nmero mayor de los dos.
void setup()
{
Serial.begin(9600); // abre el Puerto serie
} // configurando la velocidad en 9600 bps
Nota: Cuando se utiliza la comunicacin serie los pins digital 0 (RX) y 1 (TX)
no puede utilizarse al mismo tiempo.
6.36 Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro
automtico y salto de lnea. Este comando toma la misma forma que
Serial.print(), pero es ms fcil para la lectura de los datos en el Monitor
Serie del software.
El siguiente ejemplo toma de una lectura analgica pin0 y enva estos datos
al ordenador cada 1 segundo.
void setup()
{
Serial.begin(9600); // configura el puerto serie a
// 9600bps
}
void loop()
{
27
Serial.println(analogRead(0)); // enva valor analgico
delay(1000); // espera 1 segundo
}
6.38 Parmetros
data: el nmero o la cadena de caracteres a volcar o enviar.
data type: determina el formato de salida de los valores numricos (decimal,
octal, binario, etc...) DEC, OCT, BIN, HEX, BYTE , si no se pe nada vuelva
ASCII
Ejemplos:
Serial.print(b) // Vuelca o enva el valor de b como
// un nmero decimal en caracteres
// ASCII.
int b = 79;
Serial.print(b); // imprime la cadena "79".
Serial.print(b, HEX); // Vuelca o enva el valor de
// b como un nmero hexadecimal
// en caracteres ASCII "4F".
Serial.print(b, OCT); // Vuelca o enva el valor de
// b como un nmero Octal en
// caracteres ASCII "117".
Serial.print(b, BIN) // Vuelca o enva el valor de
// b como un nmero binario en
// caracteres ASCII "1001111".
Serial.print(b, BYTE); // Devuelve el caracter "O",
// el cual representa el
// caracter ASCII del valor
// 79. (Ver tabla ASCII).
Serial.print(str); //Vuelca o enva la cadena de
// caracteres como una cadena ASCII.
Serial.print("Hello World!"); // vuelca "Hello World!".
6.39 Serial.avaible()
Devuelve Un entero con el nmero de bytes disponibles para leer desde el
buffer serie, o 0 si no hay ninguno. Si hay algn dato disponible,
SerialAvailable() ser mayor que 0. El buffer serie puede almacenar como
mximo 64 bytes.
Ejemplo
int incomingByte = 0; // almacena el dato serie
void setup() {
Serial.begin(9600); // abre el puerto serie, y le asigna
// la velocidad de 9600 bps
}
void loop() {
if (Serial.available() > 0) // enva datos slo si
{ // los recibe:
incomingByte = Serial.read();// lee el byte de entrada:
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
}
}
6.40 Serial.Read()
Lee o captura un byte (un caracter) desde el puerto serie. Devuelve el
siguiente byte (caracter) desde el puerto serie, o -1 si no hay ninguno.
Ejemplo:
int incomingByte = 0; // almacenar el dato serie
void setup() {
Serial.begin(9600); // abre el puerto serie,y le asigna
// la velocidad de 9600 bps
}
void loop() {
if (Serial.available() > 0)// enva datos slo si los
{ // recibe
incomingByte = Serial.read(); // lee el byte de
// entrada y lo vuelca
Serial.print("I received: "); // a pantalla
Serial.println(incomingByte, DEC);
}
30
sean simples ejecutar. Por ejemplo, para leer el valor de un pin digital basta
con usar la funcin digitalRead (por otra parte, el nombre es fcil de
recordar).
Libreras estndar
Para incluir un librera basta con aadir una declaracin #include al comienzo
del sketch. Por ejemplo, si quieres incluir la librera de cristal lquido, que se
utiliza para exhibir datos en una pantalla LCD, basta con incluir la siguiente
declaracin al principio de tu sketch:
#include <LiquidCrystal.h>
Observa que el nombre de la librera tiene que ir limitado por los corchetes
menor/mayor: < y >. Adems hay que notar que la lnea no termina con un
punto y coma (;) como es la norma en las dems lneas de cdigo.
1. Librera ArduinoTestSuite
2. Librera EEPROM
3. Librera SD
4. Librera Ethernet
5. Librera Firmata
6. Librera LiquidCrystal
7. Librera Servo
8. Librera Stepper
9. Librera SPI
10. Librera Wire
11. Librera SoftwareSerial
31
9.2 Programacin en un entorno de test: ArduinoTestSuite
Test Description
ATS_begin Inicia el proceso de test
ATS_end Termina el proceso de test
ATS_Test_DigitalPin Testea un pin de entrada digital dado
ATS_Test_PWM Testea la salida PWM
ATS_Test_AnalogInput Testea la entrada analogical
ATS_Test_EEPROM Testea la EEPROM
ATS_TestSerialLoopBack Testea los pins RX y TX de una puerta Serie
Devuelve el nmero de posiciones libres de
ATS_GetFreeMemory
memoria en el Arduino
32
La idea de incorporar un entorno de test como parte del Arduino IDE es
nueva, pero se convertir probablemente en una parte importante del IDE a
medida que la funcionalidad de los Arduinos siga evolucionando.
Function Description
Lee el valor de un byte almacenado en una posicin de la
Read
EEPROM
Write Escribe un valor en una posicin de la EEPROM
33
(contadores, constantes necesarias para el uso de ciertos dispositivos
perifricos, como una pantalla LCD, etc.).
SD SDHC
Capacidad 02 GB 4 GB32 GB
Sistema de Almacenamiento de
FAT16 o FAT32 FAT32
ficheros
William Greiman escribi una librera para Arduino llamada SdFat basada en
los sistemas de codificacin de ficheros FAT16 y FAT 32. La librera SdFat
proporciona una gama exhaustiva de funciones para el manejo de estas
tarjetas de memoria: crear y suprimir ficheros y directorios, formateo, etc.
34
Cuando se incluye esta librera en un sketch, la librera SD proporciona una
gama de funciones bsicas (ver siguiente tabla) que permiten a tu Arduino
interaccionar con las tarjetas SD:
Arduino usa un bus serie para comunicar con sus perifricos (el bus SPI del
que hablaremos ms adelante) y en particular con la tarjeta SD (pins digitales
11, 12, y 13 en un Arduino estndar y 50, 51, y 52 en un Mega).
35
Existen microSDshields disponibles en el mercado. Asimismo est disponible
una gama de shields con conectores integrados microSDcard, incluyendo el
ltimo shield oficial Ethernet y shields de registro de datos.
Esta librera est diseada para interactuar con placas basadas en WIZnet
W5100. La placa oficial ms reciente de Arduino lleva incorporada tambin
un conector microSDcard que resulta muy apropiado para el registro
y almacenamiento continuo de datos.
De esta manera puedes, por ejemplo, utilizar el Arduino para tomar lecturas
de datos en una ubicacin remota y publicar estos datos en una pgina web
bsica mientras los almacena en un microSDcard que podra ser recuperado
y analizado ms adelante.
36
write Escribe datos a un servidor conectado.
Escribe datos a un servidor, tipo puede ser: byte, char, int, long, o
print
string
println Escribe datos a un servidor seguido por un carcter newline
Devuelve el nmero de bytes que estn listos para su lectura en
available
el servidor
read Lee el siguiente octeto (byte) desde el servidor
Desestima los bytes que estn en espera de ser ledos por el
flush
cliente
stop Se desconecta del servidor
Como puedes ver la librera Ethernet es muy rica en contenido y sigue siendo
extendida dado su inters de cara a conectar nuestras aplicaciones Arduino
con el resto del mundo.
Mtodo Descripcin
Comn begin Inicializa la librera Firmata
printVersion Enva versin del protocolo al PC
setFirmwareVersion Establece la versin del firmware
Enviar mensajes sendAnalog Enva un mensaje analgico
sendDigitalPortPair Enva el valor de un pin digital
Enva un comando con un array de
sendsysex
bytes
sendString Enva un string al PC
Comprueba que hay mensajes en el
Recibir mensajes available
buffer de entrada
processInput Procesa los mensajes entrants
Asocia una funcin a un cierto tipo de
attach
mensaje de entrada
37
Mtodo Descripcin
Disocia una funcin de un cierto tipo de
detach
mensaje de entrada
Funcin Descripcin
Establece las dimensiones en filas y columnas de la pantalla
begin
LCD
Inicializa la librera y determina los pins usados para
LiquidCrystal
comunicar con la pantalla LCD
print Visualiza datos en la pantalla LCD
clear Borra los contenidos de la pantalla LCD
setCursor Posiciona el cursor sobre la pantalla
Son ideales para los proyectos que necesitan el movimiento exacto, como
por ejemplo evitar obstculos o colocar una pieza en un ngulo pre-
determinado en aplicaciones robticas, etc.
38
La librera Servo permite al Arduino controlar hasta 12 motores servos con un
Arduino estndar, y 48 con un Mega. La siguiente tabla muestra las
principales funciones proporcionadas por la biblioteca Servo.
Funcin Descripcin
attach Asigna el servo a un pin.
Attached Verifica que el servo est conectado al pin
Detach Desconecta el servo del pin.
Read Lee el ngulo del servo.
Hace girar el eje del servo al ngulo especificado.
Write Entre 0 y 180 en un servo clsico. En un servo de
rotacin continua establece la velocidad de rotacin.
Gira el eje del servo un arco expresado en
writeMicroseconds
microsegundos.
Los motores de pasos nos proporcionan una manera muy precisa para
controlar dispositivos. La librera Stepper nos proporciona la manera de
controlar motores de pasos unipolares y bipolares con un Arduino.
Funcin Descripcin
39
Funcin Descripcin
Inicializa la librera Stepper y establece el nmero de pasos por
Stepper
revolucin.
Establece la velocidad de rotacin del motor en revoluciones por
setSpeed
minute (RPM)
Gira el motor el nmero de pasos indicado. Un nmero positive
step
gira en un sentido y uno negativo en el contrario.
El Bus Serie para Perifricos (denominado con las siglas SPI en ingls),
tambin llamado el bus de 4 hilos (four-wire bus) es un protocolo de
comunicaciones sncrono usado para comunicar en distancias cortas con
perifricos externos como sensores, incluyendo los sensores de temperatura,
sensores de presin, convertidores analgico- digital, pantallas tctiles,
controladores de videojuegos, y pantallas de visualizacin. Arduino usa
tambin el bus SPI para comunicar con tarjetas de memoria SD.
El protocolo utiliza cuatro hilos, de los cuales tres son comunes a cada
dispositivo y el cuarto que es especfico (no compartido) para cada perifrico.
Sus designaciones se muestran en la siguiente tabla:
Cada esclavo tiene un hilo selectwire especfico para l, pero comparte los
otros tres hilos del bus con los otros perifricos. El pin 10 (53 en el Mega) se
usa generalmente como lnea de seleccin de esclavo (slave select), pero
los otros tres pueden ser elegidos durante la configuracin.
El shield Ethernet del Arduino utiliza el pin 4 para conectar con el conector
SD integrado y el pin 10 para el controlador Ethernet.
40
La librera SPI proporciona las funciones que nos permitirn actuar sobre los
perifricos SPI tal y como se muestra a continuacin:
Funcin Descripcin
Inicializa el bus SPI y pone los pins MOSI y SCK en baja y
Begin
el SS en alta
End Desactiva el bus SPI
setBitOrder Establece el orden en el cual se cargan los bits en el bus
Establece el divisor de reloj SPI como una fraccin del reloj
setClockDivider
del sistema
setDataMode Establece el modo de datos en el bus SPI
Transfer Transfiere un byte al bus
Todo esto parece un poco complicado, sin embargo vers que leyendo las
especificaciones del perifrico y siguiendo sus instrucciones con cuidado
podrs comunicar con el bus SPI sin problemas.
41
9.11 Comunicando con el interface de dos hilos (I2C)
Este interface comnmente llamado interface de dos hilos (TWI, two wire
interface) se usa para comunicar a baja velocidad con una amplia gama de
dispositivos y componentes (incluyendo relojes de tiempo real).
I2C se usa en los mandos Nintendo, el Wii Motion Plus, y Wii Nunchuks.
Solo se necesitan dos pins para el interface con el bus i2C (ver tabla).
Function Description
Inicializa la librera Wire y conecta el Arduino al bus I2C
Begin
como master o esclavo.
requestFrom Pide datos del esclavo al master.
beginTransmission Prepara la transmisin de datos.
Enva datos del esclavo al master o pone en cola bytes
Send
para la transmisin de master a esclavo.
Finaliza la transmisin (comenzada con
endTransmission beginTransmission) de datos a un esclavo y enva los
datos puestos en cola de envo por send.
Devuelve el nmero de bytes disponible para su
recepcin con receive. Debe de ser usado en el
Available
dispositivo master tras una llamada requestFrom de un
esclavo dentro de la funcin activada por onReceive.
Receive requestFrom o desde el master a un esclavo.
onReceive Determina la funcin que se ha de activar cuando el
42
Function Description
esclavo recibe una transmisin desde el master.
Determina la funcin que se ha de activar cuando el
onRequest
master pide datos al dispositivo esclavo.
Los Arduino Uno y Duemilanove tienen una puerta serie conectado a los
pines digitales 0 y 1, pero si tu proyecto necesita conectarse a ms
dispositivos serie (por ejemplo un GPS y un display LCD) puedes hacer dos
cosas: comprarte el Arduino Mega (o compatible) que tiene 4 puertas serie o
usar la librera SoftwareSerial que se distribuye con el entorno de desarrollo
del Arduino (IDE).
Funcin Descripcin
Activa la puerta y establece la velocidad de transmisin en
Begin
baudios
Available Comienza a usar la puerta
isListening Devuelve la puerta active en este momento
listen Escucha a ese puerta y lo activa
end Termina el uso de ese puerta
read Lee datos de la puerta
write Escribe datos en la puerta
Esta nueva librera puede crear varias puertas serie software que pueden
comunicar a velocidades de hasta 115,000 baudios. Pero toda esta
43
funcionalidad adicional tiene un precio: el Arduino slo puede escuchar o
recibir datos de una puerta serie software a la vez (sin embargo, s que
puede transmitir por varias simultneamente).
Cuando uses la librera con ms de una puerta serie software tienes que
planificar cuidadosamente tu sketch y el orden en el que recibirs los datos.
#include <SoftwareSerial.h>
SoftwareSerial gpsPort(2, 3);
SoftwareSerial thermPort(4, 5);
void setup()
{ gpsPort.begin(9600);
thermPort.begin(9600);
}
void loop()
{
gpsPort.listen();
while (gpsPort.available() > 0)
{ char inByte = gpsPort.read();
}
thermPort.listen();
while (thermPort.available() > 0)
{ char inByte = thermPort.read();
}
}
44
Casi con seguridad existe una librera escrita por otro usuario que se puede
adecuar a tu proyecto. En el prximo captulo vamos a ver cmo usar estas
libreras llamadas contributed libraries.
Dado que estas libreras no forman parte del IDE vas a necesitar hacer una
serie de operaciones previas para poder trabajar con ellas. En el siguiente
captulo explicamos cmo proceder.
Para aadir una nueva librera al entorno de desarrollo IDE basta con realizar
las siguientes operaciones:
45
Nota: Una vez aadida la librera al IDE, queda disponible para su uso con
futuros proyectos, de la misma manera que las libreras estndar. Una vez
importada una librera en un sketch, todas sus funciones estn disponibles
en el sketch.
Una librera est constituida por al menos una clase C++. Una clase consiste
en dos ficheros: un fichero cabecera (header con una extensin .h) y un
fichero con una extension .cpp.
El fichero .cpp
void MetDet::begin()
{ //Define las funciones pblicas
// Aqu ira el cdigo de inicializacin del sensor MetDet
}
void MetDet::update()
{ int data = pollMetDet();
int result = countMetales(data);
}
int MetDet::pollMetDet()
{//Aqu ira el cdigo para realizar el sondeo de metales con el sensor
MetDet
}
47
int MetDet::countMetales(int inputData)
{//Aqu ira el cdigo para contar el nmero de metales encontrados al
sondear
}
libraries/MetDet/MetDet.h
libraries/MetDet/MetDet.cpp
12 Utilizacin de libreras
void setup()
{ // Inicializa el sensor MetDet
48
myMetDet.begin();
}
void loop()
{ // Actualiza lectura del sensor
myMetDet.update()
}
Libraries/MetDet/Examples/MetDet.ino
49
Ahora nos pedir la direccin del fichero descargado en formato xxx.zip.
Arduino define un sistema simple para formar una librera y define una serie
de ficheros que deben ir incluidos, as como los ejemplos que la acompaan
y forman un paquete comprimido con ZIP para contener todo el conjunto.
50
Los ficheros que suele incluir una librera (Que llamaremos Biblos por
ejemplo), y que podis comprobar descomprimiendo aparte cualquiera de las
nos hemos descargado, son:
Arduino establece que todo esto debe estar comprimido en un nico fichero
Zip que es capaz de importar con la instruccin Importar Librera.
51
nuevo fichero Asegrate adems de que no hay directorios
encadenados.
Por este motivo, en nuestras sesiones siempre os incluyo una copia
de la librera para vuestra descarga, que haya comprobado que se
instala sin problemas.
Basta con cerrar el IDE Arduino e ir a los directorios donde se instalan las
libreras. Ya dijimos que en Windows es
en \\Usuario\Documentos\Arduino\libraries\. SI vez con el explorador de
archivos veras algo como esto:
52
Lo que el IDE nos muestra en el men \\Programa\Importar\libreria es una
copia de los directorios que aparecen aqu y para desinstalar una librera
basta con que borrar el directorio en cuestin.
53
Y puedes borrar igualmente la carpeta de la librera correspondiente para
librarte de l.
54
15 PRACTICAS:
Practica 1
Led Intermitente
Material:
Protoboard
1 diodo LED
55
Codigo en arduino:
Circuito armado:
Practica 2
LEDs en secuencia
Se trata de encender y apagar 3 LEDs colocados en las salidas 6, 7 y 8
(PIN6, PIN7 y PIN8) con una cadencia de 200 ms. Las variables asignadas a
cada led son ledPin1,ledPin2 y ledPin3.
56
Material:
Protoboard
3 diodo LED
Cdigo en arduino:
pinMode(ledPin3, OUTPUT);
digitalWrite(ledPin1, LOW); // Apaga los LEDs
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
}
void loop(){ //Bucle de Funcionamiento
digitalWrite(ledPin1, HIGH); // Apaga y enciende los leds cada 200 ms
delay(200);
digitalWrite(ledPin1, LOW);
57
digitalWrite(ledPin2, HIGH);
delay(200);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, HIGH);
delay(200);
digitalWrite(ledPin3, LOW);
}
Circuito armado:
Practica 3
Potencimetro: Lectura de seal Analgica
Descripcin:
El potencimetro es un dispositivo electromecnico que consta de una
resistencia de
valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la
divide
elctricamente.
58
Este cambio de resistencia puede utilizarse para medir desplazamientos
lineales o
angulares de una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensin.
Un potencimetro tambin puede ser usado como una resistencia variable (o
restato)
de dos terminales, en ese caso, se cortocircuitan dos de las tres patas del
potencimetro.
Material:
1 Potencimetro de 10k
1 Diodo LED
protoboard
Cables para realizar las conexiones
Cdigo en arduino:
59
val = analogRead(potPin); // lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende LED
delay(val); // detiene el programa por un tiempo val
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo val
}
Circuito armado:
Practica 4
El coche fantstico
60
buenas tcnicas para programar la placa E/S, sera interesante usar el coche
fantstico
como una metfora.
Material:
6 LED-s.
1 resistencias de 220 Ohmios.
Protoboard.
Cables para realizar las conexiones
61
Codigo en arduino:
int pin3 = 3;
int pin4 = 4;
int pin5 = 5;
int pin6 = 6;
int pin7 = 7;
int timer = 100; // Temporizador
void setup(){
pinMode(pin2, OUTPUT); // Configuracin de los PIN-es como salida
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(pin6, OUTPUT);
pinMode(pin7, OUTPUT);
}
void loop() {
digitalWrite(pin2, HIGH); // Enciende y apaga secuencialmente LED-s
delay(timer);
digitalWrite(pin2, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin6, HIGH);
delay(timer);
digitalWrite(pin6, LOW);
delay(timer);
digitalWrite(pin7, HIGH);
delay(timer);
digitalWrite(pin7, LOW);
delay(timer);
digitalWrite(pin6, HIGH);
delay(timer);
digitalWrite(pin6, LOW);
62
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
}
Circuito armado:
63
Practica 5
Sensor de Luz o LDR (Light Dependent Resistor):
Descripcion de la practica:
Vout=((Rbotton/(Rbottom+Rtop))*Vin
Materiales:
1 LDR
1 Resistencia de 5k
Protoboard
1 Diodo LED
64
Cdigo en arduino:
Circuito armado:
65
PRACTICA 6
Knop servo
Materiales:
Potencimetro
Protoboard
Servomotor
Cables
Codigo en arduino:
#include <Servo.h>
int val; // variable to read the value from the analog pin
66
void setup()
void loop()
val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value
between 0 and 180)
Circuito armado:
67
PRACTICA 7
Sweep servo
Materiales:
Servomotor
Protoboard
Cables
Esquema:
Cdigo en arduino:
#include <Servo.h>
68
void setup()
void loop()
for(pos = 0; pos <= 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
69
Circuito armado:
Practica 8
Sensor LM35
Material:
LM35
Protoboard
Cables
70
Esquema:
Codigo en arduino:
float temperatura;
float valor = 0 ;
void setup(){
Serial.begin(9600);
void loop() {
valor = analogRead(analog_pin);
temperatura = 5.0*valor*100/1024;
Serial.print("SENSOR = ");
Serial.println(temperatura);
delay(100);
71
Circuito armado:
Practica 9
Material:
Sensor ultrasnico
Protoboard
Cables
72
Esquema:
Cdigo en arduino:
long distancia;
long tiempo;
void setup(){
Serial.begin(9600);
pinMode(8, INPUT); /*activacin del pin 8 como entrada: tiempo del rebote
del ultrasonido*/
73
void loop(){
delayMicroseconds(5);
delayMicroseconds(10);
Serial.println("Distancia ");
Serial.println(distancia);
Serial.println(" cm");
delay(100);
Circuito armado:
74
Practica 18
Generador de notas musicales
Se trata de generar hasta 8 notas musicales por una de las salidas analgicas de
Arduino
PIN10-
Se debe crear un array (vector) de datos compuesto por los valores
correspondientes a
las 8 notas que se pretende sacar:
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
Se deben definir tambin el tiempo de pausa entre nota y nota y el tiempo de pausa
de
fin de secuencia de notas:
int tnota=100;
int pausa=100;
Las iteraciones para el recorrido de las 8 notas se realizan con una instruccin de
tipo
for:
for(n=0;n<8;n++)
El tiempo de activado y desactivado de la salida del zumbador tambin se resuelve
con
un bucle for:
for(m=0;m<=tnota;m++){
Cdigo en arduino:
int piezo=10;
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956}; //cadena con los
tiempos que corresponden a las distintas notas
int n=0;
int m= 0;
int tnota=100; //n de repeticiones del pulso. Nos da la duracin de la nota
int pausa=100;
void setup() {
pinMode(piezo,OUTPUT);
}
void loop(){
for(n=0;n<8;n++){ //iteracin que recorre la lista con las duraciones de los
75
pulsos de cada nota
for(m=0;m<=tnota;m++){
digitalWrite(piezo,HIGH);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que est a 5V la
salida del piezoelctrico
digitalWrite(piezo,LOW);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que est a 0V la
salida del piezoelctrico
}
delay(pausa); //tiempo en silencio entre escalas
}
}
Practica 19
Toca tonos desde el puerto serial
En este ejercicio usaremos un Piezo elctrico para reproducir tonos, aprovechando
la
capacidad que tiene el procesador para producir seales PWM y as reproducir
msica.
Un piezo elctrico no es ms que un dispositivo que puede ser usado tanto para
reproducir o detectar tonos. En nuestro ejemplo estamos conectando el piezo en el
pin
nmero 9, que permite enviar una seal PWN .
Los tonos pueden ser generados a partir de cualquier programa capaz de enviar
valores
ASCII a travs del puerto serial. Programas de Terminal, Processing, Pure Data o
Director, pueden ser usados para generar los tonos. En nuestro caso los caracteres
ASCII los enviaremos por la ventana de dialogo del IDE Arduino.
76
Lectura de un pulsador
Descripcin del ejercicio
Para generar una seal de tensin con el pulsador, se necesita un divisor de tensin.
Ejemplo:
Material
Resistencia de 1K Ohmios.
Pulsador.
diodo LED
Cables para realizar las conexiones.
77
Circuito armado:
78
Entrada Analgica
Se trata de configurar un canal de entrad analgico pin 5 y enviar el valor ledo al PC
para visualizarlo
Programa
/* Entrada Analgica */
int potPin = 5; // selecciona el pin de entrada para colocar el potencimetro
int val = 0; // variable para almacenar el valor ledo por la entrada analgica
void setup() {
beginSerial(9600);
}
void loop() {
val = analogRead(potPin); // lee el valor del canal de ENTRADA analgica
printInteger(val); // Enva al PC el valor analgico ledo y lo muestra en pantalla
serialWrite(10);
delay(100);
}
79
Simulacin de la luz de una vela
De trata de simular el movimiento de la llama de una vela. Hacemos uso de la
instruccin para generar un numero aleatorio que lo asignamos a una salida analgica
PWM y otro numero que lo asociamos a la variable de temporizacin (tiempo que
esperamos para cambiar el valor de la salida).
/*
* Simula luz de vela
* Saca por una de las salidas del puerto PWM un valor aleatorio que activa un LED
*
* 2007 Tod E. Kurt <tod@todbot.com>
* http://todbot.com/
*
*/
int ledPin = 9; // selecciona el puerto PWM
int val = 0; // define y pone a cero la variable "brillo"
int delayval = 0; // define el intervalo de cambio de valor de salida
void setup() {
80
randomSeed(0); // inicializa el generador de nmeros aleatorios
pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9
}
void loop() {
val = random(100,255); // genera un nmero aleatorio entre 100 y 255 que asigna
a la variable val
analogWrite(ledPin, val); // enva ese valor a la salida pin 9
delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo
asigna a la variable de temporizacin
delay(delayval); // espera un tiempo delayval medido en milisegundos
}
81
Construccin de un indicador de nivel (vmetro con
diodos led)
Se trata de construir u indicador de nivel que sea capaz de medir el valor de una seal
de
entrada generada por un potencimetro desde una entrada analgica.
Se establecern 3 diodos Led conectados a las salidas PIN6, PIN7 y PIN8. La entrada
la
conectaremos en la entrada analgica PIN 1 (analog IN1)
82
13. Encendido y apagado de una luz de manera analgica
Se trata de que enviemos hacia la salida 9 un valor analgico ascendente y
descendente
cclicamente comprendido entre 0 y 255 en incrementos de 5.
Para la realizacin de este ejercicio se debe emplear una estructura de programacin
tipo for que realice el incremento o decremento de una variable entre 0-255 y 255-0
con
un valor te retardo entre cambio de valor de 30 mseg.
83
analogWrite(ledpin, value); // Enviar valor a la salida (entre 0 y 255)
delay(30); // Esperar 30 ms para ver el efecto de variacin
}
for(value = 255; value >=0; value-=5) // Variacin de la variable de salida
entre MAX y MIN
{
analogWrite(ledpin, value);
delay(30);
}
}
84
Bibliografas:
ARDUINO_APUNTES_2013
http://www.aprenderobotica.com/group/eslaprimeravez/page/principiantes-arduino
http://www.prometec.net/librerias/
http://www.prometec.net/funciones-iii/
http://www.prometec.net/intro-programacion/
http://rduinostar.com/documentacion/programacion-arduino/estructura-de-un-sketch/
85