Trabajo Arduino V1.4

PLATAFORMA
ARDUINO
en diseño de Robots
Móviles
INTRODUCCIÓN AL DISEÑO DE MICRO-‐ROBOTS 2009/2010
GRUPO A
Iván Cantero Mencerreyes Yen Hi Lee Lay
Víctor Alonso Mendieta Alberto De Lope
Álvaro Tanarro Santamaría Carlos de la Rubia Tuya
Pedro Quintero
Quintero
ÍNDICE
1. Introducción .........................................................................................................................................................4
2. Descripción Hardware .....................................................................................................................................5
2.1. Microcontrolador Atmega168/V .............................................................................................................5
2.1.1. Características 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. Librerías en Arduino...................................................................................................................................... 33
3.1 Introducción ................................................................................................................................................... 33
3.2 Lenguaje de programación Arduino..................................................................................................... 34
3.2.1 Processing.............................................................................................................................................. 34
3.2.2 Funciones básicas y operadores .................................................................................................. 34
3.2.3 AVR Libc ................................................................................................................................................. 37
3.2.4 Diferencias con Processing............................................................................................................. 40
3.2.5 Ejemplo práctico: Hola Mundo en Arduino ............................................................................. 41
3.3 Extendiendo la funcionalidad: Librerías ............................................................................................ 42
3.3.1 Librerías principales ......................................................................................................................... 42
3.3.2 Creación de librerías ......................................................................................................................... 43
4. SOFTWARE......................................................................................................................................................... 47
4.1 Introducción ................................................................................................................................................... 47
4.2 Instalación del Software Arduino .......................................................................................................... 47
4.2.1 Instalación del IDE en Windows .................................................................................................. 47
4.2.2 Instalación del IDE en Mac OS X (v. 10.3.9 o posterior)..................................................... 51
4.2.3 Instalación del IDE en GNU/Linux .............................................................................................. 53
4.3 Introducción al entorno Arduino........................................................................................................... 54
4.3.1 Barra de Herramientas..................................................................................................................... 54
4.3.2. Menús ..................................................................................................................................................... 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 Conexión del motor y el puente en H ......................................................................................... 57
5.1.3 Programación....................................................................................................................................... 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 diseño de Robots Móviles Página 2

6. Aplicaciones de Arduino en Micro-‐Robots Móviles.......................................................................... 64
6.1 Introducción ................................................................................................................................................... 64
6.2 Montaje ............................................................................................................................................................. 65
6.2.1 Componentes ......................................................................................................................................... 65
6.2.2 Construcción .......................................................................................................................................... 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 Conexión y programación de Asuro con Arduino .................................................................. 73
6.4 Funciones.. ………………………………………………………………………………………………………….…………..77

1. Introducción

É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 elaboración del trabajo se a echo repartiendo las secciones básicas 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, además de sus principales características
físicas y de periféricos. Después de ésto tratamos de definir el lenguaje de programación y las
librerías que utiliza Arduino y también su entorno de desarrollo. Posteriormente se explicarán
dos casos prácticos en los que se muestra en su totalidad como llevar a cabo una aplicación
con la placa. El primero de ellos trata sobre como se pueden controlar motores fácilmente con
una placa arduino

2. Descripción Hardware
2.1. Microcontrolador Atmega168/V
2.1.1. Características Generales

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

arquitectura RISC de AVR. Las características generales del ATmega168 son:
• CPU AVR de Atmel de 8 bits de hasta 20MHz.

• Arquitectura RISC, con 131 instrucciones de un ciclo de ejecución, 32 registros
de 8 bits de propósito 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 Analógico/Digital de 10bits.
• Comparador Analógico.
• Comunicación serie TWI, USART y SPI.
• Fuentes de interrupción tanto internas como externas.

La figura 1 muestra el diagrama de bloques del ATmega168:

Figura 1: Diagrama de Bloques.

2.1.2. Arquitectura.
A continuación se muestra la arquitectura del núcleo 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 instrucción se ejecuta, la siguiente instrucción se
carga en la memoria de programa. Esto permite que las instrucciones se ejecuten en
un solo ciclo de reloj. La mayoría de estas instrucciones tienen un formato de 16 bits.
Registros de Propósito General.
Los 32 registros de 8 bits de propósito general se localizan al principio de la memoria
SRAM. En la siguiente figura se observa la distribución de los registros:

Figura 3: Registros de Propósito General.
A cada registro se le asigna una dirección 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 Aritmético-‐Lógica
La ALU opera en conexión directa con los 32 registros de propósito general. Las
operaciones aritméticas entre los registros se realizan dentro de un solo ciclo de reloj.
Las operaciones soportadas por la ALU se dividen en tres categorías principales:
aritméticas, lógicas, y funciones a nivel de bit. Algunas implementaciones de la
arquitectura proporcionan un multiplicador que realiza operaciones de multiplicación
con o sin signo.
Registro de Estado
El registro de estado contiene información sobre los resultados de las operaciones

aritmético-‐lógicas realizadas en la ALU. Esta información 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 distribución 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 después 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. Además 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 sección de arranque y la sección 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
propósito general, los siguientes 64 localizaciones para registros estándar de
entrada/salida (registros de los periféricos), después 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 distribución de terminales del microcontrolador para un
encapsulado PDIP:

Figura 8: Encapsulado PDIP.

A continuación se detallan los terminales del ATmega168.
• Los pines de alimentación del chip: VCC y GND.
• Los pines de alimentación 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. Además de la
función típica 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 señal de reloj del chip
(XTAL1, XTAL2), salida del divisor de la señal de reloj (CLKO), entrada de
señal de reloj asíncrona externa para los Temporizadores/Contadores
(TOSCI1, TOSCI2), entrada de eventos para los
Temporizadores/Contadores (ICP1), modulación en pulso de señal PWM
(OC1A, OC2A, OC1B), fuentes de interrupción externas
(PCINT0..PCINT7), comunicación 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), comunicación
serie TWI (SCL, SDA) y también incorpora fuentes de interrupción
externas (PCINT8..PCINT14).

Figura 10: Funciones Alternativas Puerto C.

o Las funciones alternativas del Puerto D son: canales de entrada al
Comparador Analógico (AIN0, AIN1), modulación en pulso de señal
PWM (OC0A, OC0B, OC2B), entrada de señal de reloj síncrona externa
para los Temporizadores/Contadores (T0, T1), comunicación serie
USART (XCK, TXD, RXD) y fuentes de interrupción 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 dirección 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: Configuración de Pines.
En la siguiente figura se muestra el esquema correspondiente a un pin genérico con

todas las señales de control. Las señales 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 Genérico
2.1.4. Interrupciones.
El ATmega168 dispone de 26 fuentes de interrupción asociadas a los periféricos del
microcontrolador y a señales externas al mismo. En la siguiente tabla se muestra la
dirección de memoria de programa asignada a cada interrupción:

Figura 14: Tabla de Vectores de Interrupción.
Las interrupciones externas del microcontrolador se controlan mediante los siguientes
registros:
• Registro de Control A (EICRA): Este registro determina el modo de activación
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 Máscara (EIMSK): Con este registro se habilitan (1) o deshabilitan (0)
las fuentes de interrupción externas INT0 e INT1, siempre y cuando el bit I del
Registro de Estado este activo.

Figura 16: Registro Máscara de Interrupciones Externas INT0 e INT1.
• Registro de Bandera (EIFR): Su función 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 configuración de interrupciones externas similares:

Registro de Control (PCICR), Registros Máscara (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 comparación que permiten la generación de señales con modulación en
pulso PWM (OCR). Se explicará el primero de ellos (TCNT0) siendo análogo el
funcionamiento de los demás.
A continuación 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 lógica de control es la encargada de actuar sobre el registro TCNT,
mediante las señales direction (selecciona el sentido de la cuenta), count (incrementa
o decrementa la cuenta) y clear (pone a cero el registro). La señal de reloj clk va a fijar
el ritmo de cuenta. El selector de reloj permite seleccionar entre una señal de reloj
externa al microcontrolador por medio de Tn o entre la señal de reloj propia al
microcontrolador desde el preescaler. Con las señales top y botón se indica a la lógica
de control cuando el TCNT a alcanzado el valor máximo o mínimo respectivamente y
por consiguiente la lógica de control deberá generar una interrupción a través de la
señal TOVn. El valor máximo puede ser fijado con los registros comparadores OCRnA u
OCRnB. La principal función de estos registros es generar una señal PWM, a través del
generador de onda, en los pines OCnA ó OCnB. Cuando sus valores se igualan al del
contador TCNTn generán una interrupción.

A continuación se pasan a describir los principales registros asociados al Temporizador
Contador 0:

• Registro de Control A (TCCR0A): Con este registro se controla la función
alternativa de los pines de salida para PWM (OC0A, OC1A, OC0B y OC1B) con
los bits COM0A0, COM0A1, COM0B0 y COM0B1. También 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 comparación 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 máximos y mínimos vendrán fijados por
los registro de control.

Figura 21: Registro Temporizador/Contador.
• Registros de Comparación (OCR0A, OCR0B): Contienen el valor a comparar con
el Registro Temporizador/Contador TCNT0.

Figura 22: Registro de Comparación A (B, análogo).
• Registro Máscara de Interrupción (TIMSK0): Habilita las interrupciones

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

Figura 23: Registro Máscara de Interrupciones.
• Registro Bandera de Interrupción (TIFR0): Sus bits se ponen a uno cuando las
interrupciones de comparación y la de desborde se activan.

Figura 24: Registro Bandera de Interrupciones.


2.1.4. Convertidor Analógico/Digital

El ADC incluido en el ATmega168 es un convertidor analógico de 10 bits basado en el
método de conversión por aproximaciones sucesivas. El ADC está conectado a un
multiplexor analógico de 8 bits lo que permite seleccionar entre 8 fuentes de
conversión.

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

través un decodificador se selecciona el canal sobre el que se va a realizar la
conversión. Una vez seleccionado, la señal del canal se compara con una señal
analógica de referencia proporcionada por el DAC a través del comparador. En función
del resultado de la comparación, la lógica de conversión incrementará o decrementará
la señal digital de referencia que se proporciona al DAC quién se encargará de
convertir esta nueva señal de referencia a un valor analógico. Cuando el resultado de
la comparación sea igual, la señal digital de referencia será el resultado de la
conversión y se proporcionará al registro de datos del convertidor (ADCH/ADCL). El

registro ADCSRA es el encargado de generar las señales de control del ADC como la
señal de enable, la señal de inicio de conversión, el prescaler de conversión y las
señales de interrupción.
Para el control de las distintas funcionalidades del Convertidor A/D se utilizan los
siguientes registros:

• Registro de Selección del Multiplexor (ADMUX): Permite seleccionar distintos
voltajes de referencia (REFS1, REFS0) y también 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 Selección del Multiplexor.
• Registro de Estado y de Control A (ADCSRA): Este registro habilita el

Convertidor (ADEN), inicia la conversión de forma interna (ADSC), habilita el
inicio de conversión mediante una señal externa (ADATE), bandera de
interrupción que indica el fin de la conversión (ADIF), habilita la interrupción
(ADIE) y varia la frecuencia de conversión 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 conversión.

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

para el inicio de conversión.

Figura 29: Registro de Estado y de Control B.
• Registro para Deshabilitar Entrada Digital (DIDR0): Este registro deshabilita la
función de entrada/salida digital de los canales de entrada al Convertidor A/D
para la conversión.
1.2.5. Comparador Analógico.

El comparador analógico compara el valor de dos señales de entrada introducidas a
través 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 Analógico.
A continuación se describen los registros que utiliza este periférico:
• Registro de Estado y de Control B (ADCSRB): El bit ACME permite elegir la

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

• Registro de Control y de Estado (ACSR): conecta la alimentación del

Comparador (ACD), permite elegir entre dos señales de referencia a introducir
en el terminal positivo: AIN0 y una referencia interna (ACBG), contiene la salida
del comparador (ACO), también tiene la bandera asociada a la interrupción
(ACI), habilita la interrupción (ACIE), permite habilitar el disparo del
Temporizador/Contador con la señal de salida ACO (ACIC) y selecciona entre
varios modos de interrupción 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
función de entrada/salida digital de los canales de entrada al Comparador
Analógico.

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 características hardware de distintas placas y los

periféricos 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 más importante que las difiere de
la DUEMILANOVE.
2.2.1 Duemilanove Arduino

Descripción 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 analógicas, un oscilador de cristal de 16
MHz, una conexión USB, un conector de alimentación, una cabecera de ICSP, y un
botón 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
batería para empezar.

Resumen
-‐Microcontrolador ATmega168 ó Atmega328
-‐Tensión de funcionamiento: 5V.
-‐Entrada de voltaje (recomendado): 7-‐12V.
-‐Voltaje de entrada (límites): 6-‐20V.
-‐Pins Digitales I / O: 14 (de las cuales 6 proporcionar una salida PWM).
-‐Pins de entrada analógica: 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.

Alimentación
El Duemilanove Arduino puede ser alimentado a través de la conexión USB o con
una fuente de alimentación externa. La fuente de alimentación se selecciona
automáticamente.
La alimentación externa (no USB) puede proceder de un adaptador AC a DC o una
batería. El adaptador se puede conectar con una clavija 2,1 mm de centro-‐positivo en
el enchufe de alimentación de la placa. Una batería puede ser insertada entre el GND y
el pin de alimentación.

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 más de 12V, el regulador de voltaje
puede sobrecalentarse y dañar la placa. El rango recomendado es de 7 a 12 voltios.

Los pines de alimentación son los siguientes:

• VIN. Se puede proporcionar el voltaje de entrada a través de este pin a la placa
Arduino cuando está usando una fuente de alimentación externa (en lugar de 5 voltios
de la conexión USB o otra fuente de alimentación regulada).
• 5V. Se consiguen 5V mediante una fuente de alimentación 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
máxima de 50 mA.
• GND. Conexión de tierra.

Memoria
El ATmega168 tiene 16 KB de memoria flash para almacenar el código (de los
cuales 2 KB se utiliza para el gestor de arranque), la Atmega328 dispone de 32 KB,
(también con 2 KB utilizado para el gestor de arranque). El ATmega168 tiene 1 MB de
SRAM y 512 bytes de EEPROM (que puede ser leído 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 máximo de 40 mA y
tienen una resistencia interna (desconectado por omisión) de 20-‐50 kOhms.
Además, algunos pines tienen funciones especializadas:

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

• Interrupciones: 2 y 3. Estos pins se pueden configurar para activar una
interrupción 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
función analogWrite ().

• SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos son pines de apoyo a la
comunicación 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 analógicas, cada una de las cuales ofrecen 10
bits de resolución (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 función analogReference(). Además, algunos pins se han especializado
más aún en cuanto a su funcionalidad:

• I2C: 4 (SDA) y 5 (SCL). Apoyo I2C (IST) de comunicación que utiliza la biblioteca
Wire.

Hay otro par de pines en la placa:

• Aref. Voltaje de referencia para las entradas analógicas. Usado con
analogReference().
• Reset. Llevando esta línea a nivel bajo se puede reiniciar el microcontrolador.

A continuación se muestra el esquema de conexión de la placa


Comunicación
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 comunicación 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 través
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 están transmitiendo datos a través del chip FTDI y conexión USB
con el ordenador (pero no para la comunicación de serie en los pines 0 y 1).
Una biblioteca SoftwareSerial permite la comunicación serie en cualquiera de los
pines digital de la Duemilanove's.
El ATmega168 y Atmega328 también soporta I2C (IST) y comunicación SPI. El
software incluye una biblioteca de Arduino Wire para simplificar el uso del bus I2C.
Para utilizar la comunicación de la SPI, consultar las características técnicas del
ATmega168 o del Atmega328.

Programación
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 código, sin el uso de un
programador hardware externo. Se comunica usando el protocolo original STK500.
También puede omitir el gestor de arranque y el programa del microcontrolador
a través de la ICSP (In Circuito Serial).

Reset por software
En lugar de exigir apretar el botón de reinicio antes de una carga de software en
el controlador, el Duemilanove Arduino está diseñado de una manera que le permite
resetear el software se ejecuta desde un ordenador conectado. Una de las líneas de
control de flujo por hardware (DTR) de la FT232RL está conectado a la línea de reset de
la ATmega168 o Atmega328 a través de un condensador de 100 nanofaradio. Cuando
se activa esta línea (tomando nivel bajo de tensión), la línea 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 código con tan sólo pulsar el botón
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 configuración 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 conexión a ella desde el software (a través 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, además de una carga de
código nuevo), y cuando los primeros bytes de datos enviados llegan a la placa, se
interceptan dichos datos y despuésla conexión se abre. Si una aplicación se ejecuta en
la placa y recibe del exterior cualquier tipo de datos cuando se inicia por primera vez,
asegúrese de que el software con el que se comunica espera un segundo después de la
apertura de la conexión 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". También se puede deshabilitar la función
auto-‐reset, conectando una resistencia de 110 ohmios de 5V a la línea de reajuste.

USB Protección 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 mayoría de los equipos
proporcionan su protección interna, el fusible proporciona una capa adicional de
protección. Si más de 500 mA se aplica al puerto USB, el fusible rompe
automáticamente la conexión hasta que se elimina el corto o sobrecarga.

Características físicas
La longitud máxima 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 más allá
de la dimensión 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 milésimas de pulgada (0,16"), por lo que no es un
múltiplo de la distancia (de 100 milésimas 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 más
de 10.000 tarjetas Arduino se han hecho.

Resumen
Microcontrolador ATmega168 únicamente por lo que por ejemplo en cuanto a
memoria posee solo las características de este controlador.

Memoria
El ATmega168 tiene 16 KB de memoria flash para almacenar el código (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 leído y escrito con la biblioteca de EEPROM).


2.2.3 Nano Arduino

Descripción general

El Nano Arduino es una placa pequeña, completa basada en el Atmega328 (Arduino
Nano 3,0) o ATmega168 (Arduino Nano 2.x). Tiene más o menos la misma
funcionalidad de la Duemilanove Arduino, pero en un paquete diferente. Le falta sólo
el conector de alimentación DC, y trabaja con un mini cable USB en lugar de uno
normal. El Nano fue diseñado y está siendo producido por Gravitech.
Especificaciones:
Dimensiones 0.73 "x 1.70".

Potencia:
El Nano Arduino puede ser alimentado a través de la Mini-‐conexión USB, con
entre 6-‐20V mediante una fuente de alimentación externa no regulada(pin 30), o 5V
regulados mediante fuente reguladora (pin 27). Se toma como fuente de energía la
que tenga mayor tensión y se activa automáticamente.
El chip FTDI FT232RL montado en el Nano es alimentado sólo si la placa está

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


Memoria
Podemos obtener el nano con el controlador ATmega168 que tiene 16 KB de
memoria flash para almacenar el código (de los cuales 2 KB se utiliza para el gestor de
arranque), o con la Atmega328 que dispone de 32 KB, (también con 2 KB utilizado para
el gestor de arranque). El ATmega168 tiene 1 MB de SRAM y 512 bytes de EEPROM
(que puede ser leído 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 analógicas, 4 UART (puertos serie del hardware), un
oscilador de cristal de 16 MHz, una conexión USB, un conector de alimentación, una
cabecera de ICSP, y un botón 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 batería para empezar. La Mega es compatible con la
mayoría de los escudos diseñados para la Duemilanove Arduino o Diecimila.

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

Alimentación
La Mega Arduino puede ser alimentada a través de la conexión USB o con una
fuente de alimentación externa. La fuente de alimentación se selecciona
automáticamente.
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 más de 12V, el regulador de voltaje
puede sobrecalentarse y dañar el tablero. El rango recomendado es de 7 a 12 voltios.

Memoria
El ATMEGA1280 cuenta con 128 KB de memoria flash para almacenar el código (de 4
KB, que se utiliza para el gestor de arranque), 8 MB de SRAM y 4 KB de EEPROM (que
puede ser leído 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 máximo de 40 mA y tiene una
resistencia interna de 20-‐50 kOhms. Además, 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 transmisión (TX) datos TTL serie.
Pins 0 y 1 son también conectados a los pines correspondientes de la USB FTDI-‐a-‐chip
TTL serie.
• Factores externos Interrupciones: 2 (interrupción 0), 3 (de interrupción 1), 18
(interrupción de 5), 19 (de interrupción 4), 20 (de interrupción 3), y 21 (de interrupción
2). Estos pins se pueden configurar para que activen una interrupción 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 función analogWrite().
• SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). Estos son pines de apoyo a la

comunicación 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 comunicación I2C (IST) que utiliza la
biblioteca Wire. Estos pines no están en la misma ubicación que los pines I2C en el
Duemilanove o Diecimila.

El Mega cuenta con 16 entradas analógicas, cada una de las cuales ofrecen 10 bits de
resolución (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 función.

Además hay un par de pins en la placa:

• Aref. Voltaje de referencia para las entradas analógicas. Usado con analogReference
().
• Reset. Llevando esta línea a nivel bajo se reiniciará el microcontrolador.

Comunicación
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 comunicación seriea través 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 están transmitiendo datos a través del chip FTDI y conexión
USB.
Una biblioteca SoftwareSerial permite la comunicación de serie en cualquiera de los pines

digitales del “Mega”.

2.2.5 Otras placas
Existen más módelos de placas en el mercado, pero estas difieren muy poco a
nivel físico de las ya explicadas. Por ello vamos tan solo a mencionar básicamente las
placas y a ilustrarlas con la correspondiente fotografía, para saber cual elegir en
función de la aplicación que quisieramos realizar.

Lilypad -‐> Es una pequeña placa diseñada para aplicaciones con las que tuviéramos que llevar
encima, por ejemplo ropa inteligente que en la aplicación ya existe implementada con
Arduino.

Mini-‐> placa que se caracteriza por ser la más pequeña de las disponibles
Arduino serial-‐> placa que implementa una comunicación serie RS232 como principal
característica

Pro mini-‐> diseñada para aplicaciones low-‐cost y que requieran un tamaño reducido

Bluetooth Arduino
El BT Arduino es una placa Arduino con módulo incorporado Bluetooth, que

permite la comunicación inalámbrica.
Además, 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

mínimo de 1,2 V, pero con un máximo de 5,5 V. voltajes superiores o polaridad
invertida en la fuente de alimentación romperan la placa.
• Pin 7 está conectado al pin de reset del módulo Bluetooth.
• Utilizar únicamente la comunicación en serie a 115200 baudios, porque es la
velocidad a la que el módulo se ha configurado para utilizar.

El módulo Bluetooth utilizado es el WT11 Bluegiga, versión iWrap.El módulo 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. Librerías en Arduino
3.1 Introducción
La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en
el popular lenguaje de programación de alto nivel Processing1. Sin embargo, es posible
utilizar otros lenguajes de programación y aplicaciones populares en Arduino [1].
Algunos ejemplos son:
Java •
Flash (mediante ActionScript)
•
Processing •
MaxMSP (entorno gráfico de programación para aplicaciones musicales, de
•
audio y multimedia)
• VVVV (síntesis de vídeo 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 (síntesis de audio en tiempo real)
• Instant Reality (X3D)
• Second Life
• Liberlab (software de medición y experimentación)
• BlitzMax (con acceso restringido)
• Squeak (implementación 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 transmisión de datos en
formato serie que es algo que la mayoría 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 comunicación 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 comunicación que ofrece.
No obstante en este trabajo nos centraremos en el lenguaje que acepta por defecto: El
lenguaje de programación Arduino.
3.2 Lenguaje de programación Arduino

3.2.1 Processing
Processing es un lenguaje de programación 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 programación obtener programas de forma fácil y rápida que
ofrecieran efectos visuales de forma rápida. Esto lo consigue abstrayendo gran parte
de la complejidad de ciertas funciones.
A partir de Processing nacieron varios proyectos relacionados que siguieron su filosofía
y se centraban en otros aspectos. De estos proyectos destacan Wiring, Fritzing y
Arduino.
3.2.2 Funciones básicas y operadores

Arduino esta basado en C y soporta todas las funciones del estándar C y algunas de
C++ [3]. A continuación 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 aritméticos
• Asignación: =
• Operaciones: +, -‐, *, /, %
Operadores de comparación

• ==, !=, <, >, <=, >=
Operadores Booleanos
• &&, ||, !
Operadores de acceso a punteros

• *, &
Operadores de bits

• &, |, ^, ~, <<, >>
Operadores compuestos
• Incremento/decremento de variables: ++, -‐-‐
• Asignación y operación: +=, -‐=, *=, /=, &=, |=
Manipulación de puertos

Los registros de puertos permiten la manipulación a mas bajo nivel y de forma mas
rápida de los pines de E/S del microcontrolador de las placas Arduino [4]. Los pines de
las placas Arduino están repartidos entre los registros B(0-‐7), C (analógicos) y D(8-‐13).
Mediante las siguientes variables podemos ver y modificar su estado:
• DDR[B/C/D]: Data Direction Register (o dirección 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 sólo lectura.

Por ejemplo, para especificar que queremos utilizar los pines 1 a 7 como salidas y
el 0 como entrada, bastaría utilizar la siguiente asignación:

DDRD = B11111110;

En cuanto al tratamiento de las variables también 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 más.
• 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
Conversión 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 básicas del lenguaje nos encontramos con las siguientes:
E/S Digital
• pinMode(pin, modo)
• digitalWrite(pin, valor)
• int digitalRead(pin)
E/S Analógica
• 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)
Matemáticas
min(x, y), max(x, y), abs(x), constrain(x, a, b), map(valor, fromLow, fromHigh,
•
toLow, toHigh), pow(base, exponente), sqrt(x)
Trigonometría
• sin(rad), cos(rad), tan(rad)
Números aleatorios
• randomSeed(semilla), long random(máx), long random(mín, máx)
Bits y Bytes
• lowByte(), highByte(), bitRead(), bitWrite(), bitSet(), bitClear(), bit()
Interrupciones externas
• attachInterrupt(interrupción, función, modo)
• detachInterrupt(interrupción)
Interrupciones
• interrupts(), noInterrupts()
Comunicación por puerto serie [5]
Las funciones de manejo del puerto serie deben ir precedidas de “Serial.” aunque no
necesitan ninguna declaración 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 sólo debemos
aprender algunas funciones específicas de que dispone el lenguaje para manejar los
diferentes parámetros 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 librería 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 mayoría del lenguaje de programación Arduino está escrita con constantes y
funciones de AVR y ciertas funcionalidades sólo 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 comunicación serie. La función
delayMicroseconds() desactiva las interrupciones cuando se ejecuta.
Temporizadores
La función delayMicroseconds() crea el menor retardo posible del lenguaje Arduino
que ronda los 2μs.
Para retardos mas pequeños se debe utilizar la llamada de ensamblador 'nop' (no
operación). Cada sentencia 'nop' se ejecutará en un ciclo de máquina (16 Mhz): unos
62.5ns. Se haría de la siguiente manera:
__asm__("nop\n\t");

Manipulación de puertos

La manipulación de puertos con código AVR es mas rápida que utilizar la función
digitalWrite() de Arduino.
Establecer Bits en variables

cbi y sbi son mecanismos estándar (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 pequeños hacks tendremos la posibilidad de mejorar los tiempos de
ejecución de ciertas tareas críticas o de aquellas que se repitan muchas veces
obteniendo mejores resultados. No obstante el código fuente que escribamos
resultará probablemente menos legible si los utilizamos por lo que habrá que
sopesarlo en función de nuestras necesidades.

3.2.4 Diferencias con Processing
La sintaxis del lenguaje de programación Arduino es una versión 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 también 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++) { ... }
Impresión 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 práctico:
Hola Mundo en Arduino

El primer programa que solemos realizar en

un lenguaje de programación es a menudo
el célebre “Hello World” que consiste en el
programa mas simple posible que escribe
un texto con la cadena “Hola mundo” en la
salida estándar. En el caso de la plataforma
Arduino este primer programa es uno que
enciende y apaga un led conectado al pin
número 13 indefinidamente. Veamos el
código 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 señal alta
digitalWrite (LED_PIN, HIGH);
// Esperamos un segundo (1000 ms)
delay (1000);
// Apagamos el led enviando una señal baja
digitalWrite (LED_PIN, LOW);
// Esperamos un segundo (1000 ms)
delay (1000);

El orden de ejecución será: Primero se hace una llamada a la función init() que inicializa
el programa, después se ejecuta la función setup() que configura diversos parámetros,
y por último se ejecuta un bucle while(1) que llama repetidamente a la función loop.
Todo ello se ejecuta dentro de main() y podría haberse indicado explícitamente (en el
caso anterior se encarga el IDE de añadir el el código que se ha omitido).
3.3 Extendiendo la funcionalidad: Librerías

3.3.1 Librerías principales
Para hacer uso de una librería en Sketch (el IDE de Arduino), basta con hacer clic sobre
“Import Library” en el menú, escoger una librería y se añadirá el #include
correspondiente.
Las librerías estándar 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
Conexión 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
Comuncación con aplicaciones de ordenador utilizando el protocolo estándar del
puerto serie [13].
LiquidCrystal
Control de LCDs con chipset Hitachi HD44780 o compatibles [14]. La librería soporta los
modos de 4 y 8 bits.
Servo
Control de servo motores [15]. A partir de la versión 0017 de Arduino la librería
soporta hasta 12 motores en la mayoría de placas Arduino y 48 en la Arduino Mega.
• attach(), write(), writeMicroseconds(), read(), attached(), detach()
El manejo de la librería es bastante sencillo. Mediante attach(numero de pin)
añadimos un servo y mediante write podemos indicar los grados que queremos que
tenga el motor (habitualmente de 0 a 180).

SoftwareSerial
Comunicación serie en pines digitales [16]. Por defecto Arduino incluye comunicación
sólo en los pines 0 y 1 pero gracias a esta librería podemos realizar esta comunicación
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 recepción de datos sobre una red de dispositivos o sensores mediante Two
Wire Interface (TWI/I2C) [18].

Además las librerías Matrix y Sprite de Wiring son totalmente compatibles con Arduino
y sirven para manejo de matrices de leds.
También se ofrece información sobre diversas librerías desarrolladas por

contribuidores diversos que permiten realizar muchas tareas.
3.3.2 Creación de librerías

Además de las librerías base, las que son compatibles y las que han aportado otras
personas tenemos la posibilidad de escribir nuestra propia librería [19]. Esto es muy
interesante por varias razones: permite disponer de código del que disponer en otros
proyectos de forma cómoda; nos permite mantener el código fuente principal
separado de las librerías de forma que sean mantenibles de forma separada; y es mas
organizado y elegante.
Veamos un ejemplo de la creación de una librería que envía código Morse:
Creamos el fichero Morse.h que incluye la definición de la clase Morse que tiene 3
funciones: un constructor (Morse()), una función para enviar 1 punto (dot()) y una
función 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
Además necesitaremos un fichero Morse.cpp con el código de las funciones

declaradas. A continuación se muestra el código:
/*
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 podríamos utilizar la librería mediante el correspondietne #include. Si

quisieramos enviar un SOS por el pin 13 bastaría 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] “Manipulación 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 Introducción
El Entorno de Desarrollo de Arduino (más conocido como IDE – Integrated
Development Environment) es una herramienta que funciona en diferentes plataformas
(Windows, Macintosh, Linux) dedicada a la edición y descarga de programas en la placa
Arduino.
El código que se ejecuta en las placas está basado en las librerias de aplicación Wiring
API y en las de desarrollo de los integrados AVR.

4.2 Instalación del Software Arduino

Debido a que el software se encuentra disponible para los sistemas
operativos Windows, Mac OS y GNU/Linux, se explicará cómo 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 Instalación del IDE en Windows
Para la instalación de la placa Arduino en Windows, conviene tener instalado
la última versión de Java Runtime Enviroment (J2RE) que se puede descargar de la web
de Sun[1].
1. Descargar el entorno Arduino
Descargar la última versión 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. Sólo 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 distribución.
Si por algún motivo se desea descargar nuevos drivers, en la dirección

http://www.ftdichip.com/Drivers/VCP.htm se puede encontrar los más actuales
A continuación, conectamos la placa USB:

Figura 4.1: Conexión del cable USB a la placa Arduino
Se debería encender el LED de alimentación

Se abrirá automáticamente el asistente Añadir Nuevo Hardware:
1. Seleccionar “No por el momento” y presionar “Siguiente”.

2. Seleccionar “Instalar desde una lista o ubicación específica” y presionar
“Siguiente”.
3. "Buscar el controlador más adecuado en estas ubicaciones" presionar
"Examinar". Seleccionar la carpeta donde se haya descomprimido el driver y
presionar “Siguiente”.
Si no ha habido ningún 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: Selección del puerto donde está conectado la placa en Windows

Así como seleccionar el modelo de tarjeta apropiado.

Figura 4.3: Selección de la placa Arduino deseada en Windows

4.2.2 Instalación del IDE en Mac OS X (v. 10.3.9 o posterior)
1. Descarga del entorno Arduino
Descargar la última versión 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 distribución
Arduino.
Si se posee un Mac más antiguo como un Powerbook, iBook, G4 o G5, se
debería usar los drivers PPC: FTDIUSBSerialDriver_v2_1_9.dmg.
Si se posee un Mac más 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 versión 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 guardarán 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: Selección 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: Selección del puerto donde está conectado la placa en Mac OS X
Debemos escoger la opción parecida a /dev/tty.usbserl-XXXXXXX. Si no

apareciese ninguna opción, puede ser debido a que, o tenemos mal conectado la placa
o los drives no están bien instalados como en el caso de la Figura 4.5.

4.2.3 Instalación del IDE en GNU/Linux
Estas instrucciones se centran en la distribución Ubuntu1, para más

información sobre cómo instalar el entorno Arduino en otras distribuciones visitar
http://www.arduino.cc/playground/Learning/Linux.

1. Ejecutar el Gestor de Paquetes Synaptic (en Sistema > Administración ).
2. Primero se necesita habilitar los repositorios <<Universe>> y <<Multiverse>>
para que se pueda acceder a todos los paquetes necesarios.
a. Ir a Configuración > Repositorios.
b. Click en Añadir.
c. Marcar <<Software restringido por copyright o cuestiones legales
(multiverse)>> y <<Software libre mantenido por la comunidad
(universe)>> y click en Añadir.
d. Clicl en Cerrar y en Cerrar en el diálogo <<Los repositorios han
cambiado>>.
3. Click en el botón 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 diálogo. Esto instalará los paquetes
seleccionados.
7. Aceptar la licencia de Java.
8. Esperar hasta completar la instalación: el cuadro de diálogo dirá <<Cambios
aplicados>>. Click en Cerrar.
9. Cerrar Sypnaptic.
10. Descargar la distribución 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 algún lugar (por ejemplo, el Escritorio).
11. Ejecutar el Terminal (en Aplicaciones > Accesorios).
12. Escribir <<sudo update-‐alternatives –config.java>> y presionar Enter. Teclear el
número de opción que tiene <<java-‐1.5.0-‐sun>> en él y presionar Enter. Esto
hará de la versión de Java de Sun la predeterminada del sistema (necesaria
porque la versión GNU todavía no soporta todo lo necesitado por el entorno
Arduino).
13. Doble click en <<Arduino>> en el directorio de aplicación de Arduino. Esto
debería lanzar un diálogo preguntando dónde se guardan los archivos de las
rutinas de Arduino. Un directorio <<Arduino>> en la carpeta home es la
ubicación típica. Click en OK. El entorno Arduino debería abrirse.

4.3 Introducción al entorno Arduino
Menús
Menú
Tabulador
Barra de
Herramientas
Área de
código

Figura 4.6: Elementos del entorno de desarrollo en Windows
4.3.1 Barra de Herramientas
Icono Nombre Descripción

Verify/Compile Chequea el código 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 código a la placa Arduino I/O.
board
Serial Monitor Muestra datos serie enviados desde la placa Arduino


Tab Menu Permite gestionar las rutinas con más de un archivo (cada
uno de los cuales aparece en su propia pestaña). Estos
pueden ser:
• Archivos de código de Arduino (sin extensión).

• Archivos de C (extensión .c).
• Archivos de C++ (extensión .cpp).
• Archivos de cabecera (extensión .h).
4.3.2. Menús
Sketch
• Verify/Compile: Comprueba la rutina para detectar errores.

• Import Library: Utiliza una librería en la rutina. Trabaja añadiendo #include en
la cabecera del código. Esto añade funcionalidad extra a la rutina, pero
incrementa su tamaño. Para dejar de usar una librería, eliminar el #include
apropiado.
• Show Sketch Folder: Abre la carpeta de rutinas
• Add File: Añade otro fichero fuente a la rutina. El nuevo archivo aparece en una
nueva pestaña en la ventana de la rutina. Esto facilita y agranda proyectos con
múltiples archivos fuente. Los archivos pueden ser eliminados de una rutina
usando el Tab Menu.
Tools
• Auto Format: Esto formatea el código

• Copy for Discourse: Copia el código 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 máquina. Debería actualizarse automáticamente 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 electrónico que permite que un motor de corriente

continua gire en un sentido u otro y su nombre proviene de la apariencia de su representación
gráfica 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 pasaría 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 ningún sentido.
En la práctica no se implementas los puentes en H con interruptores, si no que se utilizan
transistores que en función de las tensiones que apliquemos en su puerta, estará en corte o en
saturación, impidiendo o dejando así pasar la corriente a través de los mismos [1].
El integrado L293NE, está preparado para conectarle hasta 4 motores, por lo que para el
diseño de un robot que tenga dos o cuatro ruedas motrices, sólo necesitaremos un integrado.

En la figura 2, podemos observar el patillaje del integrado y una tabla de verdad con las
salidas que provoca cualquier combinación de entradas al mismo.
Figura 2. Patillaje del L293NE.
5.1.2 Conexión 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 eléctrico [1] sería el de la figura 3.
Figura 3. Conexiones eléctricas
Utilizaremos la alimentación externa del Arduino, para lo que tendremos que cambiar el
switch de alimentación, 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 alimentación del motor y tierra para evitar así los
picos de tensión que se producen al conectar y desconectar el motor.
Una vez montado el circuito sólo nos queda programar nuestro Arduino para que podamos
controlar nuestro motor de corriente continua.
5.1.3 Programación

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 continuación configuraremos los pines del Arduino como entrada o salida, también
haremos que el led parpadee 3 veces, pero esto sólo debería pasar una sola vez, ya que si
ocurre más 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);
}

Función para hacer que el led parpadee un cierto número de veces cada cierto periodo,
que se le pasan como parámetros. Como hemos visto en el código anteriormente, nuestro led
parpadeará 3 veces con un intervalo de 100 milisegundos. La función 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 sólo nos queda la función principal de nuestro programa, que estará implementada de
forma que lea el valor del interruptor para saber en qué dirección 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) { //dirección 1
digitalWrite(motor1Pin, LOW);
digitalWrite(motor2Pin, HIGH);
}
else { // dirección 2
digitalWrite(motor1Pin, HIGH);
digitalWrite(motor2Pin, LOW);
}
}

Ahora ya sólo tendríamos que cargar nuestro programa en el Arduino y mediante el

interruptor podemos controlar la dirección 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 expansión para el Arduino, la cual mediante librerías
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 dirección y 2
motores paso a paso (unipolares o bipolares) con bobina simple, doble o micro paso a paso.
Además cuenta con una entrada externa para la alimentación 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)
Alimentación 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 dirección de giro y la velocidad mediante el PWM. Para
poder realizar este control debemos incluir la librería 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 sólo funcionan a 1KHz.
• Se puede ajustar la velocidad de giro del motor con la función setSpeed (velocidad), a
la que le pasaremos un valor comprendido entre 0 (parado) y 255 (velocidad máxima).

• Para hacer funcionar el motor tenemos que llamar a la función run (dirección), a la que
le pasaremos hacia donde queremos que gire el motor, las posibilidades con:
fORDWARE (hacia adelante), BACKWARD (hacia atrás) 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 dirección, al cabo de un segundo girará en dirección 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 atrás
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 energía, se deberían alimentar mediante la conexión de alimentación
externa. El PWM para el control de los servos es de 16 bits y para poder realizar este control
debemos incluir la librería ServoTimer1.h y seguir los siguientes pasos [2]:
• Crear un objeto ServoTimer para cada servo (máximo 2).
• Conectar los servos al pin 9 (servo A) o pin 10 (servo B) usando la función attach().
• Fijar la posición del servo con la función write (ángulo), donde el ángulo puede variar
desde 0 a 180.
En el siguiente ejemplo utilizaremos dos servos que estará cada uno en la posición 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 librerías 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 librería 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 cuántos pasos por revolución 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 estás utilizando M1 y M2, el puerto será 1y si estás utilizando
M3 y M4 el puerto será el 2.
• Ajuste la veloicdad del motor utilizando la función setSpeed (rpm) donde rpm son las
revoluciones por minuto.
Cada vez que se quiera mover el motor hay que utilizar la función step (#pasos,
•
dirección, tipo_paso), donde #pasos es el número de pasos que quieres dar, dirección
puede tomar los valores FORWARD o BACKWARD para ir hacia adelante o hacia atrás
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 posición dada, podemos utilizar la
función 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 Móviles.
6.1 Introducción
ASURO es un pequeño robot móvil desarrollado por DLR (el centro aeroespacial
alemán) para proyectos educativos.
A excepción de la placa o circuito impreso

(PCB), el resto de los componentes
utilizados y las herramientas de software,
son estándares o libres “freeware”, de
forma que puede ser reprogramado y
ampliado muy fácilmente. De este modo
ASURO puede servir como introducción al
mundo de los microprocesadores, robótica,
etc. en colegios, universidades, así como
para centros de educación para adultos.
Se puede comprar on-‐line y su precio ronda los 50 Euros.
Como se muestra a continuación, ASURO viene con un micro Atmega8, dos motores
controlados de forma independiente, un seguidor de líneas óptico, seis sensores de
contacto o colisión, dos odómetros, tres LED’s indicadores de estado y un interfaz IR-‐
para programación y control remoto vía 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 analógica). De esta forma, se obtendrá un valor diferente,
dependiendo del pulsador pulsado o de la combinación de los mismos.
• LED’s

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 líneas y situado en la parte
inferior. Su activación 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 odómetro, es decir, se activan los pines
PC0 y PC1 como entradas (analógica) 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 baterías o monitor de voltaje

El medidor de voltaje consiste de un simple divisor de tensión. Y va

conectado al pin PC5 como entrada analógica.
• Interfaz de Infrarrojos a 36KHz

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

• Odómetros 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
revolución.
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 simultáneamente) y leer los Pines (entradas analógicas): PC1 (T11-‐
izquierdo) y PC0 (T12-‐derecho).
• Seguidor de líneas
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 línea negra (donde no se
reflejara la luz), se podría crear una
función que siguiera dicha línea.
Para ello el procesador debe activar el Pin (salida digital): PD6 (D11-‐ frontal) y leer
los Pines (entradas analógicas):PC3 (T9-‐izquierdo) / PC2 (T10-‐derecho).
• Motores
Para manejar cada uno de los motores se utilizan puentes H (H-‐bridge).
Lógica 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
señal PWM para el control de la velocidad. PD4 y PD5 (y/o PB4 y PB5)
determinan la dirección de rotación del motor (salidas digitales).
A continuación se muestra una tabla, donde se resume todo esto:
Función PD5 PD4

Avanza 1(activo) 0(inactivo)
Retrocede 0 1
Frena 0 0
Operación de “no-‐load” 1 1
6.2.2 Construcción

Por el momento sólo 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 inglés, pero siguiendo los gráficos que aparecen en él no es

muy difícil de montar. Aún así en el siguiente enlace se puede encontrar
información en castellano.
• http://arduino.cc/es/Ensamblado-‐Asuro/Ensamblado-‐Asuro
Unas notas:
El oscilador (Q1: el pequeño componente marrón 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 comprobación o TEST de todos sus componentes y
funcionalidades, de forma que se pueda detectar si se ha producido algún 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 lógica AND) en los
zócalos, activa el interruptor a ON. Los LEDs situados en la parte trasera (D15,
D16), deberían de brillar tenuemente (prueba en la oscuridad!).
Si no lo hacen, desactiva inmediatamente el interruptor a off y continúa

leyendo en la parte de resolución 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 lógica AND) en sus correspondientes
zócalos.
Las marcas de la polaridad de los chips (muescas) deben estar alineadas con las
marcas de los zócalos. También, las patas del chip o IC deben ser dobladas muy
cuidadosamente para que puedan quedar todas insertadas en los agujeros de
contacto del zócalo.
El procesador o ATmega8 del Asuro, se ha diseñado 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 baterías recargables. Entonces activa el interruptor a On y verifica lo
siguiente:
El LED de estado (D12) debe emitir una luz naranja (combinación de rojo y
verde) y los LEDs traseros (D15, D16) deben estar activos. Si esto no pasa,
desactiva el interruptor inmediatamente y continúa leyendo en resolución de
problemas.
o Prueba de LEDs
Lo anterior, sólo ha sido la secuencia básica de arranque del ASURO. En

la siguiente fase todos los elementos serán 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 Led’s activados al mismo tiempo
Si ocurre algún error, desactiva el interruptor a OFF inmediatamente y

continúa leyendo en resolución de problemas.
o Fototransistores de parte inferior
Después de terminar el Test de los Leds, el LED de estado (D12) debería

quedarse en color verde, indicando la comprobación de los
fototransistores (T9, T10), situados en la parte inferior del ASURO y
responsables del sigue líneas. La comprobación 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 algún error, el Test no se interrumpe, de forma que el error se
puede evaluar más adelante.
o Pulsadores o sensores de choque
A continuación se van a chequear los pulsadores, durante 15 segundos.

Sólo 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
serán chequeados más adelante.
Pulsando varios pulsadores al mismo tiempo se iniciará la equivalente

combinación de señales.

o Odómetros
A continuación el Led frontal (D11) se activa. Lo que indica el comienzo
del próximo Test (15 segundos), en el cual, ambos odómetros

(consistentes de un LED D13/D14 y un fototransistor T11/T12
respectivamente) serán 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 odómetros están funcionando
correctamente.

o La mecánica o los motores
Los Leds traseros (D15, D16) se encenderán, indicando el último test, y
durará 15 segundos.
Los motores serán chequeados intensivamente. El motor izquierdo se

activa en la dirección izquierda desde la velocidad mínima a máxima y
vuelta a empezar.
Entonces se invierte la dirección de giro y la velocidad se vuelve a

acelerar desde el mínimo al máximo y vuelta a empezar. La misma
comprobación se realizará con el motor derecho. Después de ambos
chequeos ambos motores se comprobarán de forma simultánea.

o IR interface
Existe un último Test que dura también 15 segundos y que se realiza

sobre el interfaz de infrarrojos. Para ello hay que montar la placa
pequeña, de forma que se pueda establecer la comunicación 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 (vía transmisión 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 continuación.
Saca el ATmega8 de la placa del Asuro

(guárdalo, 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 (Asegúrate 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 líneas en el fichero de
preferencias de Arduino (es recomendable hacer una copia del fichero original, antes
de hacer dicha modificación):
La ubicación 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 líneas 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 Conexión y programación de Asuro con Arduino

Para poder programar el Asuro con Arduino, también 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 continuación se muestra la relación 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, información necesaria para su
posterior programación con Arduino:

Librerías 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, vía cable USB (u RS232). De esta forma se podrá
descargar programas desde el entorno de Arduino. Sólo 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
botón de "upload" en el entorno de programación de Arduino. Si no funciona,
comprueba la conexión de los cables que van a los pines 0 y 1 sobre la placa Arduino.
Los comandos Arduino, para la comunicación serie, deberían de funcionar sin ningún
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 más faciles e intuitivas.
Setup(): La función 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 librerías, etc.
void setup() //Sección 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 sección loop() hace precisamente lo que su nombre indica en inglés(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, varía según el número de instrucciones que contenga. Y se puede conocer
y controlar con las funciones de temporización (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 analógico, la
tarjeta Arduino realiza una conversión analógica 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 analógico (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. Después de invocar o realizar una llamada a la función analogWrite, el
pin generará una señal estable hasta la próxima invocación o llamada de la función
analogWrite (o una llamada a digitalRead o digitalWrite sobre el mismo pin).

value: representa al parámetro "ciclo de trabajo"y puede tomar valores entre 0 y 255.
0 corresponde a una señal de salida de valor constante de 0 v (LOW) o 0% de "ciclo de
trabajo"; 255 es una señal de salida de valor constante de 5 v (HIGH) o 100% de "ciclo de
trabajo"; . Para valores intermedios, el pin rápidamente alterna entre 0 y 5 voltios -‐ el valor
más alto, lo usual es que el pin esté en high (5 voltios).

int ledPin = 9; // LED conectado al pin digital 9
int analogPin = 3; // potenci�metro conectado al pin anal�gico 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 contunuación son válidas para la version 0004 e inferiores:

beginSerial(int speed) : Inicializa el puerto serie asignándole una velocidad de transmisión de
datos (bits por segundo). Dicha función debe ser llamada desde dentro de lasección setup().

serialWrite(character) : Envía un byte (como caracter ASCII que representa el valor numérico
de dicho byte) al puerto serie.

SerialAvailable() : Obtiene un número entero con el número 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 alg�n byte

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

printMode(mode): Esta función determina si la salida de la función 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 numérico 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 número entero codificado o en caracteres ASCII en formato
decimal al puerto serie; de esta forma, transmite la secuencia de números en ASCII, de la
representación en base 10 del número entero.

printHex(num) : Vuelca un entero codificado o en caracteres ASCII, en formato
hexadecimal al puerto serie; de esta forma, transmite la secuencia de números y letras en
ASCII, de la representación en base 16 del número 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 representación en base 2 del número entero.

PrintNewline() : Imprime o vuelca un carácter de salto de línea ('\n') en el puerto serie.

Estas funciones son validas de la versión 0004 en adelante:

Serial.begin(int speed) : Equivalente a la función beginSerial().

Serial.available() : Equivalente a la función 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() {
// envía datos sólo 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 función 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() {
// envía datos sólo 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) : Envía un número o una cadena de caracteres, al puerto serie.
Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que
utilicemos para definir el formato de volcado de los números.
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 carácter ASCII asociado a dicho valor
str: escribe la cadena de caracteres.

Serial.printnl(data, data type) : Envía un número o una cadena de caracteres al puerto serie,
seguido de un carácter de retorno de carro "CR" ('\r')y un carácter de salto de línea "LF"('\n').
Toma la misma forma que el comando Serial.print()


A continuación 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 parámetro.

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 parámetro.

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 más funciones, matemáticas,
trigonométricas... más complejas, en librerías aparte.

Por lo demás es todo igual que en C, sólo que no existen los puertos, sino que son solo pines.
A continuación 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. También 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 código 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);

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

Trabajo Arduino V1.4

Cargado por

Copyright:

Formatos disponibles

PLATAFORMA

INTRODUCCIÓN AL DISEÑO DE MICRO-­‐ROBOTS 2009/2010

Víctor Alonso Mendieta Alberto De Lope

Álvaro Tanarro Santamaría Carlos de la Rubia Tuya

Plataforma Arduino en diseño de Robots Móviles Página 2

Plataforma Arduino en diseño de Robots Móviles Página 3

Plataforma Arduino en diseño de Robots Móviles Página 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 diseño de Robots Móviles Página 5

Registros de Propósito General.

A cada registro se le asigna una dirección mapeada directamente en las primeras 32

Plataforma Arduino en diseño de Robots Móviles Página 6

ALU -­‐ Unidad Aritmético-­‐Lógica

Registro de Estado

El registro de estado contiene información sobre los resultados de las operaciones

Puntero de Pila

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 diseño de Robots Móviles Página 8

• Los pines de alimentación del chip: VCC y GND.

• Los pines de alimentación del Convertidor A/D: AVCC y AREF.

En la siguiente figura se muestra el esquema correspondiente a un pin genérico con

Plataforma Arduino en diseño de Robots Móviles Página 11

De la misma manera las interrupciones externas adicionales denominadas PCINT

Plataforma Arduino en diseño de Robots Móviles Página 12

A continuación se muestra el esquema de funcionamiento del

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

Plataforma Arduino en diseño de Robots Móviles Página 13

Plataforma Arduino en diseño de Robots Móviles Página 14

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

• Registro Máscara de Interrupción (TIMSK0): Habilita las interrupciones

2.1.4. Convertidor Analógico/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

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

Plataforma Arduino en diseño de Robots Móviles Página 17

Figura 30: Registro de Estado y de Control B.

1.2.5. Comparador Analógico.

A continuación se describen los registros que utiliza este periférico:

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

Plataforma Arduino en diseño de Robots Móviles Página 18

• Registro de Control y de Estado (ACSR): conecta la alimentación del

Plataforma Arduino en diseño de Robots Móviles Página 19

2.2Tipos de placas y perifericos

Se va a tratar de explicar las características hardware de distintas placas y los

2.2.1 Duemilanove Arduino

Plataforma Arduino en diseño de Robots Móviles Página 20

Plataforma Arduino en diseño de Robots Móviles Página 21

Plataforma Arduino en diseño de Robots Móviles Página 23

Plataforma Arduino en diseño de Robots Móviles Página 25

El ATmega168 tiene 16 KB de memoria flash para almacenar el código (de los

Plataforma Arduino en diseño de Robots Móviles Página 26

2.2.3 Nano Arduino

El chip FTDI FT232RL montado en el Nano es alimentado sólo si la placa está

Plataforma Arduino en diseño de Robots Móviles Página 27

La Mega Arduino es una placa basada en el microcontrolador ATMEGA1280

Plataforma Arduino en diseño de Robots Móviles Página 28

• SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). Estos son pines de apoyo a la

Plataforma Arduino en diseño de Robots Móviles Página 29

Una biblioteca SoftwareSerial permite la comunicación de serie en cualquiera de los pines

Plataforma Arduino en diseño de Robots Móviles Página 30

Plataforma Arduino en diseño de Robots Móviles Página 31

INTRODUCCIÓN AL DISEÑO DE MICRO-‐ROBOTS 2009/2010

ALU -‐ Unidad Aritmético-‐Lógica

• El uso de un convertidor DC-‐DC, lo que permite a la placa ser alimentado con un