IDMRM0910 Trabajo Arduino V1.4

PLATAFORMA
ARDUINO
en diseo de Robots
Mviles
INTRODUCCIN AL DISEO DE MICRO-ROBOTS 2009/2010
GRUPO A
Ivn Cantero Mencerreyes Yen Hi Lee Lay
Vctor Alonso Mendieta Alberto De Lope
lvaro Tanarro Santamara Carlos de la Rubia Tuya
Pedro Quintero
Quintero
NDICE
1. Introduccin .........................................................................................................................................................4
2. Descripcin Hardware .....................................................................................................................................5
2.1. Microcontrolador Atmega168/V .............................................................................................................5
2.1.1. Caractersticas Generales..................................................................................................................5
2.1.2. Arquitectura............................................................................................................................................6
2.2 Tipos de placas y perifericos ................................................................................................................... 20
2.2.1 Duemilanove Arduino....................................................................................................................... 20
2.2.2 Diecimila Arduino............................................................................................................................... 26
2.2.3 Nano Arduino ....................................................................................................................................... 27
2.2.4 Mega Arduino ....................................................................................................................................... 28
2.2.5 Otras placas........................................................................................................................................... 31
3. Libreras en Arduino...................................................................................................................................... 33
3.1 Introduccin ................................................................................................................................................... 33
3.2 Lenguaje de programacin Arduino..................................................................................................... 34
3.2.1 Processing.............................................................................................................................................. 34
3.2.2 Funciones bsicas y operadores .................................................................................................. 34
3.2.3 AVR Libc ................................................................................................................................................. 37
3.2.4 Diferencias con Processing............................................................................................................. 40
3.2.5 Ejemplo prctico: Hola Mundo en Arduino ............................................................................. 41
3.3 Extendiendo la funcionalidad: Libreras ............................................................................................ 42
3.3.1 Libreras principales ......................................................................................................................... 42
3.3.2 Creacin de libreras ......................................................................................................................... 43
4. SOFTWARE......................................................................................................................................................... 47
4.1 Introduccin ................................................................................................................................................... 47
4.2 Instalacin del Software Arduino .......................................................................................................... 47
4.2.1 Instalacin del IDE en Windows .................................................................................................. 47
4.2.2 Instalacin del IDE en Mac OS X (v. 10.3.9 o posterior)..................................................... 51
4.2.3 Instalacin del IDE en GNU/Linux .............................................................................................. 53
4.3 Introduccin al entorno Arduino........................................................................................................... 54
4.3.1 Barra de Herramientas..................................................................................................................... 54
4.3.2. Mens ..................................................................................................................................................... 55
5. Control de motores con Arduino .............................................................................................................. 56
5.1 Control de motores DC con puente en H ............................................................................................ 56
5.1.1 Puente en H. . 56
5.1.2 Conexin del motor y el puente en H ......................................................................................... 57
5.1.3 Programacin....................................................................................................................................... 58
5.2 Control de motores con Motor Shield Arduino ........................................................................... 59
5.2.2 Control de motores de corriente continua con Motor Shield.......................................... 60
5.2.3 Control de servos con Motor Shield ........................................................................................... 61
5.2.4 Control de motores paso a paso con Motor Shield............................................................... 62
Plataforma Arduino en diseo de Robots Mviles Pgina 2

6. Aplicaciones de Arduino en Micro-Robots Mviles.......................................................................... 64
6.1 Introduccin ................................................................................................................................................... 64
6.2 Montaje ............................................................................................................................................................. 65
6.2.1 Componentes ......................................................................................................................................... 65
6.2.2 Construccin .......................................................................................................................................... 68
6.2.3 Test del Asuro........................................................................................................................................ 69
6.3 ATmega8 .......................................................................................................................................................... 72
6.3.1 Reemplazamiento del ATmega8.................................................................................................... 72
6.3.2 Cambiando los ficheros de Arduino............................................................................................. 72
6.3.3 Conexin y programacin de Asuro con Arduino .................................................................. 73
6.4 Funciones.. ...77
1. Introduccin

ste trabajo acerca de Arduino tiene como nico objetivo ilustrar a cualquier persona
que se inicie en el conocimiento y desarrollo de aplicaciones con la placa.
La elaboracin del trabajo se a echo repartiendo las secciones bsicas de conocimiento

de la placa de tal manera que se trata por un lado el chip controlador Atmega168/V y toda su
estructura interna a nivel hardware, y por otro lado se habla sobre distintos modelos de placas
en los que podemos encontrarnos insertado el chip, adems de sus principales caractersticas
fsicas y de perifricos. Despus de sto tratamos de definir el lenguaje de programacin y las
libreras que utiliza Arduino y tambin su entorno de desarrollo. Posteriormente se explicarn
dos casos prcticos en los que se muestra en su totalidad como llevar a cabo una aplicacin
con la placa. El primero de ellos trata sobre como se pueden controlar motores fcilmente con
una placa arduino

2. Descripcin Hardware
2.1. Microcontrolador Atmega168/V
2.1.1. Caractersticas Generales

El ATmega168 es un microcontrolador CMOS de 8 bits de baja potencia basado en

arquitectura RISC de AVR. Las caractersticas generales del ATmega168 son:
CPU AVR de Atmel de 8 bits de hasta 20MHz.

Arquitectura RISC, con 131 instrucciones de un ciclo de ejecucin, 32 registros
de 8 bits de propsito general.
16K bytes de memoria Flash, 512 bytes de SRAM y 1K bytes de EEPROM.
28 pines de I/O, para el encapsulado PDIP.
2 Temporizadores/Contadores de 8 bits, 1 Temporizador/Contador de 16 bits
con Comparadores.
6 Canales de PWM.
8 canales para el Convertidor Analgico/Digital de 10bits.
Comparador Analgico.
Comunicacin serie TWI, USART y SPI.
Fuentes de interrupcin tanto internas como externas.

La figura 1 muestra el diagrama de bloques del ATmega168:

Figura 1: Diagrama de Bloques.

2.1.2. Arquitectura.
A continuacin se muestra la arquitectura del ncleo AVR del ATmega168:

Figura 2: Arquitectura del AVR.
El Atmega168 utiliza una arquitectura Harvard con la memoria y el bus de programa y

de datos separados. Las instrucciones en la memoria de programa se ejecutan en un
solo nivel de pipeline. Mientras una instruccin se ejecuta, la siguiente instruccin se
carga en la memoria de programa. Esto permite que las instrucciones se ejecuten en
un solo ciclo de reloj. La mayora de estas instrucciones tienen un formato de 16 bits.
Registros de Propsito General.
Los 32 registros de 8 bits de propsito general se localizan al principio de la memoria

SRAM. En la siguiente figura se observa la distribucin de los registros:

Figura 3: Registros de Propsito General.
A cada registro se le asigna una direccin mapeada directamente en las primeras 32

posiciones de memoria de datos. Los 6 ltimos de estos 32 registros se pueden usar

como tres punteros de 16 bits para direccionamiento indirecto a memoria de datos.
Estos registros se denominan X, Y, Z.
ALU - Unidad Aritmtico-Lgica
La ALU opera en conexin directa con los 32 registros de propsito general. Las
operaciones aritmticas entre los registros se realizan dentro de un solo ciclo de reloj.
Las operaciones soportadas por la ALU se dividen en tres categoras principales:
aritmticas, lgicas, y funciones a nivel de bit. Algunas implementaciones de la
arquitectura proporcionan un multiplicador que realiza operaciones de multiplicacin
con o sin signo.
Registro de Estado
El registro de estado contiene informacin sobre los resultados de las operaciones

aritmtico-lgicas realizadas en la ALU. Esta informacin puede ser til para alterar el
flujo del programa y ejecutar operaciones condicionales. Las funciones asociadas a
este registro son: habilitar interrupciones (I), copia de un bit (T), flag de acarreo
intermedio (H), bit de signo (S), flag de overflow en complemento a 2 (V), Flag de
Negativo (N), flag de cero (Z), flag de acarreo (C). La figura X muestra la distribucin de
los bits:

Figura 4: Registro de Estado.
Puntero de Pila
La pila se usa principalmente para almacenar datos temporales, para almacenamiento

local de variables y para almacenar direcciones de retorno despus de interrupciones y
de llamadas a subrutina. El puntero de pila apunta a los datos de la SRAM que
funciona como pila. El espacio de la pila la define el usuario. El puntero de pila est
implementado en dos registros de 8 bits:

Figura 5: Puntero de Pila.

Memoria.
La arquitectura AVR est dividida en dos espacios principales de memoria, la Memoria

de Datos y la Memoria de Programa. Adems contiene una Memoria EEPROM para
almacenar datos adicionales de forma permanente.
Memoria Flash. Este microcontrolador contiene 16Kbytes de memoria Flash

reprogramable utilizada para almacenar programa. Dado que las instrucciones
tienen un formato de 16 o 32 bits, la memoria Flash se organiza en 8Kx16bits.
El Contador de Programa es un registro de 13 bits permitiendo el
direccionamiento a 8K de memoria de programa. Esta memoria est separada
en dos espacios de memoria, la seccin de arranque y la seccin de
aplicaciones.

Figura 6: Mapa de memoria Flash.

Memoria SRAM. La memoria SRAM del ATmega168 tiene una capacidad de
1Kbyte para datos. Las 32 primeras posiciones direccionan a los registros de
propsito general, los siguientes 64 localizaciones para registros estndar de
entrada/salida (registros de los perifricos), despus 160 posiciones para
memoria extendida de entrada/salida y las ltimas 1024 para memoria de
datos interna.

Figura 7: Mapa de memoria de SRAM.

Memoria EEPROM. El ATmega168 contiene 512 bytes de memoria EEPROM.
Esta memoria est mapeada en una zona de datos separada. Permite
operaciones tanto de lectura como de escritura. El acceso a la EEPROM est

asociado a tres registros: un Registro de Direcciones (EEAR), un Registro de
Datos (EEDR) y un Registro de Control (EECR).
.
2.1.3. Puertos de Entrada/Salida.
La figura 2 muestra la distribucin de terminales del microcontrolador para un
encapsulado PDIP:

Figura 8: Encapsulado PDIP.

A continuacin se detallan los terminales del ATmega168.
Los pines de alimentacin del chip: VCC y GND.
Los pines de alimentacin del Convertidor A/D: AVCC y AREF.
3 puertos paralelos bidireccionales de 8 bits (Puerto B), 7 bits (Puerto C) y 8

bits (Puerto D) con resistencia de pull-up interna seleccionable. Adems de la
funcin tpica de entrada/salida, estos puertos pueden ser configurados para
realizar otras funciones alternativas. As, por ejemplo:

o El Puerto B puede utilizarse como entrada de seal de reloj del chip
(XTAL1, XTAL2), salida del divisor de la seal de reloj (CLKO), entrada de
seal de reloj asncrona externa para los Temporizadores/Contadores
(TOSCI1, TOSCI2), entrada de eventos para los
Temporizadores/Contadores (ICP1), modulacin en pulso de seal PWM
(OC1A, OC2A, OC1B), fuentes de interrupcin externas
(PCINT0..PCINT7), comunicacin SPI (SCK, MISO, MOSI, SS).


Figura 9: Funciones Alternativas Puerto B.

o El Puerto C tiene como funciones alternativas las siguientes: entrada de
reset (RESET), canales de entrada al ADC (ADC0..ADC5), comunicacin
serie TWI (SCL, SDA) y tambin incorpora fuentes de interrupcin
externas (PCINT8..PCINT14).

Figura 10: Funciones Alternativas Puerto C.

o Las funciones alternativas del Puerto D son: canales de entrada al
Comparador Analgico (AIN0, AIN1), modulacin en pulso de seal
PWM (OC0A, OC0B, OC2B), entrada de seal de reloj sncrona externa
para los Temporizadores/Contadores (T0, T1), comunicacin serie
USART (XCK, TXD, RXD) y fuentes de interrupcin externas (INT0, INT1,
PCINT16..PCINT23).

Figura 11: Funciones Alternativas Puerto D.

Cada pin del puerto tiene asociado tres registros de 8 bits para cada puerto (x):
Registro de Direcciones (DDRx) para configurar la direccin de los pines del puerto
(entrada/salida), el Registro de Datos del Puerto (PORTx) para escribir o leer en el pin
correspondiente configurado como salida y para leer los pines del puerto configurados
como entrada el Registro de los Pines (PINx).


Figura 12: Configuracin de Pines.
En la siguiente figura se muestra el esquema correspondiente a un pin genrico con

todas las seales de control. Las seales PUOE, PUOV, DDOE, DDOV, PVOE, PVOV,
PTOE, DIEOE, DIEOV, DI y AIO son las que controlan las funciones alternativas de los
puertos.

Figura 13: Esquema de un Pin Genrico
2.1.4. Interrupciones.
El ATmega168 dispone de 26 fuentes de interrupcin asociadas a los perifricos del
microcontrolador y a seales externas al mismo. En la siguiente tabla se muestra la
direccin de memoria de programa asignada a cada interrupcin:

Figura 14: Tabla de Vectores de Interrupcin.
Las interrupciones externas del microcontrolador se controlan mediante los siguientes

registros:
Registro de Control A (EICRA): Este registro determina el modo de activacin

de las interrupciones INT0 e INT1, por flanco de subida o de bajada o por nivel
alto o bajo.

Figura 15: Registro de Control de Interrupciones Externas INT0 e INT1.
Registro Mscara (EIMSK): Con este registro se habilitan (1) o deshabilitan (0)
las fuentes de interrupcin externas INT0 e INT1, siempre y cuando el bit I del
Registro de Estado este activo.

Figura 16: Registro Mscara de Interrupciones Externas INT0 e INT1.
Registro de Bandera (EIFR): Su funcin es indicar cuando las interrupciones

INT0 e INT1 se han activado (1) o no (0).

Figura 17: Registro de Bandera de Interrupciones Externas INT0 e INT1.
De la misma manera las interrupciones externas adicionales denominadas PCINT

tienen asociados unos registros de configuracin de interrupciones externas similares:

Registro de Control (PCICR), Registros Mscara (PCMSK0..PCMSK2) y Registro de
Bandera (PCIFR).
2.1.4. Temporizador/Contador.
Este microcontrolador contiene tres Temporizadores/Contadores: un
Temporizadores/Contadores de 8 bits (TCNT0 y TCNT2) y un Temporizador/Contador
de 16 bits (TCNT1). Cada uno de los Temporizadores/Contadores contiene dos
unidades de comparacin que permiten la generacin de seales con modulacin en
pulso PWM (OCR). Se explicar el primero de ellos (TCNT0) siendo anlogo el
funcionamiento de los dems.
A continuacin se muestra el esquema de funcionamiento del

Temporizador/Contador:

Figura 18: Diagrama de Bloques del Temporizador/Contador 0.
El registro denominado TCNTn contiene el valor del temporizador o del contador en

todo momento. La lgica de control es la encargada de actuar sobre el registro TCNT,
mediante las seales direction (selecciona el sentido de la cuenta), count (incrementa
o decrementa la cuenta) y clear (pone a cero el registro). La seal de reloj clk va a fijar
el ritmo de cuenta. El selector de reloj permite seleccionar entre una seal de reloj
externa al microcontrolador por medio de Tn o entre la seal de reloj propia al
microcontrolador desde el preescaler. Con las seales top y botn se indica a la lgica
de control cuando el TCNT a alcanzado el valor mximo o mnimo respectivamente y
por consiguiente la lgica de control deber generar una interrupcin a travs de la
seal TOVn. El valor mximo puede ser fijado con los registros comparadores OCRnA u
OCRnB. La principal funcin de estos registros es generar una seal PWM, a travs del
generador de onda, en los pines OCnA OCnB. Cuando sus valores se igualan al del
contador TCNTn genern una interrupcin.

A continuacin se pasan a describir los principales registros asociados al Temporizador
Contador 0:

Registro de Control A (TCCR0A): Con este registro se controla la funcin
alternativa de los pines de salida para PWM (OC0A, OC1A, OC0B y OC1B) con
los bits COM0A0, COM0A1, COM0B0 y COM0B1. Tambin permite elegir entre
varios modos de funcionamiento del generador de onda con WGM01 y
WGM00.

Figura 19: Registro de Control A.
Registro de Control B (TCCR0B): Las funciones de este registro son habilitar los
registros de comparacin para el generador de onda (FOC0A, FC0B), seleccionar
el modo de funcionamiento (WGM02) y seleccionar la fuente de reloj
(CS00..CS02).

Figura 20: Registro de Control B.
Registro Temporizador/Contador (TCNT0): Este registro contiene el valor del

Temporizador/Contador. Los valores mximos y mnimos vendrn fijados por
los registro de control.

Figura 21: Registro Temporizador/Contador.
Registros de Comparacin (OCR0A, OCR0B): Contienen el valor a comparar con

el Registro Temporizador/Contador TCNT0.

Figura 22: Registro de Comparacin A (B, anlogo).
Registro Mscara de Interrupcin (TIMSK0): Habilita las interrupciones

(OCF0A, OCF0B) asociadas al registro de comparacin y a la de desborde
(TOV0) del Temporizador/Contador.

Figura 23: Registro Mscara de Interrupciones.
Registro Bandera de Interrupcin (TIFR0): Sus bits se ponen a uno cuando las
interrupciones de comparacin y la de desborde se activan.

Figura 24: Registro Bandera de Interrupciones.

2.1.4. Convertidor Analgico/Digital

El ADC incluido en el ATmega168 es un convertidor analgico de 10 bits basado en el
mtodo de conversin por aproximaciones sucesivas. El ADC est conectado a un
multiplexor analgico de 8 bits lo que permite seleccionar entre 8 fuentes de
conversin.

Figura 25: Diagrama de Bloques del ADC.
El funcionamiento del convertidor es el siguiente. Mediante el registro ADMUX y a

travs un decodificador se selecciona el canal sobre el que se va a realizar la
conversin. Una vez seleccionado, la seal del canal se compara con una seal
analgica de referencia proporcionada por el DAC a travs del comparador. En funcin
del resultado de la comparacin, la lgica de conversin incrementar o decrementar
la seal digital de referencia que se proporciona al DAC quin se encargar de
convertir esta nueva seal de referencia a un valor analgico. Cuando el resultado de
la comparacin sea igual, la seal digital de referencia ser el resultado de la
conversin y se proporcionar al registro de datos del convertidor (ADCH/ADCL). El

registro ADCSRA es el encargado de generar las seales de control del ADC como la
seal de enable, la seal de inicio de conversin, el prescaler de conversin y las
seales de interrupcin.
Para el control de las distintas funcionalidades del Convertidor A/D se utilizan los
siguientes registros:

Registro de Seleccin del Multiplexor (ADMUX): Permite seleccionar distintos
voltajes de referencia (REFS1, REFS0) y tambin el canal de entrada al ADC
(MUX0..MUX3). EL bit ADLAR ajusta el resultado a la derecha o izquierda del
registro de datos.

Figura 26: Registro de Seleccin del Multiplexor.
Registro de Estado y de Control A (ADCSRA): Este registro habilita el

Convertidor (ADEN), inicia la conversin de forma interna (ADSC), habilita el
inicio de conversin mediante una seal externa (ADATE), bandera de
interrupcin que indica el fin de la conversin (ADIF), habilita la interrupcin
(ADIE) y varia la frecuencia de conversin a partir de un preescaler
(ADPS0..ADPS2).

Figura 27: Registro de Estado y de Control A.
Registros de Datos (ADCH, ADCL): Estos 2 registros de 8 bits contienen el

resultado de la conversin.

Figura 28: Registros de Datos.
Registro de Estado y de Control B (ADCSRB): Determina las fuentes externas

para el inicio de conversin.

Figura 29: Registro de Estado y de Control B.
Registro para Deshabilitar Entrada Digital (DIDR0): Este registro deshabilita la

funcin de entrada/salida digital de los canales de entrada al Convertidor A/D
para la conversin.
1.2.5. Comparador Analgico.

El comparador analgico compara el valor de dos seales de entrada introducidas a
travs de los pines AIN0 y AIN1. Cuando el voltaje en la entrada positiva (AIN0) es
mayor que el voltaje en la entrada negativa (AIN1) la salida del comparador ACO se
pone a uno en caso contrario se pone a cero. El diagrama de bloques se muestra en la
siguiente figura:

Figura 31: Diagrama de Bloques del Comparador Analgico.
A continuacin se describen los registros que utiliza este perifrico:
Registro de Estado y de Control B (ADCSRB): El bit ACME permite elegir la

seal a introducir en el terminal negativo. Si es (1) se introduce la seal
seleccionada en el Multiplexor del ADC y si es (0) se introduce el terminal AIN1.

Registro de Control y de Estado (ACSR): conecta la alimentacin del

Comparador (ACD), permite elegir entre dos seales de referencia a introducir
en el terminal positivo: AIN0 y una referencia interna (ACBG), contiene la salida
del comparador (ACO), tambin tiene la bandera asociada a la interrupcin
(ACI), habilita la interrupcin (ACIE), permite habilitar el disparo del
Temporizador/Contador con la seal de salida ACO (ACIC) y selecciona entre
varios modos de interrupcin asociada a la salida ACO (ACIS1, ACIS0).

Figura 33: Registro de Control y de Estado.
Registro para Deshabilitar Entrada Digital (DIDR1): Este registro deshabilita la

funcin de entrada/salida digital de los canales de entrada al Comparador
Analgico.

Figura 34: Registro de Control y de Estado.
Referencias
[1]Datasheet ATmega48/68/168/V AVR Atmel, 2007-2009.
2.2Tipos de placas y perifericos

Se va a tratar de explicar las caractersticas hardware de distintas placas y los

perifricos que se pueden incorporar o que por el contrario vienen montados de serie
en dichas placas. Para ello explicamos en principio la placa DUEMILANOVE ARDUINO y
posteriormente veremos otros modelos indicando lo ms importante que las difiere de
la DUEMILANOVE.
2.2.1 Duemilanove Arduino

Descripcin general
El Duemilanove Arduino ("2009") es una placa basada en el microcontrolador
ATmega168 o Atmega328. Cuenta con 14 entradas digitales / salida (de los cuales 6 se
pueden utilizar como salidas PWM), 6 entradas analgicas, un oscilador de cristal de 16
MHz, una conexin USB, un conector de alimentacin, una cabecera de ICSP, y un
botn de reinicio. Contiene todo lo necesario para apoyar al microcontrolador, basta
con conectarlo a un ordenador con un cable USB o a la red con un AC a DC adaptador o
batera para empezar.
Resumen
-Microcontrolador ATmega168 Atmega328
-Tensin de funcionamiento: 5V.
-Entrada de voltaje (recomendado): 7-12V.
-Voltaje de entrada (lmites): 6-20V.
-Pins Digitales I / O: 14 (de las cuales 6 proporcionar una salida PWM).
-Pins de entrada analgica: 6.
- Corriente DC de pin I / O: 40 mA..
-Corriente DC para Pin de 3.3V: 50 mA.
-Memoria Flash: 16 KB (ATmega168) o de 32 KB (Atmega328) de los cuales 2 KB
utilizado por el bootloader (arranque).
-Memoria SRAM: 1 KB (ATmega168) o 2 KB (Atmega328).
-Memoria EEPROM 512 bytes (ATmega168) o 1 KB (Atmega328).
-Velocidad del reloj de 16 MHz.

Alimentacin
El Duemilanove Arduino puede ser alimentado a travs de la conexin USB o con
una fuente de alimentacin externa. La fuente de alimentacin se selecciona
automticamente.
La alimentacin externa (no USB) puede proceder de un adaptador AC a DC o una
batera. El adaptador se puede conectar con una clavija 2,1 mm de centro-positivo en
el enchufe de alimentacin de la placa. Una batera puede ser insertada entre el GND y
el pin de alimentacin.

La tarjeta puede operar con una fuente externa de 6 a 20 voltios. Si se suministra
con menos de 7V, sin embargo, el pin de 5V puede proporcionar menos de estos cinco
voltios y la placa puede ser inestable. Si utiliza ms de 12V, el regulador de voltaje
puede sobrecalentarse y daar la placa. El rango recomendado es de 7 a 12 voltios.

Los pines de alimentacin son los siguientes:

VIN. Se puede proporcionar el voltaje de entrada a travs de este pin a la placa
Arduino cuando est usando una fuente de alimentacin externa (en lugar de 5 voltios
de la conexin USB o otra fuente de alimentacin regulada).
5V. Se consiguen 5V mediante una fuente de alimentacin reguladora. Utilizada
para alimentar el microcontrolador y otros componentes en la placa.
3V3. Unos 3,3 voltios generados por el chip FTDI situado en la placa. Corriente
mxima de 50 mA.
GND. Conexin de tierra.

Memoria
El ATmega168 tiene 16 KB de memoria flash para almacenar el cdigo (de los
cuales 2 KB se utiliza para el gestor de arranque), la Atmega328 dispone de 32 KB,
(tambin con 2 KB utilizado para el gestor de arranque). El ATmega168 tiene 1 MB de
SRAM y 512 bytes de EEPROM (que puede ser ledo y escrito con la biblioteca de
EEPROM); la Atmega328 tiene 2 MB de SRAM y 1 KB de memoria EEPROM.

Entrada y Salida
Cada uno de los 14 pines digitales en la Duemilanove puede ser utilizado como
una entrada o salida, utilizando las funciones pinMode () digitalWrite () y digitalRead ().
Operan a 5 voltios. Cada pin puede proporcionar o recibir un mximo de 40 mA y
tienen una resistencia interna (desconectado por omisin) de 20-50 kOhms.
Adems, algunos pines tienen funciones especializadas:

Serial: 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmisir (TX) datos TTL
serie. Estos pines estn conectados a los pines correspondientes del chip serie USB
FTDI-a-TTL.

Interrupciones: 2 y 3. Estos pins se pueden configurar para activar una
interrupcin en un valor bajo, un flanco de subida o bajada.
PWM: 3, 5, 6, 9, 10 y 11. Proporcionar 8-bit con salida PWM mediante la
funcin analogWrite ().

SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos son pines de apoyo a la
comunicacin SPI, que aunque est implementada por el hardware subyacente, no
est incluida actualmente en la lengua Arduino.
LED: 13. Hay un LED integrado conectado al pin digital 13. Cuando el pin esta en
nivel alto, el LED est encendido, y cuando est a nivel bajo bajo, el Led es apagado.

El Duemilanove tiene 6 entradas analgicas, cada una de las cuales ofrecen 10
bits de resolucin (es decir, 1024 valores diferentes). Por defecto, que miden desde el
masa hasta 5 voltios, aunque es posible cambiar el extremo superior de su rango con el
pin AREF y la funcin analogReference(). Adems, algunos pins se han especializado
ms an en cuanto a su funcionalidad:

I2C: 4 (SDA) y 5 (SCL). Apoyo I2C (IST) de comunicacin que utiliza la biblioteca
Wire.

Hay otro par de pines en la placa:

Aref. Voltaje de referencia para las entradas analgicas. Usado con
analogReference().
Reset. Llevando esta lnea a nivel bajo se puede reiniciar el microcontrolador.

A continuacin se muestra el esquema de conexin de la placa


Comunicacin
El Duemilanove Arduino tiene una serie de facilidades para comunicarse con un
ordenador, con otro Arduino, o con otros microcontroladores. El ATmega168 y
Atmega328 proporcionan una comunicacin serie UART TTL (5V), que est disponible
en los pines digital 0 (RX) y 1 (TX).
Un chip FT232RL FTDI canaliza las comunicaciones en serie de esta placa a travs
del USB y los drivers de FTDI (incluido con el software Arduino) proporcionan un
puerto virtual COM siempre y cuando est el software correspondiente instalado en el
equipo. El software Arduino incluye un monitor serie que permite a que datos simples
de texto puedan ser enviados hacia y desde la placa Arduino. El LED RX y TX en la placa
parpadear cuando se estn transmitiendo datos a travs del chip FTDI y conexin USB
con el ordenador (pero no para la comunicacin de serie en los pines 0 y 1).
Una biblioteca SoftwareSerial permite la comunicacin serie en cualquiera de los
pines digital de la Duemilanove's.
El ATmega168 y Atmega328 tambin soporta I2C (IST) y comunicacin SPI. El
software incluye una biblioteca de Arduino Wire para simplificar el uso del bus I2C.
Para utilizar la comunicacin de la SPI, consultar las caractersticas tcnicas del
ATmega168 o del Atmega328.

Programacin
El Duemilanove Arduino puede ser programado con el software Arduino.
Seleccione "Arduino Duemilanove ATmega168" o "W Arduino Duemilanove
Atmega328" desde el men Herramientas> Board (de acuerdo con el microcontrolador
en su tablero).

El ATmega168 o Atmega328 en el Duemilanove Arduino de serie viene con un
cargador de arranque que le permite cargar el nuevo cdigo, sin el uso de un
programador hardware externo. Se comunica usando el protocolo original STK500.
Tambin puede omitir el gestor de arranque y el programa del microcontrolador
a travs de la ICSP (In Circuito Serial).

Reset por software
En lugar de exigir apretar el botn de reinicio antes de una carga de software en
el controlador, el Duemilanove Arduino est diseado de una manera que le permite
resetear el software se ejecuta desde un ordenador conectado. Una de las lneas de
control de flujo por hardware (DTR) de la FT232RL est conectado a la lnea de reset de
la ATmega168 o Atmega328 a travs de un condensador de 100 nanofaradio. Cuando
se activa esta lnea (tomando nivel bajo de tensin), la lnea de reseteo del chip
permanece activa el tiempo necesario para restablecer dicho chip. El software Arduino

utiliza esta capacidad, ya que le permite la carga de cdigo con tan slo pulsar el botn
de subida en el entorno Arduino. La carga de datos en el controlador puede llevar poco
tiempo ya que podemos coordinar bien el tiempo en nivel bajo de DTR, con el inicio de
la subida de datos.
Esta configuracin tiene otras implicaciones. Cuando el Duemilanove est
conectado al ordenador ya sea un Mac OS X o Linux, se resetea cada vez que se realiza
una conexin a ella desde el software (a travs de USB). Aproximadamente durante
medio segundo, el gestor de arranque se ejecuta en el Duemilanove. Est programado
para ignorar los datos con formato incorrecto (es decir, nada, adems de una carga de
cdigo nuevo), y cuando los primeros bytes de datos enviados llegan a la placa, se
interceptan dichos datos y despusla conexin se abre. Si una aplicacin se ejecuta en
la placa y recibe del exterior cualquier tipo de datos cuando se inicia por primera vez,
asegrese de que el software con el que se comunica espera un segundo despus de la
apertura de la conexin y antes de enviar los datos.
El Duemilanove contiene una traza que se puede cortar para deshabilitar la auto-
reset. Las almohadillas a ambos lados de la traza se pueden soldar en conjunto para
volver a habilitarla. Es llamado "reset-en". Tambin se puede deshabilitar la funcin
auto-reset, conectando una resistencia de 110 ohmios de 5V a la lnea de reajuste.

USB Proteccin de sobreintensidad
El Duemilanove Arduino tiene un fusible reseteable que protege a los puertos
USB de su ordenador de cortos y picos de corriente. Aunque la mayora de los equipos
proporcionan su proteccin interna, el fusible proporciona una capa adicional de
proteccin. Si ms de 500 mA se aplica al puerto USB, el fusible rompe
automticamente la conexin hasta que se elimina el corto o sobrecarga.

Caractersticas fsicas
La longitud mxima y ancho de la placa Duemilanove son 2,7 y 2,1 pulgadas
respectivamente, con el conector USB y conector de potencia que se extiende ms all
de la dimensin anterior. Tres orificios de los tornillos que la Junta pudiera estar
conectada a una superficie o carcasa. Hay que tener en cuenta que la distancia entre
los pines digitales 7 y 8 es de 160 milsimas de pulgada (0,16"), por lo que no es un
mltiplo de la distancia (de 100 milsimas de pulgada) entre los otros pines.


2.2.2 Diecimila Arduino

Origen
"Diecimila" significa 10.000 en italiano y se llamaba as al marcar el hecho de que ms

de 10.000 tarjetas Arduino se han hecho.

Resumen
Microcontrolador ATmega168 nicamente por lo que por ejemplo en cuanto a
memoria posee solo las caractersticas de este controlador.

Memoria
El ATmega168 tiene 16 KB de memoria flash para almacenar el cdigo (de los

cuales 2 KB se utiliza para el gestor de arranque). Dispone de 1 MB de SRAM y 512
bytes de EEPROM (que puede ser ledo y escrito con la biblioteca de EEPROM).

2.2.3 Nano Arduino

Descripcin general

El Nano Arduino es una placa pequea, completa basada en el Atmega328 (Arduino
Nano 3,0) o ATmega168 (Arduino Nano 2.x). Tiene ms o menos la misma
funcionalidad de la Duemilanove Arduino, pero en un paquete diferente. Le falta slo
el conector de alimentacin DC, y trabaja con un mini cable USB en lugar de uno
normal. El Nano fue diseado y est siendo producido por Gravitech.
Especificaciones:
Dimensiones 0.73 "x 1.70".

Potencia:
El Nano Arduino puede ser alimentado a travs de la Mini-conexin USB, con
entre 6-20V mediante una fuente de alimentacin externa no regulada(pin 30), o 5V
regulados mediante fuente reguladora (pin 27). Se toma como fuente de energa la
que tenga mayor tensin y se activa automticamente.
El chip FTDI FT232RL montado en el Nano es alimentado slo si la placa est

siendo alimentada por USB. Como resultado, cuando se ejecuta en no-USB
(alimentacin externa), la salida de 3.3V (que es suministrada por el chip FTDI) no est
disponible y los LED RX y TX parpadearn si los pins digitales 0 o 1 estn a nivel alto.


Memoria
Podemos obtener el nano con el controlador ATmega168 que tiene 16 KB de
memoria flash para almacenar el cdigo (de los cuales 2 KB se utiliza para el gestor de
arranque), o con la Atmega328 que dispone de 32 KB, (tambin con 2 KB utilizado para
el gestor de arranque). El ATmega168 tiene 1 MB de SRAM y 512 bytes de EEPROM
(que puede ser ledo y escrito con la biblioteca de EEPROM); la Atmega328 tiene 2 MB
de SRAM y 1 KB de memoria EEPROM.

2.2.4 Mega Arduino

La Mega Arduino es una placa basada en el microcontrolador ATMEGA1280

(Directa). Cuenta con 54 entradas digitales / salida (de los cuales 14 se pueden utilizar
como salidas PWM), 16 entradas analgicas, 4 UART (puertos serie del hardware), un
oscilador de cristal de 16 MHz, una conexin USB, un conector de alimentacin, una
cabecera de ICSP, y un botn de reinicio. Contiene todo lo necesario para apoyar el
microcontrolador, basta con conectarlo a un ordenador con un cable USB o el poder
con un AC a DC adaptador o batera para empezar. La Mega es compatible con la
mayora de los escudos diseados para la Duemilanove Arduino o Diecimila.

Resumen
Microcontrolador ATMEGA1280.
SRAM 8 KB.
EEPROM 4 KB.

Alimentacin
La Mega Arduino puede ser alimentada a travs de la conexin USB o con una
fuente de alimentacin externa. La fuente de alimentacin se selecciona
automticamente.
La tarjeta puede operar en una fuente externa de 6 a 20 voltios. Si se suministra

con menos de 7V, sin embargo, el regulador de 5V puede proporcionar menos de cinco
voltios y la placa puede ser inestable. Si utiliza ms de 12V, el regulador de voltaje
puede sobrecalentarse y daar el tablero. El rango recomendado es de 7 a 12 voltios.

Memoria
El ATMEGA1280 cuenta con 128 KB de memoria flash para almacenar el cdigo (de 4
KB, que se utiliza para el gestor de arranque), 8 MB de SRAM y 4 KB de EEPROM (que
puede ser ledo y reescrito con la biblioteca de EEPROM).

Entrada y Salida.
Cada uno de los 54 pines digital de la Mega se puede utilizar como una entrada o
salida, utilizando las funciones pinMode (), digitalWrite (), y digitalRead (). Operan a 5
voltios. Cada pin puede proporcionar o recibir un mximo de 40 mA y tiene una
resistencia interna de 20-50 kOhms. Adems, algunos pines tienen funciones
especializadas:

Serial: 0 (RX) y 1 (TX), 1 de serie: 19 (RX) y 18 (TX), 2 de serie: 17 (RX) y 16 (TX), 3 de
serie: 15 (RX) y 14 (TX). Se utiliza para recibir (RX) y transmisin (TX) datos TTL serie.
Pins 0 y 1 son tambin conectados a los pines correspondientes de la USB FTDI-a-chip
TTL serie.
Factores externos Interrupciones: 2 (interrupcin 0), 3 (de interrupcin 1), 18
(interrupcin de 5), 19 (de interrupcin 4), 20 (de interrupcin 3), y 21 (de interrupcin
2). Estos pins se pueden configurar para que activen una interrupcin cuando stos
tenga un valor bajo, o haya un flanco de subida o bajada.
PWM: 0 a 13. Proporciona 8-bit de salida PWM con la funcin analogWrite().
SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). Estos son pines de apoyo a la

comunicacin SPI, que aunque est implementada por el hardware subyacente,
actualmente no est incluida en la lengua Arduino.

LED: 13. Hay un built-in LED conectado al pin digital 13. Cuando el pin es de alto
valor, el LED est encendido, cuando el pasador es bajo, es apagado.
I2C: 20 (SDA) y 21 (SCL). Pins de apoyo de comunicacin I2C (IST) que utiliza la
biblioteca Wire. Estos pines no estn en la misma ubicacin que los pines I2C en el
Duemilanove o Diecimila.

El Mega cuenta con 16 entradas analgicas, cada una de las cuales ofrecen 10 bits de
resolucin (es decir, 1024 valores diferentes). Por defecto, que miden desde el masa a
5 voltios, aunque es posible cambiar el nivel superior de su rango con el pin AREF y
analogReference () la funcin.

Adems hay un par de pins en la placa:

Aref. Voltaje de referencia para las entradas analgicas. Usado con analogReference
().
Reset. Llevando esta lnea a nivel bajo se reiniciar el microcontrolador.

Comunicacin
La Mega Arduino tiene una serie de facilidades para comunicarse con un ordenador,
otro Arduino, o de otros microcontroladores. El ATMEGA1280 proporciona cuatro
interfaces UART hardware para TTL (5V) de comunicaciones serie. Un FT232RL FTDI
que canaliza dicha comunicacin seriea travs de USB y los drivers de FTDI (incluidos
con el software Arduino) proporcionar un puerto COM virtual, siempre que se tenga
instalado el software correspondiente en el equipo. El software Arduino permite enviar
datos simples de texto hacia y desde la placa Arduino. El LED RX y TX en la placa
parpadear cuando se estn transmitiendo datos a travs del chip FTDI y conexin
USB.
Una biblioteca SoftwareSerial permite la comunicacin de serie en cualquiera de los pines

digitales del Mega.

2.2.5 Otras placas
Existen ms mdelos de placas en el mercado, pero estas difieren muy poco a
nivel fsico de las ya explicadas. Por ello vamos tan solo a mencionar bsicamente las
placas y a ilustrarlas con la correspondiente fotografa, para saber cual elegir en
funcin de la aplicacin que quisieramos realizar.

Lilypad -> Es una pequea placa diseada para aplicaciones con las que tuviramos que llevar
encima, por ejemplo ropa inteligente que en la aplicacin ya existe implementada con
Arduino.

Mini-> placa que se caracteriza por ser la ms pequea de las disponibles
Arduino serial-> placa que implementa una comunicacin serie RS232 como principal
caracterstica
Pro mini-> diseada para aplicaciones low-cost y que requieran un tamao reducido

Bluetooth Arduino
El BT Arduino es una placa Arduino con mdulo incorporado Bluetooth, que

permite la comunicacin inalmbrica.
Adems, tiene algunas otras diferencias con una GN Arduino:
El uso de un convertidor DC-DC, lo que permite a la placa ser alimentado con un

mnimo de 1,2 V, pero con un mximo de 5,5 V. voltajes superiores o polaridad
invertida en la fuente de alimentacin romperan la placa.
Pin 7 est conectado al pin de reset del mdulo Bluetooth.
Utilizar nicamente la comunicacin en serie a 115200 baudios, porque es la
velocidad a la que el mdulo se ha configurado para utilizar.

El mdulo Bluetooth utilizado es el WT11 Bluegiga, versin iWrap.El mdulo Bluetooth
se puede configurar con los comandos que se distribuyen desde el puerto serie de la
ATmega168.

--
[1] http://arduino.cc/en/Main/Hardware
[2] http://arduino.cc/en/Main/ArduinoBoardDuemilanove
[3] http://arduino.cc/en/Main/ArduinoBoardDiecimila
[4] http://arduino.cc/en/Main/ArduinoBoardMega
[5] http://www.bluegiga.com/WT11_Class_1_Bluetooth_Module

3. Libreras en Arduino
3.1 Introduccin
La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en
el popular lenguaje de programacin de alto nivel Processing1. Sin embargo, es posible
utilizar otros lenguajes de programacin y aplicaciones populares en Arduino [1].
Algunos ejemplos son:
Java
Flash (mediante ActionScript)

Processing
MaxMSP (entorno grfico de programacin para aplicaciones musicales, de

audio y multimedia)
VVVV (sntesis de vdeo en tiempo real)
Adobe Director
Python
Ruby
C
C++ (mediante libSerial o en Windows)
C#
Cocoa/Objective-C (para Mac OS X)
Linux TTY (terminales de Linux)
3DVIA Virtools (aplicaciones interactivas y de tiempo real)
SuperCollider (sntesis de audio en tiempo real)
Instant Reality (X3D)
Second Life
Liberlab (software de medicin y experimentacin)
BlitzMax (con acceso restringido)
Squeak (implementacin libre de Smalltalk)
Mathematica
Matlab
Mono
Isadora (Interactividad audiovisual en tiempo real)
PERL
Visual Basic .NET
VBscript
Esto es posible debido a que Arduino se comunica mediante la transmisin de datos en
formato serie que es algo que la mayora de los lenguajes anteriormente citados
soportan. Para los que no soportan el formato serie de forma nativa, es posible utilizar

1 En realidad, Arduino est basado en Wiring que a su vez se basa en Processing.

software intermediario que traduzca los mensajes enviados por ambas partes para
permitir una comunicacin fluida. Es bastante interesante tener la posibilidad de
interactuar Arduino mediante esta gran variedad de sistemas y lenguajes puesto que
dependiendo de cuales sean las necesidades del problema que vamos a resolver
podremos aprovecharnos de la gran compatibilidad de comunicacin que ofrece.
No obstante en este trabajo nos centraremos en el lenguaje que acepta por defecto: El
lenguaje de programacin Arduino.
3.2 Lenguaje de programacin Arduino

3.2.1 Processing
Processing es un lenguaje de programacin orientado al desarrollo gil de aplicaciones
interactivas y multimedia cuya sintaxis est influenciado por Java, OpenGL, PostScript y
C [2]. Es un lenguaje bastante moderno creado en 2001 por Casey Reas y Ben Fry
quienes lo desarrollaron en el MIT Media Lab.
El lenguaje se cre con el objetivo de permitir a personas con escasos o nulos

conocimientos de programacin obtener programas de forma fcil y rpida que
ofrecieran efectos visuales de forma rpida. Esto lo consigue abstrayendo gran parte
de la complejidad de ciertas funciones.
A partir de Processing nacieron varios proyectos relacionados que siguieron su filosofa

y se centraban en otros aspectos. De estos proyectos destacan Wiring, Fritzing y
Arduino.
3.2.2 Funciones bsicas y operadores

Arduino esta basado en C y soporta todas las funciones del estndar C y algunas de
C++ [3]. A continuacin se muestra un resumen con todas la estructura del lenguaje
Arduino:
Estructuras de control
Condicionales: if, if...else, switch case
Bucles: for, while, do... while
Bifurcaciones y saltos: break, continue, return, goto

Sintaxis
Delimitadores: ;, {}
Comentarios: //, /* */
Cabeceras: #define, #include
Operadores aritmticos
Asignacin: =
Operaciones: +, -, *, /, %
Operadores de comparacin
==, !=, <, >, <=, >=
Operadores Booleanos
&&, ||, !
Operadores de acceso a punteros

*, &
Operadores de bits
&, |, ^, ~, <<, >>
Operadores compuestos
Incremento/decremento de variables: ++, --
Asignacin y operacin: +=, -=, *=, /=, &=, |=
Manipulacin de puertos
Los registros de puertos permiten la manipulacin a mas bajo nivel y de forma mas
rpida de los pines de E/S del microcontrolador de las placas Arduino [4]. Los pines de
las placas Arduino estn repartidos entre los registros B(0-7), C (analgicos) y D(8-13).
Mediante las siguientes variables podemos ver y modificar su estado:
DDR[B/C/D]: Data Direction Register (o direccin del registro de datos) del

puerto B, C D. Sirve para especificar que pines queremos usar como de
entrada y cuales de salida. Variable de Lectura/Escritura.
PORT[B/C/D]: Data Register (o registro de datos) del puerto B, C D. Variable
de Lectura/Escritura.
PIN[B/C/D]: Input Pins Register (o registro de pines de entrada) del puerto B, C
D. Variable de slo lectura.

Por ejemplo, para especificar que queremos utilizar los pines 1 a 7 como salidas y
el 0 como entrada, bastara utilizar la siguiente asignacin:

DDRD = B11111110;

En cuanto al tratamiento de las variables tambin comparte un gran parecido con el
lenguaje C.
Constantes
HIGH / LOW: niveles alto y bajo en pines. Los niveles altos son aquellos de 3
voltios o ms.
INPUT / OUTPUT : entrada o salida
true / false
Tipos de datos
void, boolean, char, unsigned char, byte, int, unsigned int, word, long, unsigned
long, float, double, string, array
Conversin entre tipos

Estas funciones reciben como argumento una variable de cualquier tipo y devuelven
una variable convertida en el tipo deseado.
char(), byte(), int(), word(), long(), float()
Cualificadores y mbito de las variables

static , volatile , const
Utilidades
sizeof()
En cuanto a las funciones bsicas del lenguaje nos encontramos con las siguientes:
E/S Digital
pinMode(pin, modo)
digitalWrite(pin, valor)
int digitalRead(pin)
E/S Analgica
analogReference(tipo)
int analogRead(pin)
analogWrite(pin, valor)
E/S Avanzada
shiftOut(dataPin, clockPin, bitOrder, valor)
unsigned long pulseIn(pin, valor)

Tiempo
unsigned long millis()
unsigned long micros()
delay(ms)
delayMicroseconds(microsegundos)
Matemticas
min(x, y), max(x, y), abs(x), constrain(x, a, b), map(valor, fromLow, fromHigh,

toLow, toHigh), pow(base, exponente), sqrt(x)
Trigonometra
sin(rad), cos(rad), tan(rad)
Nmeros aleatorios
randomSeed(semilla), long random(mx), long random(mn, mx)
Bits y Bytes
lowByte(), highByte(), bitRead(), bitWrite(), bitSet(), bitClear(), bit()
Interrupciones externas
attachInterrupt(interrupcin, funcin, modo)
detachInterrupt(interrupcin)
Interrupciones
interrupts(), noInterrupts()
Comunicacin por puerto serie [5]
Las funciones de manejo del puerto serie deben ir precedidas de Serial. aunque no
necesitan ninguna declaracin en la cabecera del programa. Por esto se consideran
funciones base del lenguaje.
begin(), available(), read(), flush(), print(), println(), write()

Como se ha podido comprobar, si conocemos el lenguaje C, no tendremos dificultades
para programar en Arduino puesto que se parecen enormemente. Tan slo debemos
aprender algunas funciones especficas de que dispone el lenguaje para manejar los
diferentes parmetros de Arduino. Se pueden construir aplicaciones de cierta
complejidad sin necesidad de muchos conceptos previos.

3.2.3 AVR Libc

Los programas compilados con Arduino se enlazan contra AVR Libc [3] por lo que
tienen acceso a algunas de sus funciones. AVR Libc es un proyecto de software libre
con el objetivo de proporcionar una librera C de alta calidad para utilizarse con el
compilador GCC sobre microcontroladores Atmel AVR. Se compone de 3 partes:

avr-binutils
avr-gcc
and avr-libc
La mayora del lenguaje de programacin Arduino est escrita con constantes y
funciones de AVR y ciertas funcionalidades slo se pueden obtener haciendo uso de
AVR [6].
Interrupciones
Para desactivar las interrupciones:
cli(); // desactiva las interrupciones globales

Para activarlas:
sei(); // activa las interrupciones

Esto afectar al temporizador y a la comunicacin serie. La funcin
delayMicroseconds() desactiva las interrupciones cuando se ejecuta.
Temporizadores
La funcin delayMicroseconds() crea el menor retardo posible del lenguaje Arduino
que ronda los 2s.
Para retardos mas pequeos se debe utilizar la llamada de ensamblador 'nop' (no
operacin). Cada sentencia 'nop' se ejecutar en un ciclo de mquina (16 Mhz): unos
62.5ns. Se hara de la siguiente manera:
__asm__("nop\n\t");

Manipulacin de puertos
La manipulacin de puertos con cdigo AVR es mas rpida que utilizar la funcin
digitalWrite() de Arduino.
Establecer Bits en variables

cbi y sbi son mecanismos estndar (AVR) para establecer o limpiar bits en PORT y otras
variables.
Ser necesario utilizar las siguientes cabeceras para poder utilizarlos:
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
Para utilizarlas hay que pasarles como argumento la variable PORT y un pin para
establecerlo o limpiarlo.


Gracias a estos pequeos hacks tendremos la posibilidad de mejorar los tiempos de
ejecucin de ciertas tareas crticas o de aquellas que se repitan muchas veces
obteniendo mejores resultados. No obstante el cdigo fuente que escribamos
resultar probablemente menos legible si los utilizamos por lo que habr que
sopesarlo en funcin de nuestras necesidades.

3.2.4 Diferencias con Processing
La sintaxis del lenguaje de programacin Arduino es una versin simplificada de C/C++
y tiene algunas diferencias respecto de Processing [7][8]. Ya desde el punto de que
Arduino esta basado en C/C++ mientras que Processing se basa en Java. En cuanto a la
sintaxis de ambos lenguajes y el modo en que se programan existen tambin varias
diferencias:
Arrays
Arduino Processing
int bar[8]; int[] bar = new int[8];

bar[0] = 1; bar[0] = 1;
int foo[] = { 0, 1, 2 }; int foo[] = { 0, 1, 2 };

o bien
int[] foo = { 0, 1, 2 };
Bucles
Arduino Processing
int i; for (int i = 0; i < 5; i++) { ... }

for (i = 0; i < 5; i++) { ... }
Impresin de cadenas
Arduino Processing
Serial.println("hello world"); println("hello world");
int i = 5; int i = 5;
Serial.println(i); println(i);
int i = 5; int i = 5;
Serial.print("i = "); println("i = " + i);
Serial.print(i);
Serial.println();

Las diferencias son escasas por lo que alguien que conozca bien Processing tendr muy
pocos problemas a la hora de programar en Arduino.

3.2.5 Ejemplo prctico:
Hola Mundo en Arduino

El primer programa que solemos realizar en

un lenguaje de programacin es a menudo
el clebre Hello World que consiste en el
programa mas simple posible que escribe
un texto con la cadena Hola mundo en la
salida estndar. En el caso de la plataforma
Arduino este primer programa es uno que
enciende y apaga un led conectado al pin
nmero 13 indefinidamente. Veamos el
cdigo necesario para conseguirlo:

[9]
#define LED_PIN 13
void setup () {
// Activamos el pin 13 para salida digital
pinMode (LED_PIN, OUTPUT);
// Bucle infinito
void loop () {
// Encendemos el led enviando una seal alta
digitalWrite (LED_PIN, HIGH);
// Esperamos un segundo (1000 ms)
delay (1000);
// Apagamos el led enviando una seal baja
digitalWrite (LED_PIN, LOW);
// Esperamos un segundo (1000 ms)
delay (1000);

El orden de ejecucin ser: Primero se hace una llamada a la funcin init() que inicializa
el programa, despus se ejecuta la funcin setup() que configura diversos parmetros,
y por ltimo se ejecuta un bucle while(1) que llama repetidamente a la funcin loop.
Todo ello se ejecuta dentro de main() y podra haberse indicado explcitamente (en el
caso anterior se encarga el IDE de aadir el el cdigo que se ha omitido).
3.3 Extendiendo la funcionalidad: Libreras

3.3.1 Libreras principales
Para hacer uso de una librera en Sketch (el IDE de Arduino), basta con hacer clic sobre
Import Library en el men, escoger una librera y se aadir el #include
correspondiente.
Las libreras estndar que ofrece Arduino son las siguientes [10]:
Serial
Lectura y escritura por el puerto serie. Ya hemos hablado de ella anteriormente.
EEPROM
Lectura y escritura en el almacenamiento permanente [11].
read(), write()
Ethernet
Conexin a Internet mediante Arduino Ethernet Shield. Puede funcionar como
servidor que acepta peticiones remotas o como cliente. Se permiten hasta cuatro
conexiones simultaneas [12].
Servidor: Server(), begin(), available(), write(), print(), println()

Cliente: Client(), connected(), connect(), write(), print(), println(), available(),

read(), flush(), stop()
Firmata
Comuncacin con aplicaciones de ordenador utilizando el protocolo estndar del
puerto serie [13].
LiquidCrystal
Control de LCDs con chipset Hitachi HD44780 o compatibles [14]. La librera soporta los
modos de 4 y 8 bits.
Servo
Control de servo motores [15]. A partir de la versin 0017 de Arduino la librera
soporta hasta 12 motores en la mayora de placas Arduino y 48 en la Arduino Mega.
attach(), write(), writeMicroseconds(), read(), attached(), detach()
El manejo de la librera es bastante sencillo. Mediante attach(numero de pin)
aadimos un servo y mediante write podemos indicar los grados que queremos que
tenga el motor (habitualmente de 0 a 180).

SoftwareSerial
Comunicacin serie en pines digitales [16]. Por defecto Arduino incluye comunicacin
slo en los pines 0 y 1 pero gracias a esta librera podemos realizar esta comunicacin
con el resto de pines.
Stepper
Control de motores paso a paso unipolares o bipolares [17].
Stepper(steps, pin1, pin2), Stepper(steps, pin1, pin2, pin3, pin4),
setSpeed(rpm), step(steps)
El manejo es sencillo. Basta con iniciar el motor mediante Stepper indicando los pasos
que tiene y los pines a los que esta asociado. Se indica la velocidad a la que queramos
que gire en revoluciones por minuto con setSpeed(rpm) y se indican los pasos que
queremos que avance con step(pasos).
Wire
Envi y recepcin de datos sobre una red de dispositivos o sensores mediante Two
Wire Interface (TWI/I2C) [18].

Adems las libreras Matrix y Sprite de Wiring son totalmente compatibles con Arduino
y sirven para manejo de matrices de leds.
Tambin se ofrece informacin sobre diversas libreras desarrolladas por

contribuidores diversos que permiten realizar muchas tareas.
3.3.2 Creacin de libreras

Adems de las libreras base, las que son compatibles y las que han aportado otras
personas tenemos la posibilidad de escribir nuestra propia librera [19]. Esto es muy
interesante por varias razones: permite disponer de cdigo del que disponer en otros
proyectos de forma cmoda; nos permite mantener el cdigo fuente principal
separado de las libreras de forma que sean mantenibles de forma separada; y es mas
organizado y elegante.
Veamos un ejemplo de la creacin de una librera que enva cdigo Morse:
Creamos el fichero Morse.h que incluye la definicin de la clase Morse que tiene 3
funciones: un constructor (Morse()), una funcin para enviar 1 punto (dot()) y una
funcin para enviar una raya (dash()). La variable _pin permite indicar el pin que vamos
a utilizar.
/*

Morse.h - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.
*/
#ifndef Morse_h
#define Morse_h
#include "WProgram.h"
class Morse
public:
Morse(int pin);
void dot();
void dash();
private:
int _pin;
};
#endif
Adems necesitaremos un fichero Morse.cpp con el cdigo de las funciones

declaradas. A continuacin se muestra el cdigo:
/*
Morse.cpp - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.

*/
#include "WProgram.h"
#include "Morse.h"
Morse::Morse(int pin)
pinMode(pin, OUTPUT);
_pin = pin;
void Morse::dot()
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
void Morse::dash()
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
Y con esto ya podramos utilizar la librera mediante el correspondietne #include. Si

quisieramos enviar un SOS por el pin 13 bastara con llamar a Morse(13) y ejecutar
morse.dot(); morse.dot(); morse.dot();

--
Referencias
[1] "Interfacing Arduino to other languages", Proyecto Arduino. URL:

http://www.arduino.cc/playground/Main/InterfacingWithSoftware
[2] Processing (programming language), Wikipedia The Free Encyclopedia. URL:

http://en.wikipedia.org/wiki/Processing_(programming_language)
[3] Language Reference (extended), Proyecto Arduino. URL:

http://arduino.cc/en/Reference/Extended
[4] Manipulacin de puertos, Proyecto Arduino. URL

http://arduino.cc/en/Reference/PortManipulation
[5] Serial, Proyecto Arduino. URL: http://arduino.cc/en/Reference/Serial
[6] AVR Code, Proyecto Arduino. URL: http://www.arduino.cc/playground/Main/AVR
[7] Arduino/Processing Language Comparison, Proyecto Arduino. URL:

http://arduino.cc/en/Reference/Comparison?from=Main.ComparisonProcessing
[8] Processing Reference, Proyecto Processing. URL: http://processing.org/reference/
[9] Arduino Experiments (2009), Eatherton. URL: http://www.eathertons.com/blog/?p=73
[10] http://arduino.cc/en/Reference/Libraries
[11] EEPROM Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/EEPROM
[12] Ethernet Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/Ethernet
[13] Firmata Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/Firmata
[14] LiquidCrystal Library, Proyecto Processing. URL:

http://arduino.cc/en/Reference/LiquidCrystal
[15] Servo Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/Servo
[16] SoftwareSerial Library, Proyecto Processing. URL:

http://arduino.cc/en/Reference/SoftwareSerial
[17] Stepper Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/Stepper
[18] Wire Library, Proyecto Processing. URL: http://arduino.cc/en/Reference/Wire
[19] Writing a Library for Arduino, Proyecto Arduino. URL:

http://arduino.cc/en/Hacking/LibraryTutorial

4. SOFTWARE
4.1 Introduccin
El Entorno de Desarrollo de Arduino (ms conocido como IDE Integrated
Development Environment) es una herramienta que funciona en diferentes plataformas
(Windows, Macintosh, Linux) dedicada a la edicin y descarga de programas en la placa
Arduino.
El cdigo que se ejecuta en las placas est basado en las librerias de aplicacin Wiring
API y en las de desarrollo de los integrados AVR.

4.2 Instalacin del Software Arduino

Debido a que el software se encuentra disponible para los sistemas
operativos Windows, Mac OS y GNU/Linux, se explicar cmo se instala en cada
sistema con los siguientes pasos:
1. Descargar el entorno Arduino

2. Instalar los drivers USB
3. Ejecutar el entorno Arduino
4.2.1 Instalacin del IDE en Windows
Para la instalacin de la placa Arduino en Windows, conviene tener instalado

la ltima versin de Java Runtime Enviroment (J2RE) que se puede descargar de la web
de Sun[1].
1. Descargar el entorno Arduino
Descargar la ltima versin del IDE Arduino de la web oficial[2]. Cuando

termine la descarga, descomprimir el archivo descargado. Asegurarse de mantener la
estructura de carpetas.
Nota: Es recomendable descomprimir el fichero en el directorio raiz (c:\) manteniendo

la estructura original.
--
[1] http://java.sun.com/javase/downloads/index.jsp
[2] http://www.arduino.cc/en/Main/Software

Entre todas las carpetas creadas en el directorio Arduino, conviene destacar
las siguientes:
C:\arduino-0017\hardware\bootloader

sta contiene el software necesario para cargar el firmware en el chip
Atmega168 para trabajar con Arduino. Slo se utiliza si hemos montado la placa
nosotros mismos, o en el caso que se haya estropeado el chip y se haya comprado uno
nuevo.
C: \arduino-0017\drivers

Contiene los drivers necesarios para el funcionamiento de la placa Arduino
con Windows: FTDI USB Drivers.
Como se indic antes, los drivers para conectar la placa Arduino por USB se
encuentran en la subcarpeta drivers de la distribucin.
Si por algn motivo se desea descargar nuevos drivers, en la direccin

http://www.ftdichip.com/Drivers/VCP.htm se puede encontrar los ms actuales
A continuacin, conectamos la placa USB:

Figura 4.1: Conexin del cable USB a la placa Arduino
Se debera encender el LED de alimentacin

Se abrir automticamente el asistente Aadir Nuevo Hardware:
1. Seleccionar No por el momento y presionar Siguiente.

2. Seleccionar Instalar desde una lista o ubicacin especfica y presionar
Siguiente.
3. "Buscar el controlador ms adecuado en estas ubicaciones" presionar
"Examinar". Seleccionar la carpeta donde se haya descomprimido el driver y
presionar Siguiente.
Si no ha habido ningn problema, el driver de la placa estar instalado.
Ahora ejecutamos el fichero Arduino.exe para abrir la interfaz para luego

configurar el puerto USB al que tenemos conectado nuestra placa Arduino:

Figura 4.2: Seleccin del puerto donde est conectado la placa en Windows

As como seleccionar el modelo de tarjeta apropiado.

Figura 4.3: Seleccin de la placa Arduino deseada en Windows

4.2.2 Instalacin del IDE en Mac OS X (v. 10.3.9 o posterior)
1. Descarga del entorno Arduino
Descargar la ltima versin del IDE Arduino de la web oficial[1]. Cuando

termine la descarga, descomprimir el archivo descargado. Asegurarse de mantener la
estructura de carpetas.
Si se va a usar un Arduino USB, se necesitar instalar los drivers para el chip

FTDI de la placa. Estos pueden encontrarse en el directorio drivers de la distribucin
Arduino.
Si se posee un Mac ms antiguo como un Powerbook, iBook, G4 o G5, se
debera usar los drivers PPC: FTDIUSBSerialDriver_v2_1_9.dmg.
Si se posee un Mac ms nuevo como un MacBook, Mac-Book Pro o Mac Pro,
se necesita los drivers de Intel: TDIUSBSerialDriver_v2_2_9_Intel.dmg.
Hacer doble click para montar la imagen del disco y ejecutar el
FTDIUSBSerialDriver.pkg incluido.

La ltima versin de los drivers se puede encontrar en
http://www.ftdichip.com/Drivers/VCP.htm.
Reiniciamos el sistema.
Acto seguido, instalamos y ejecutamos el IDE. Por defecto nos crear una
carpeta en Documentos donde se guardarn todos los programas que vayamos
haciendo.
--
[1] http://www.arduino.cc/en/Main/Software

Debemos ahora especificar qu placa de Arduino tenemos:

Figura 4.4: Seleccin de la placa Arduino deseada en Mac OS X
Ahora conectamos la placa al mac y le indicamos el puerto por el que debemos

comunicarnos:

Figura 4.5: Seleccin del puerto donde est conectado la placa en Mac OS X
Debemos escoger la opcin parecida a /dev/tty.usbserl-XXXXXXX. Si no

apareciese ninguna opcin, puede ser debido a que, o tenemos mal conectado la placa
o los drives no estn bien instalados como en el caso de la Figura 4.5.

4.2.3 Instalacin del IDE en GNU/Linux
Estas instrucciones se centran en la distribucin Ubuntu1, para ms

informacin sobre cmo instalar el entorno Arduino en otras distribuciones visitar
http://www.arduino.cc/playground/Learning/Linux.

1. Ejecutar el Gestor de Paquetes Synaptic (en Sistema > Administracin ).
2. Primero se necesita habilitar los repositorios <<Universe>> y <<Multiverse>>
para que se pueda acceder a todos los paquetes necesarios.
a. Ir a Configuracin > Repositorios.
b. Click en Aadir.
c. Marcar <<Software restringido por copyright o cuestiones legales
(multiverse)>> y <<Software libre mantenido por la comunidad
(universe)>> y click en Aadir.
d. Clicl en Cerrar y en Cerrar en el dilogo <<Los repositorios han
cambiado>>.
3. Click en el botn Recargar de la barra de herramientas
4. Marcar para instalar: <<sun-java5-jre>>, <<gcc-avr>>, <<avr-libc>>.
5. Click en Aplicar en la barra de herramientas.
6. Click en Aplicar en el cuadro de dilogo. Esto instalar los paquetes
seleccionados.
7. Aceptar la licencia de Java.
8. Esperar hasta completar la instalacin: el cuadro de dilogo dir <<Cambios
aplicados>>. Click en Cerrar.
9. Cerrar Sypnaptic.
10. Descargar la distribucin GNU/Linux de Arduino desde
http://www.arduino.cc/en/Main/Software. Doble click en el archivo .zip y
arrastrar la carpeta que contiene a algn lugar (por ejemplo, el Escritorio).
11. Ejecutar el Terminal (en Aplicaciones > Accesorios).
12. Escribir <<sudo update-alternatives config.java>> y presionar Enter. Teclear el
nmero de opcin que tiene <<java-1.5.0-sun>> en l y presionar Enter. Esto
har de la versin de Java de Sun la predeterminada del sistema (necesaria
porque la versin GNU todava no soporta todo lo necesitado por el entorno
Arduino).
13. Doble click en <<Arduino>> en el directorio de aplicacin de Arduino. Esto
debera lanzar un dilogo preguntando dnde se guardan los archivos de las
rutinas de Arduino. Un directorio <<Arduino>> en la carpeta home es la
ubicacin tpica. Click en OK. El entorno Arduino debera abrirse.
4.3 Introduccin al entorno Arduino
Mens
Men
Tabulador
Barra de
Herramientas
rea de
cdigo

Figura 4.6: Elementos del entorno de desarrollo en Windows
4.3.1 Barra de Herramientas
Icono Nombre Descripcin

Verify/Compile Chequea el cdigo en busca de errores

Stop Para el <<Serial monitor>> o minimiza otros botones

New Crea una nueva rutina

Open Muestra un men con todas las rutinas de <<sketchbook>>

Save Guarda las rutinas

Upload to I/O Carga el cdigo a la placa Arduino I/O.
board
Serial Monitor Muestra datos serie enviados desde la placa Arduino


Tab Menu Permite gestionar las rutinas con ms de un archivo (cada
uno de los cuales aparece en su propia pestaa). Estos
pueden ser:
Archivos de cdigo de Arduino (sin extensin).

Archivos de C (extensin .c).
Archivos de C++ (extensin .cpp).
Archivos de cabecera (extensin .h).
4.3.2. Mens
Sketch
Verify/Compile: Comprueba la rutina para detectar errores.

Import Library: Utiliza una librera en la rutina. Trabaja aadiendo #include en
la cabecera del cdigo. Esto aade funcionalidad extra a la rutina, pero
incrementa su tamao. Para dejar de usar una librera, eliminar el #include
apropiado.
Show Sketch Folder: Abre la carpeta de rutinas
Add File: Aade otro fichero fuente a la rutina. El nuevo archivo aparece en una
nueva pestaa en la ventana de la rutina. Esto facilita y agranda proyectos con
mltiples archivos fuente. Los archivos pueden ser eliminados de una rutina
usando el Tab Menu.
Tools
Auto Format: Esto formatea el cdigo

Copy for Discourse: Copia el cdigo de la rutina al portapapeles de forma
conveniente para postear en un foro, completa con resaltado de sintaxis.
Board: Selecciona la placa que se est usando. Esto controla la forma en que la
rutina es compilada y cargada as como el comportamiento de los elementos
del men Burn Bootloader.
Serial Port: Este men contiene todos los dispositivos serie (reales o virtuales)
de la mquina. Debera actualizarse automticamente cada vez q se abre el
nivel superior del men Tools. Antes de subir la rutina, se necesita seleccionar
el elemento de este men que representa a la placa Arduino.
Burn Bootloader: Los elementos en este men permiten grabar un bootloader
en la placa con una variedad de programadores. Hay que asegurarse de haber
seleccionado la placa correcta del men Boards de antemano.

5. Control de motores con Arduino
5.1 Control de motores DC con puente en H

En este apartado vamos a implementar un control para motores de corriente continua

mediante un puente en H, que en nuestro caso ser el L293NE de Texas Instrument.
5.1.1 Puente en H.

Un puente en H, es un circuito electrnico que permite que un motor de corriente

continua gire en un sentido u otro y su nombre proviene de la apariencia de su representacin
grfica como vemos en la figura 1.
Figura 1. Diagrama puente en H.
Como observamos en la imagen anterior, si cerramos los interruptores S1 y S4, la corriente

que pasa por el motor ser contraria a la que pasara si cerramos S2 y S3, lo que har que el
motor gire en un sentido o en otro, mientras que si cerramos S1 y S2 o S3 y S4 el motor no
girar ya que por l no pasa corriente en ningn sentido.
En la prctica no se implementas los puentes en H con interruptores, si no que se utilizan

transistores que en funcin de las tensiones que apliquemos en su puerta, estar en corte o en
saturacin, impidiendo o dejando as pasar la corriente a travs de los mismos [1].
El integrado L293NE, est preparado para conectarle hasta 4 motores, por lo que para el
diseo de un robot que tenga dos o cuatro ruedas motrices, slo necesitaremos un integrado.

En la figura 2, podemos observar el patillaje del integrado y una tabla de verdad con las
salidas que provoca cualquier combinacin de entradas al mismo.
Figura 2. Patillaje del L293NE.
5.1.2 Conexin del motor y el puente en H

Para realizar nuestro proyecto, debemos conectar correctamente el motor y el puente en

H con nuestro Arduino, el esquema elctrico [1] sera el de la figura 3.
Figura 3. Conexiones elctricas
Utilizaremos la alimentacin externa del Arduino, para lo que tendremos que cambiar el
switch de alimentacin, ya que el USB trabaja a 5V y normalmente los motores trabajan a
tensiones mayores, en nuestro caso 12V.

Se ha colocado un condensador entre la alimentacin del motor y tierra para evitar as los
picos de tensin que se producen al conectar y desconectar el motor.
Una vez montado el circuito slo nos queda programar nuestro Arduino para que podamos
controlar nuestro motor de corriente continua.
5.1.3 Programacin

Lo primero ser declarar nuestras variables asociadas a los pines del Arduino [1].
const int switchPin = 2; // switch input

const int motor1Pin = 3; // H-bridge pata 1 (pin 2, 1A)
const int motor2Pin = 4; // H-bridge pata 2 (pin 7, 2A)
const int enablePin = 9; // H-bridge enable pin
const int ledPin = 13; // LED

A continuacin configuraremos los pines del Arduino como entrada o salida, tambin
haremos que el led parpadee 3 veces, pero esto slo debera pasar una sola vez, ya que si
ocurre ms veces es porque nuestro programa ha vuelto a reiniciarse a causa probablemente
de un fallo en nuestro motor, como puede ser un corto.
void setup() {
pinMode(switchPin, INPUT);
pinMode(motor1Pin, OUTPUT);
pinMode(motor2Pin, OUTPUT);
pinMode(enablePin, OUTPUT);
pinMode(ledPin, OUTPUT);
digitalWrite(enablePin, HIGH);
blink(ledPin, 3, 100);
}

Funcin para hacer que el led parpadee un cierto nmero de veces cada cierto periodo,
que se le pasan como parmetros. Como hemos visto en el cdigo anteriormente, nuestro led
parpadear 3 veces con un intervalo de 100 milisegundos. La funcin la implementaremos con
un simple bucle for y retardos para encender y apagar el led.
void blink(int whatPin, int howManyTimes, int milliSecs) {

int i = 0;
for ( i = 0; i < howManyTimes; i++) {
digitalWrite(whatPin, HIGH);
delay(milliSecs/2);

digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}

Ya slo nos queda la funcin principal de nuestro programa, que estar implementada de
forma que lea el valor del interruptor para saber en qu direccin debe girar y activar las
salidas correspondientes a la tabla de verdad de la figura 2 vista en el apartado puente en H.
void loop() {
if (digitalRead(switchPin) == HIGH) { //direccin 1
digitalWrite(motor1Pin, LOW);
digitalWrite(motor2Pin, HIGH);
}
else { // direccin 2
digitalWrite(motor1Pin, HIGH);
digitalWrite(motor2Pin, LOW);
}
}

Ahora ya slo tendramos que cargar nuestro programa en el Arduino y mediante el

interruptor podemos controlar la direccin de giro de nuestro motor.
5.2 Control de motores con Motor Shield Arduino

Una alternativa al control de motores utilizando el puente en H, puede ser utilizar la

Motor Shield de Arduino, figura 4, que viene preparada para el control de motores de
corriente continua, servos y motores paso a paso.
La Motor Shield es una placa de expansin para el Arduino, la cual mediante libreras
permite el control de motores de hasta 1 A. Para conectar motores de mayor consumo hace
falta utilizar un integrado L293.
Figura 4. Arduino con Motor Shield.

La Motor Shield contiene 4 puentes en H en los que se pueden conectar hasta 2 servos de
5V, 4 motores de corriente continua bidireccionales u 8 que giren en una sola direccin y 2
motores paso a paso (unipolares o bipolares) con bobina simple, doble o micro paso a paso.
Adems cuenta con una entrada externa para la alimentacin de los motores. En la figura 5
podemos observar el Arduino con la Motor Shield y sus conectores.
Dos motores DC (3 y 4) o un motor

Dos servos. paso-paso (2)
Dos motores DC (1 y 2) o un motor

paso-paso (1)
Alimentacin externa para los motores
Figura 5. Conectores Motor Shield.
5.2.2 Control de motores de corriente continua con Motor Shield

Los motores de corriente continua se colocan en los puertos M1, M2, M3 o M4, y si son
bidireccionales, se podr controlar la direccin de giro y la velocidad mediante el PWM. Para
poder realizar este control debemos incluir la librera AFMotor.h y seguir lo siguientes pasos
[2]:
Crear el objeto AF_DCMotor con AF_DCMotor (motor #, frecuencia), para configurar

el puente en H. Motor# indica el puerto en el que est conectado el motor que puede
ser 1,2,3 o 4 y la frecuencia es la velocidad con la que se llevar a cabo el control del
motor. Para los motores 1 y 2 se puede elegir entre 1KHz, 2KHz, 8KHz o 64Khz, pero
los motores 3 y 4 slo funcionan a 1KHz.
Se puede ajustar la velocidad de giro del motor con la funcin setSpeed (velocidad), a
la que le pasaremos un valor comprendido entre 0 (parado) y 255 (velocidad mxima).

Para hacer funcionar el motor tenemos que llamar a la funcin run (direccin), a la que
le pasaremos hacia donde queremos que gire el motor, las posibilidades con:
fORDWARE (hacia adelante), BACKWARD (hacia atrs) o RELEASE (parado).
En el siguiente ejemplo utilizaremos un motor en el puerto 2, con un PWM de 64KHz y

haremos que gire en una direccin, al cabo de un segundo girar en direccin contraria y luego
lo pararemos.
#include <AFMotor.h>
AF_DCMotor motor(2, MOTOR12_64KHZ); // Motor #2, 64KHz pwm
void setup() {
motor.setSpeed(200); // velocidad 200 de 255
}
void loop() {
motor.run(FORWARD); // girar hacia adelante
delay(1000);
motor.run(BACKWARD); // girar hacia atrs
delay(1000);
motor.run(RELEASE); // parar
delay(1000);
}

5.2.3 Control de servos con Motor Shield

Los servos se conectan en los puertos serv y debido a que este tipo de motores consume
una gran cantidad de energa, se deberan alimentar mediante la conexin de alimentacin
externa. El PWM para el control de los servos es de 16 bits y para poder realizar este control
debemos incluir la librera ServoTimer1.h y seguir los siguientes pasos [2]:
Crear un objeto ServoTimer para cada servo (mximo 2).
Conectar los servos al pin 9 (servo A) o pin 10 (servo B) usando la funcin attach().
Fijar la posicin del servo con la funcin write (ngulo), donde el ngulo puede variar
desde 0 a 180.
En el siguiente ejemplo utilizaremos dos servos que estar cada uno en la posicin opuesta
al otro durante 1 segundo.
#include <ServoTimer1.h>
ServoTimer1 servo1;
ServoTimer1 servo2;
void setup() {
servo1.attach(10);
servo2.attach(9);
}

void loop() {
servo1.write(180);
servo2.write(0);
delay(1000);
servo1.write(0);
servo2.write(180);
delay(1000);
}

5.2.4 Control de motores paso a paso con Motor Shield

Podemos conectar hasta 2 motores paso a paso unipolares o bipolares y las libreras son las
mismas. La bobina 1 del motor debe conectarse a un puerto por ejemplo M1 o M2 y la otra
bobina al M3 o M4. La nica diferencia es que si el motor es unipolar el cable del centro ir
conectado a tierra, mientras que en los bipolares este cable no existe, pero el funcionamiento
es el mismo en ambos casos.
Para poder realizar este tipo de control es necesario incluir la librera AFMotor.h y seguir los
siguientes pasos [2]:
Crear el objeto de motor paso a paso con AF_Stepper (pasos, pasos#) para configurar el
puente en H. Pasos indica cuntos pasos por revolucin tiene el motor. Con
7.5grados/paso el motor tiene 360/7.5 = 48 pasos. Pasos# es que el puerto al que est
conectado el motor. Si ests utilizando M1 y M2, el puerto ser 1y si ests utilizando
M3 y M4 el puerto ser el 2.
Ajuste la veloicdad del motor utilizando la funcin setSpeed (rpm) donde rpm son las
revoluciones por minuto.
Cada vez que se quiera mover el motor hay que utilizar la funcin step (#pasos,

direccin, tipo_paso), donde #pasos es el nmero de pasos que quieres dar, direccin
puede tomar los valores FORWARD o BACKWARD para ir hacia adelante o hacia atrs
respectivamente, y tipo_paso puede tomar los valores SINGLE (paso simple), DOUBLE
(paso doble), INTERLEAVE (paso simple y doble alternado) o MICROSTEP (pasos
suavizados con el PWM).

Como el servo por defecto suele mantener la posicin dada, podemos utilizar la
funcin release() para liberarlo.

En el siguiente ejemplo utilizaremos un servo y lo moveremos con los diferentes tipos de
pasos explicados anteriormente.
#include <AFMotor.h>
AF_Stepper motor(48, 2);
void setup() {
motor.setSpeed(10); // 10 rpm
motor.step(100, FORWARD, SINGLE);

motor.release();
delay(1000);
}
void loop() {
motor.step(100, FORWARD, SINGLE);
motor.step(100, BACKWARD, SINGLE);
motor.step(100, FORWARD, DOUBLE);
motor.step(100, BACKWARD, DOUBLE);
motor.step(100, FORWARD, INTERLEAVE);
motor.step(100, BACKWARD, INTERLEAVE);
motor.step(100, FORWARD, MICROSTEP);
motor.step(100, BACKWARD, MICROSTEP);
}
[1] ITP Physical Computing. http://itp.nyu.edu/physcomp/Labs/DCMotorControl
[2] Ladyada. http://www.ladyada.net/make/mshield/index.html

6. Aplicaciones de Arduino en Micro-
Robots Mviles.
6.1 Introduccin
ASURO es un pequeo robot mvil desarrollado por DLR (el centro aeroespacial
alemn) para proyectos educativos.
A excepcin de la placa o circuito impreso

(PCB), el resto de los componentes
utilizados y las herramientas de software,
son estndares o libres freeware, de
forma que puede ser reprogramado y
ampliado muy fcilmente. De este modo
ASURO puede servir como introduccin al
mundo de los microprocesadores, robtica,
etc. en colegios, universidades, as como
para centros de educacin para adultos.
Se puede comprar on-line y su precio ronda los 50 Euros.
Como se muestra a continuacin, ASURO viene con un micro Atmega8, dos motores
controlados de forma independiente, un seguidor de lneas ptico, seis sensores de
contacto o colisin, dos odmetros, tres LEDs indicadores de estado y un interfaz IR-
para programacin y control remoto va un PC.

6.2 Montaje
6.2.1 Componentes

Sensores de contacto

El conjunto de pulsadores de K1 a K6, en la parte delantera del ASURO,

se activan con el pin PD3 (salida digital) y se capturan los valores con un nico
pin , el PC4 (entrada analgica). De esta forma, se obtendr un valor diferente,
dependiendo del pulsador pulsado o de la combinacin de los mismos.
LEDs

Existen 3 tipos de LEDs:
o El LED de estado (D12) o led bicolor (verde-rojo), es decir, dos LEDs

encapsulados en un mismo componente. De forma que ambos LEDs pueden
ser activados/desactivados individualmente as como en conjunto. As

obtenemos tres colores, un naranja-amarillo (ambos activados), un rojo y
un verde.
Para obtener el color rojo hay que activar el pin PD2 (salida digital), y para
el verde, el pin PB0 (salida digital). Y para el naranja amarillo, pues ambos.
o El LED frontal (D11) como parte del sigue lneas y situado en la parte
inferior. Su activacin se encuentra en el pin PD6 (salida digital).
o Los LEDs traseros (D15-izquierdo/D16-derecho), ambos se activan

respectivamente con los pines PC1 y PC0 (salidas digitales) y el pin PD7
queda como entrada (digital).
Si en cambio se activa la parte del odmetro, es decir, se activan los pines
PC0 y PC1 como entradas (analgica) y PD7 como salida ambos LEDs no
pueden ser utilizados. Es decir, ambas funcionalidades son incompatibles o
no pueden ser activadas al mismo tiempo.

Medidor del nivel de bateras o monitor de voltaje

El medidor de voltaje consiste de un simple divisor de tensin. Y va

conectado al pin PC5 como entrada analgica.
Interfaz de Infrarrojos a 36KHz

Est compuesto de un transmisor IR LED (D10) conectado al pin PB3
(salida digital pwm a 36Khz) que acta como portadora y PD1 (salida UART TxD)
como seal de datos. Y de un receptor (IC2), conectado a pin PD0 (entrada
UART RxD). El rango del interfaz solo abarca 50cm aproximadamente.

Odmetros o Encoders pticos
Se proporcionan 2 discos con 6 y/o 8 sectores para pegar a los engranajes que
activan las ruedas. De forma que se puede recibir 30 y/o 40 pulsos por
revolucin.
El funcionamiento es el siguiente, los discos o encoders son iluminados por los

LEDs de infrarrojos (D13, D14) y los fototransistores (T11, T12) se encargan de
medir la luz reflejada (negro no refleja, blanco si). Entonces si se cuentan los
cambios entre luz /oscuridad podemos evaluar la velocidad o pasos del robot.
Para ello el procesador debe activar el pin (salida digital): PD7 (D13 y D14 se
iluminan simultneamente) y leer los Pines (entradas analgicas): PC1 (T11-
izquierdo) y PC0 (T12-derecho).
Seguidor de lneas
En la parte inferior del robot se han

situado un led (D11) y dos
fototransistores (T9/T10), de forma que
los fototransistores puedan capturar la
cantidad de luz reflejada por la
superficie (Superficies oscuras reflejan
menos luz que superficies claras). De
este modo, si se situara al robot dentro
de una lnea negra (donde no se
reflejara la luz), se podra crear una
funcin que siguiera dicha lnea.
Para ello el procesador debe activar el Pin (salida digital): PD6 (D11- frontal) y leer
los Pines (entradas analgicas):PC3 (T9-izquierdo) / PC2 (T10-derecho).
Motores
Para manejar cada uno de los motores se utilizan puentes H (H-bridge).

Lgica de un Puente H:

Por ejemplo, para controlar el motor izquierdo el procesador utiliza pines PB1,
PD4 y PD5 (PB2, PB4 y PB5 para motor derecho). PB1 (y/o PB2) proporcionan la
seal PWM para el control de la velocidad. PD4 y PD5 (y/o PB4 y PB5)
determinan la direccin de rotacin del motor (salidas digitales).
A continuacin se muestra una tabla, donde se resume todo esto:
Funcin PD5 PD4

Avanza 1(activo) 0(inactivo)
Retrocede 0 1
Frena 0 0
Operacin de no-load 1 1
6.2.2 Construccin

Por el momento slo es necesario montar la placa principal (la placa

grande); Las instrucciones sobre el montaje, se pueden encontrar en el manual
(http://www.arexx.com/downloads/asuro/asuro_manual_en.pdf) o en el CD
que viene con el robot Asuro).
El Manual viene en ingls, pero siguiendo los grficos que aparecen en l no es

muy difcil de montar. An as en el siguiente enlace se puede encontrar
informacin en castellano.
http://arduino.cc/es/Ensamblado-Asuro/Ensamblado-Asuro
Unas notas:
El oscilador (Q1: el pequeo componente marrn de tres patas) no tiene

polaridad; as que se puede poner de cualquier forma.
Una vez montada, el Atmega8 que viene con el Robot, contiene un programa
que realiza una comprobacin o TEST de todos sus componentes y
funcionalidades, de forma que se pueda detectar si se ha producido algn error
durante el proceso de montaje.

6.2.3 Test del Asuro

Fase 1
Antes de insertar el chip IC1 (ATmega8) y el chip IC3 (puerta lgica AND) en los
zcalos, activa el interruptor a ON. Los LEDs situados en la parte trasera (D15,
D16), deberan de brillar tenuemente (prueba en la oscuridad!).
Si no lo hacen, desactiva inmediatamente el interruptor a off y contina

leyendo en la parte de resolucin de problemas.
Fase 2
Si se pasa esta prueba anterior, desactiva el interruptor a OFF e inserta el chip

ATmega8 (IC1) y el chip IC3 (puerta lgica AND) en sus correspondientes
zcalos.
Las marcas de la polaridad de los chips (muescas) deben estar alineadas con las
marcas de los zcalos. Tambin, las patas del chip o IC deben ser dobladas muy
cuidadosamente para que puedan quedar todas insertadas en los agujeros de
contacto del zcalo.
El procesador o ATmega8 del Asuro, se ha diseado para hacer una auto-

prueba y en ella comprobar el funcionamiento de todos los componentes.
Para empezar la prueba o Test, debes insertar el Jumper (J1), en el caso de que
utilices bateras recargables. Entonces activa el interruptor a On y verifica lo
siguiente:
El LED de estado (D12) debe emitir una luz naranja (combinacin de rojo y
verde) y los LEDs traseros (D15, D16) deben estar activos. Si esto no pasa,
desactiva el interruptor inmediatamente y contina leyendo en resolucin de
problemas.
o Prueba de LEDs
Lo anterior, slo ha sido la secuencia bsica de arranque del ASURO. En

la siguiente fase todos los elementos sern chequeados
secuencialmente en un intervalo de 3 segundos y en el siguiente orden:
LED de estado (D12) verde

LED de estado (D12) rojo
LED frontal (D11) activo (en la parte inferior del Asuro)
LED trasero (D15) parte trasera izquierda
LED trasero (D16) parte trasera derecha

Todos los Leds activados al mismo tiempo
Si ocurre algn error, desactiva el interruptor a OFF inmediatamente y

contina leyendo en resolucin de problemas.
o Fototransistores de parte inferior
Despus de terminar el Test de los Leds, el LED de estado (D12) debera

quedarse en color verde, indicando la comprobacin de los
fototransistores (T9, T10), situados en la parte inferior del ASURO y
responsables del sigue lneas. La comprobacin dura como unos 10
segundos. Mientras se iluminan dichos transistores Con D11?, los Back-
LEDs (D15, D16) se activan y desactivan al mismo tiempo (fototransistor
derecho (T10) --> Led trasero derecho (D16); fototransistor izquierdo
(T9) ->Led trasero izquierdo (D15)).
Si todo va bien, los LEDs traseros no se apagan completamente una vez

se dejan de iluminar los fototransistores.
Si ocurre algn error, el Test no se interrumpe, de forma que el error se

puede evaluar ms adelante.
o Pulsadores o sensores de choque
A continuacin se van a chequear los pulsadores, durante 15 segundos.

Slo se trata de ver si ocurre lo siguiente.
Si se Pulsa K1 -> LED de estado (D12) es activado a verde

Si se Pulsa K2 ->LED de estado (D12) es activado a rojo
Si se Pulsa K3 -> LED de la parte inferior D11 activado
Si se Pulsa K4 -> LED trasero izquierdo (D15) activado
Si se Pulsa K5 -> LED trasero derecho (D16) activado
Si se Pulsa K6 -> Motor izquierdo empieza a funcionar (si el
motor no funciona, el test puede continuarse). Los motores
sern chequeados ms adelante.
Pulsando varios pulsadores al mismo tiempo se iniciar la equivalente

combinacin de seales.

o Odmetros
A continuacin el Led frontal (D11) se activa. Lo que indica el comienzo

del prximo Test (15 segundos), en el cual, ambos odmetros

(consistentes de un LED D13/D14 y un fototransistor T11/T12
respectivamente) sern chequeados. Para ello se situar un papel
blanco en frente de los fototransistores (T11, T12) lo que activar el LED
de estado (D12).
Si mantenemos un papel blanco en frente del fototransistor izquierdo

(T11). --> Led de estado (D12) se activa a verde. Entonces, si
mantenemos el papel en frente del fototransistor derecho (T12) el LED
de estado (D12) se activa a rojo.
En el momento que quitemos los papeles, el LED de estado se apagar.

Si se realiza dicha secuencia, los odmetros estn funcionando
correctamente.

o La mecnica o los motores
Los Leds traseros (D15, D16) se encendern, indicando el ltimo test, y

durar 15 segundos.
Los motores sern chequeados intensivamente. El motor izquierdo se

activa en la direccin izquierda desde la velocidad mnima a mxima y
vuelta a empezar.
Entonces se invierte la direccin de giro y la velocidad se vuelve a

acelerar desde el mnimo al mximo y vuelta a empezar. La misma
comprobacin se realizar con el motor derecho. Despus de ambos
chequeos ambos motores se comprobarn de forma simultnea.

o IR interface
Existe un ltimo Test que dura tambin 15 segundos y que se realiza

sobre el interfaz de infrarrojos. Para ello hay que montar la placa
pequea, de forma que se pueda establecer la comunicacin de
infrarrojos entre el robot Asuro y el PC.
En nuestro caso esto no ser necesario ya que por el momento

reemplazaremos dicho interfaz por Arduino.
Pero en caso de que se quiera utilizar, se puede chequear su circuito.

6.3 ATmega8
6.3.1 Reemplazamiento del ATmega8

El ATmega8 que viene con el robot usa un protocolo para la descarga de los
programas (va transmisin IR) que no est documentado o que no es Standard, por lo
que no puede modificarse, y de este modo, tampoco se puede utilizar Arduino para
dicha descarga. Afortunadamente, en lugar de ello se puede usar el ATmega8 de la
placa de Arduino como se indica a continuacin.
Saca el ATmega8 de la placa del Asuro

(gurdalo, ya que est programado con el TEST
que hemos utilizado para comprobar su
correcto ensamblado). Entonces coloca el
ATmega8 de la placa de Arduino, en la placa del
Asuro (Asegrate que en la forma correcta).
6.3.2 Cambiando los ficheros de Arduino
Como el robot Asuro funciona a mitad de la velocidad de la placa Arduino (8

MHz en lugar de 16 MHz), es necesario cambiar un par de lneas en el fichero de
preferencias de Arduino (es recomendable hacer una copia del fichero original, antes
de hacer dicha modificacin):
La ubicacin de los ficheros depende del sistema operativo que utilices:
c:\Documents and Settings\USERNAME\Application

Data\Arduino\preferences.txt (Windows)
/Home/USERNAME/Library/Arduino/preferences.txt (Mac OS X)
~/.arduino/preferences.txt or something similar (Linux)
Las lneas a cambiar son las siguientes:
serial.download_rate: desde 19200 (antiguo valor) a 9600 (nuevo valor)
build.f_cpu: desde 16000000L (antiguo valor) a 8000000L (nuevo valor)

6.3.3 Conexin y programacin de Asuro con Arduino

Para poder programar el Asuro con Arduino, tambin ser necesario soldar algunos
cables extras sobre la placa del Asuro.
Como se muestra en la foto, los cables deben ser soldados a los pines 2 (RX) y 3 (TX)
del ATmega8 que se encuentra en el Asuro, de forma que puedan ser conectados a los
pines digital pin 0 (RX) y digital pin 1 (TX) de la placa Arduino. El otro cable saldr del
pin de tierra o GND (pin 8) e ir al correspondiente pin de tierra de Arduino.
A continuacin se muestra la relacin de correspondencia (Mapping o mapeo) que hay

entre los pines definidos en el ATmega8 y los pines definidos en Arduino y Asuro
respectivamente.
MAPEO DE PINES ARDUINO
MAPEO DE PINES ASURO

De este modo, se puede establecer la siguiente correspondencia entre los
componentes del Asuro y los pines de Arduino, informacin necesaria para su
posterior programacin con Arduino:

Libreras oficiales para controlar el Asuro
http://www.arexx.com/downloads/asuro/asuro_src.zip
Una vez conectados los cables a los pines indicados en la placa Arduino, hay que
conectar la placa Arduino al PC, va cable USB (u RS232). De esta forma se podr
descargar programas desde el entorno de Arduino. Slo hay que tener en cuenta que
el ATmega8 est en el Asuro, no en la placa Arduino, as que ser necesario utilizar el
switch o interruptor de encendido/apagado del robot, en lugar del pulsador de reset
de la placa Arduino. Para ello hay que encender el robot Asuro justo antes de pulsar el
botn de "upload" en el entorno de programacin de Arduino. Si no funciona,
comprueba la conexin de los cables que van a los pines 0 y 1 sobre la placa Arduino.
Los comandos Arduino, para la comunicacin serie, deberan de funcionar sin ningn
problema.

6.4 Funciones
En primer caso decir que Arduino no se programa en C, tiene un lenguaje propio llamado
Arduino, muy parecido a C. Con funciones ms faciles e intuitivas.
Setup(): La funcin setup() es llamada justo en el momento en que el programa

comienza. Se utiliza para inicializar variables, definir los modos de entrada o salida de los pines,
indicar libreras, etc.
void setup() //Seccin Setup de la estructura de programa
beginSerial(9600);
pinMode(buttonPin, INPUT); // Configura como entrada el pin

digital
pinMode(ledPin, OUTPUT); // Configura como salida el pin

digital
Loop(): la seccin loop() hace precisamente lo que su nombre indica en ingls(bucle), y se

repite continuamente, permitiendo que tu programa mute y responda. Se usa para controlar
de forma activa la tarjeta Arduino.
El tiempo del bucle, vara segn el nmero de instrucciones que contenga. Y se puede conocer
y controlar con las funciones de temporizacin (millis(), delay(), etc).

void loop() {
if (digitalRead(buttonPin) == HIGH)
serialWrite('H');
else
serialWrite('L');
delay(1000);

pinMode(pin, mode) : Configura el pin especificado para que se comporte como una entrada
(input) o una salida (output).

digitalWrite(pin, value) : Asigna el valor de salida HIGH o LOW al pin especificado.

digitalRead(pin): Lee o captura el valor de entrada del pin especificado, dar valores
HIGH o LOW.


pulseIn(pin, value): Lee un pulso (en estado HIGH (1) o LOW(0)) sobre un pin. Por ejemplo, si
el valor es HIGH, pulseIn() espera hasta que el pin est en estado HIGH, entonces empieza a
temporizar, y cuando el pin vuelve al estado LOW, se para el temporizador. De este modo, se
devuelve el ancho del pulso en microsegundos.

void setup() {
pinMode(pin, INPUT);
void loop() {
duration = pulseIn(pin, HIGH);

analogRead(pin) : Lee o captura el valor de entrada del especificado pin analgico, la
tarjeta Arduino realiza una conversin analgica a digital de 10 bits. Esto quiere decir que
mapear los valores de voltage de entrada, entre 0 y 5 voltios, a valores enteros comprendidos
entre 0 y 1024.

void setup() {
pinMode(ledPin, OUTPUT); // asigna modo salida el pin

digital 13
void loop() {
val = analogRead(analogPin); // captura el pin de entrada
if (val >= threshold) {
digitalWrite(ledPin, HIGH); // enciende el LED
} else {
digitalWrite(ledPin, LOW); // apaga el LED

analogWrite(pin, value): Escribe o asigna un valor analgico (PWM) al pin desado. Se
puede usar para encender un Led e ir variando la intensidad de su brillo o impulsar un motor a
distintas velocidades. Despus de invocar o realizar una llamada a la funcin analogWrite, el
pin generar una seal estable hasta la prxima invocacin o llamada de la funcin
analogWrite (o una llamada a digitalRead o digitalWrite sobre el mismo pin).

value: representa al parmetro "ciclo de trabajo"y puede tomar valores entre 0 y 255.
0 corresponde a una seal de salida de valor constante de 0 v (LOW) o 0% de "ciclo de
trabajo"; 255 es una seal de salida de valor constante de 5 v (HIGH) o 100% de "ciclo de
trabajo"; . Para valores intermedios, el pin rpidamente alterna entre 0 y 5 voltios - el valor
ms alto, lo usual es que el pin est en high (5 voltios).

int ledPin = 9; // LED conectado al pin digital 9
int analogPin = 3; // potencimetro conectado al pin analgico 3
int val = 0; // variable para almacenar el valor de captura o

lectura
void setup() {
pinMode(ledPin, OUTPUT); // asigna el pin como modo salida
void loop() {
val = analogRead(analogPin); // lee o captura el pin de

entrada
analogWrite(ledPin, val / 4);
// los valores de analogRead van desde 0 a 1023, los valores de

analogWrite desde 0 a 255

Las funciones que se explican a contunuacin son vlidas para la version 0004 e inferiores:

beginSerial(int speed) : Inicializa el puerto serie asignndole una velocidad de transmisin de
datos (bits por segundo). Dicha funcin debe ser llamada desde dentro de laseccin setup().

serialWrite(character) : Enva un byte (como caracter ASCII que representa el valor numrico
de dicho byte) al puerto serie.

SerialAvailable() : Obtiene un nmero entero con el nmero de bytes (caracteres)
diponibles para leer desde el puerto serie.


SerialRead(): Lee un byte (un caracter) desde el puerto serie.
void loop() {
serByte = serialRead(); //almacena el valor del puerto

serie
if (serByte != -1) { // Muestra el valor si hay algn byte

en el puerto serie
val = serByte;
printByte(val);

printMode(mode): Esta funcin determina si la salida de la funcin print() va hacia el
puerto serie o a un display LCD (Liquid Crystal Display). Mode puede ser SERIAL o DISPLAY

printByte(b) : Vuelca un nico byte al puerto serie (no como caracteres ASCII que
representan el valor numrico de dicho byte).

printString(str) : Vuelca como salida al puerto serie una cadena de caracteres ; de esta
forma, transmite la secuencia ASCII de los caracteres contenidos en la cadena.

printInteger(num) : Vuelca un nmero entero codificado o en caracteres ASCII en formato
decimal al puerto serie; de esta forma, transmite la secuencia de nmeros en ASCII, de la
representacin en base 10 del nmero entero.

printHex(num) : Vuelca un entero codificado o en caracteres ASCII, en formato
hexadecimal al puerto serie; de esta forma, transmite la secuencia de nmeros y letras en
ASCII, de la representacin en base 16 del nmero entero.

printBinary(num): Imprime o vuelca un entero codificado o en caracteres ASCII, en
formato binario (binary integer) al puerto serie; de esta forma, transmite la secuencia de ceros
y unos en ASCII, de la representacin en base 2 del nmero entero.

PrintNewline() : Imprime o vuelca un carcter de salto de lnea ('\n') en el puerto serie.

Estas funciones son validas de la versin 0004 en adelante:

Serial.begin(int speed) : Equivalente a la funcin beginSerial().

Serial.available() : Equivalente a la funcin serialAvailable().
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() {
// enva datos slo si los recibe:

if (Serial.available() > 0) {
// lee el byte de entrada:
incomingByte = Serial.read();
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
Serial.Read(): Equivale a la funcin serialRead().
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() {
// enva datos slo si los recibe:
if (Serial.available() > 0) {
// lee el byte de entrada:
incomingByte = Serial.read();
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
Serial.print(data, data type) : Enva un nmero o una 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.
DEC: escribe el valor en decimal, en caracteres ASCII
HEX: escribe el valor en hexadecimal, en caracteres ASCII

OCT; escribe el valor en octal, en caracteres ASCII
BIN: escribe el valor en binario, en caracteres ASCII
BYTE: escribe el carcter ASCII asociado a dicho valor
str: escribe la cadena de caracteres.

Serial.printnl(data, data type) : Enva un nmero o una cadena de caracteres al puerto serie,
seguido de un carcter de retorno de carro "CR" ('\r')y un carcter de salto de lnea "LF"('\n').
Toma la misma forma que el comando Serial.print()


A continuacin hablaremos de las funciones de tiempo que la plataforma Arduino nos ofrece.

Millis(): Devuelve el tiempo en milisegundos, desde que la tarjeta Arduino activ el programa
que se est ejecutando.
long time;
void setup(){
Serial.begin(9600);
} void loop(){
Serial.print("Time: ");
time = millis();
//muestra el tiempo desde que el programa comenz
Serial.println(time);
// espera un segundo para no enviar una cantidad masiva de

datos
delay(1000);

delay(ms) : Detiene el programa durante una cantidad de tiempo (en milisegundos)
especificado mediante parmetro.

int ledPin = 13; // LED conectado a pin digital 13
void setup() {
pinMode(ledPin, OUTPUT); // asigna al pin digital como

pin de salida
void loop() {
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // espera un segundo
digitalWrite(ledPin, LOW); // apaga el LED
delay(1000); // espera un segundo

delayMicroseconds(us) : Detiene el programa durante una cantidad de tiempo (en
microsegundos) especificado mediante parmetro.

int outPin = 8; // pin digital 8
void setup() {
pinMode(outPin, OUTPUT); // asigna el modo salida al pin

digital
void loop() {
digitalWrite(outPin, HIGH); // da valor de 5v al pin
delayMicroseconds(50); // se detiene unos 50

microsegundos
digitalWrite(outPin, LOW); // da valor de 0v al pin
delayMicroseconds(50); // se detiene unos 50

microsegundos

Aparte de todas estas funciones, existen muchas ms funciones, matemticas,
trigonomtricas... ms complejas, en libreras aparte.

Por lo dems es todo igual que en C, slo que no existen los puertos, sino que son solo pines.
A continuacin mostraremos un ejemplo
El programa tiene tres funciones distintas, tiene una matriz 4x4 y las coordenadas del led se
controlan con el Pad L del mando de la Play station. Tambin hay un servo-motor que es
controlado por el eje Y del Pad R del mismo mando, y finalmente tiene un led, cuya intensidad
se regula con las flechas de hacia arriba, y hacia abajo del mando.
El cdigo es el siguiente:
#define pinX 0
#define ctr_srv 1
#define pinY 2

#define servoPin 11
#define ledraise 5
#define ledlower 4
#define led 12
#define time 50
boolean portx[4]={HIGH,HIGH,LOW,HIGH}, porty[4]={LOW,LOW,HIGH,LOW};
char i, j;
int x, y, ix=2, iy=2;
int previousMillis=0, led_ilu=0;
int pos, angulo;
void setup() {
pinMode(17, OUTPUT);
pinMode(servoPin, OUTPUT);
void loop() {

x = analogRead(pinX)/256;
y = analogRead(pinY)/256;
pos= analogRead(ctr_srv);
angulo=(map(pos, 0, 512, 0, 179));
for(i=0;i<4;i++){ porty[i]= LOW; portx[i]= HIGH;}
portx[x]=LOW;
porty[y]=HIGH;
if(millis()-previousMillis>=time){
previousMillis= millis();
if(analogRead(ledraise)<300){ led_ilu+=5; if(led_ilu>=250)

led_ilu=250;}
if(analogRead(ledlower)<300){ led_ilu-=5; if(led_ilu<=0)

led_ilu=0;}}
servoPulse();
salidas();
void salidas(){
char indice;
for(i=17, indice=0;i<21;i++, indice++)

digitalWrite(i,portx[indice]);
for(i=28, indice=0;i<35;i+=2, indice++)

digitalWrite(i,porty[indice]);
analogWrite(led, led_ilu);}

void servoPulse() {
float pulseWidth;
pulseWidth = ((angulo/180.0) * 1100.0) + 200.0;
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseWidth);
digitalWrite(servoPin, LOW);
delay(20);

IDMRM0910 Trabajo Arduino V1.4

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

IDMRM0910 Trabajo Arduino V1.4

Cargado por

Copyright:

Formatos disponibles

PLATAFORMA

INTRODUCCIN AL DISEO DE MICRO-ROBOTS 2009/2010

Vctor Alonso Mendieta Alberto De Lope

lvaro Tanarro Santamara Carlos de la Rubia Tuya

Plataforma Arduino en diseo de Robots Mviles Pgina 2

Plataforma Arduino en diseo de Robots Mviles Pgina 3

La elaboracin del trabajo se a echo repartiendo las secciones bsicas de conocimiento

Plataforma Arduino en diseo de Robots Mviles Pgina 4

El ATmega168 es un microcontrolador CMOS de 8 bits de baja potencia basado en

CPU AVR de Atmel de 8 bits de hasta 20MHz.

Plataforma Arduino en diseo de Robots Mviles Pgina 5

A continuacin se muestra la arquitectura del ncleo AVR del ATmega168:

El Atmega168 utiliza una arquitectura Harvard con la memoria y el bus de programa y

Registros de Propsito General.

Los 32 registros de 8 bits de propsito general se localizan al principio de la memoria

A cada registro se le asigna una direccin mapeada directamente en las primeras 32

Plataforma Arduino en diseo de Robots Mviles Pgina 6

ALU - Unidad Aritmtico-Lgica

El registro de estado contiene informacin sobre los resultados de las operaciones

La pila se usa principalmente para almacenar datos temporales, para almacenamiento

La arquitectura AVR est dividida en dos espacios principales de memoria, la Memoria

Memoria Flash. Este microcontrolador contiene 16Kbytes de memoria Flash

Figura 7: Mapa de memoria de SRAM.

Plataforma Arduino en diseo de Robots Mviles Pgina 8

Los pines de alimentacin del chip: VCC y GND.

Los pines de alimentacin del Convertidor A/D: AVCC y AREF.

3 puertos paralelos bidireccionales de 8 bits (Puerto B), 7 bits (Puerto C) y 8

En la siguiente figura se muestra el esquema correspondiente a un pin genrico con

Plataforma Arduino en diseo de Robots Mviles Pgina 11

Las interrupciones externas del microcontrolador se controlan mediante los siguientes

Registro de Control A (EICRA): Este registro determina el modo de activacin

Registro de Bandera (EIFR): Su funcin es indicar cuando las interrupciones

De la misma manera las interrupciones externas adicionales denominadas PCINT

Plataforma Arduino en diseo de Robots Mviles Pgina 12

A continuacin se muestra el esquema de funcionamiento del

El registro denominado TCNTn contiene el valor del temporizador o del contador en

Plataforma Arduino en diseo de Robots Mviles Pgina 13

Plataforma Arduino en diseo de Robots Mviles Pgina 14

Registro Temporizador/Contador (TCNT0): Este registro contiene el valor del

Registros de Comparacin (OCR0A, OCR0B): Contienen el valor a comparar con

Registro Mscara de Interrupcin (TIMSK0): Habilita las interrupciones

2.1.4. Convertidor Analgico/Digital

El funcionamiento del convertidor es el siguiente. Mediante el registro ADMUX y a

Registro de Estado y de Control A (ADCSRA): Este registro habilita el

Registros de Datos (ADCH, ADCL): Estos 2 registros de 8 bits contienen el

Registro de Estado y de Control B (ADCSRB): Determina las fuentes externas

Plataforma Arduino en diseo de Robots Mviles Pgina 17

Registro para Deshabilitar Entrada Digital (DIDR0): Este registro deshabilita la

Figura 30: Registro de Estado y de Control B.

1.2.5. Comparador Analgico.

A continuacin se describen los registros que utiliza este perifrico:

Registro de Estado y de Control B (ADCSRB): El bit ACME permite elegir la

Plataforma Arduino en diseo de Robots Mviles Pgina 18

Registro de Control y de Estado (ACSR): conecta la alimentacin del

Registro para Deshabilitar Entrada Digital (DIDR1): Este registro deshabilita la

Plataforma Arduino en diseo de Robots Mviles Pgina 19

2.2Tipos de placas y perifericos

Se va a tratar de explicar las caractersticas hardware de distintas placas y los

2.2.1 Duemilanove Arduino

Plataforma Arduino en diseo de Robots Mviles Pgina 20

Plataforma Arduino en diseo de Robots Mviles Pgina 21

Plataforma Arduino en diseo de Robots Mviles Pgina 23

Plataforma Arduino en diseo de Robots Mviles Pgina 25

"Diecimila" significa 10.000 en italiano y se llamaba as al marcar el hecho de que ms