Escolar Documentos
Profissional Documentos
Cultura Documentos
ARDUINO
en diseo de Robots
Mviles
GRUPO A
Ivn Cantero Mencerreyes Yen Hi Lee Lay
Pedro Quintero
Quintero
NDICE
1.
Introduccin .........................................................................................................................................................4
2.
Descripcin
Hardware .....................................................................................................................................5
2.1.
Microcontrolador
Atmega168/V .............................................................................................................5
2.1.1.
Caractersticas
Generales..................................................................................................................5
2.1.2.
Arquitectura............................................................................................................................................6
2.2
Tipos
de
placas
y
perifericos ................................................................................................................... 20
2.2.1
Duemilanove
Arduino....................................................................................................................... 20
2.2.2
Diecimila
Arduino............................................................................................................................... 26
2.2.3
Nano
Arduino ....................................................................................................................................... 27
2.2.4
Mega
Arduino ....................................................................................................................................... 28
2.2.5
Otras
placas........................................................................................................................................... 31
3.
Libreras
en
Arduino...................................................................................................................................... 33
3.1
Introduccin ................................................................................................................................................... 33
3.2
Lenguaje
de
programacin
Arduino..................................................................................................... 34
3.2.1
Processing.............................................................................................................................................. 34
3.2.2
Funciones
bsicas
y
operadores .................................................................................................. 34
3.2.3
AVR
Libc ................................................................................................................................................. 37
3.2.4
Diferencias
con
Processing............................................................................................................. 40
3.2.5
Ejemplo
prctico:
Hola
Mundo
en
Arduino ............................................................................. 41
3.3
Extendiendo
la
funcionalidad:
Libreras ............................................................................................ 42
3.3.1
Libreras
principales ......................................................................................................................... 42
3.3.2
Creacin
de
libreras ......................................................................................................................... 43
4.
SOFTWARE......................................................................................................................................................... 47
4.1
Introduccin ................................................................................................................................................... 47
4.2
Instalacin
del
Software
Arduino .......................................................................................................... 47
4.2.1
Instalacin
del
IDE
en
Windows .................................................................................................. 47
4.2.2
Instalacin
del
IDE
en
Mac
OS
X
(v.
10.3.9
o
posterior)..................................................... 51
4.2.3
Instalacin
del
IDE
en
GNU/Linux .............................................................................................. 53
4.3
Introduccin
al
entorno
Arduino........................................................................................................... 54
4.3.1
Barra
de
Herramientas..................................................................................................................... 54
4.3.2.
Mens ..................................................................................................................................................... 55
5.
Control
de
motores
con
Arduino .............................................................................................................. 56
5.1
Control
de
motores
DC
con
puente
en
H ............................................................................................ 56
5.1.1
Puente
en
H.
.
56
5.1.2
Conexin
del
motor
y
el
puente
en
H ......................................................................................... 57
5.1.3
Programacin....................................................................................................................................... 58
5.2
Control
de
motores
con
Motor
Shield
Arduino ........................................................................... 59
5.2.2
Control
de
motores
de
corriente
continua
con
Motor
Shield.......................................... 60
5.2.3
Control
de
servos
con
Motor
Shield ........................................................................................... 61
5.2.4
Control
de
motores
paso
a
paso
con
Motor
Shield............................................................... 62
6.
Aplicaciones
de
Arduino
en
Micro-Robots
Mviles.......................................................................... 64
6.1
Introduccin ................................................................................................................................................... 64
6.2
Montaje ............................................................................................................................................................. 65
6.2.1
Componentes ......................................................................................................................................... 65
6.2.2
Construccin .......................................................................................................................................... 68
6.2.3
Test
del
Asuro........................................................................................................................................ 69
6.3
ATmega8 .......................................................................................................................................................... 72
6.3.1
Reemplazamiento
del
ATmega8.................................................................................................... 72
6.3.2
Cambiando
los
ficheros
de
Arduino............................................................................................. 72
6.3.3
Conexin
y
programacin
de
Asuro
con
Arduino .................................................................. 73
6.4
Funciones..
...77
1.
Introduccin
ste
trabajo
acerca
de
Arduino
tiene
como
nico
objetivo
ilustrar
a
cualquier
persona
que
se
inicie
en
el
conocimiento
y
desarrollo
de
aplicaciones
con
la
placa.
2.
Descripcin
Hardware
2.1.
Microcontrolador
Atmega168/V
2.1.1.
Caractersticas
Generales
Figura
1:
Diagrama
de
Bloques.
2.1.2.
Arquitectura.
Figura
2:
Arquitectura
del
AVR.
Figura
3:
Registros
de
Propsito
General.
como
tres
punteros
de
16
bits
para
direccionamiento
indirecto
a
memoria
de
datos.
Estos
registros
se
denominan
X,
Y,
Z.
La
ALU
opera
en
conexin
directa
con
los
32
registros
de
propsito
general.
Las
operaciones
aritmticas
entre
los
registros
se
realizan
dentro
de
un
solo
ciclo
de
reloj.
Las
operaciones
soportadas
por
la
ALU
se
dividen
en
tres
categoras
principales:
aritmticas,
lgicas,
y
funciones
a
nivel
de
bit.
Algunas
implementaciones
de
la
arquitectura
proporcionan
un
multiplicador
que
realiza
operaciones
de
multiplicacin
con
o
sin
signo.
Registro de Estado
Figura
4:
Registro
de
Estado.
Puntero de Pila
Figura
5:
Puntero
de
Pila.
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
7
Memoria.
Figura
6:
Mapa
de
memoria
Flash.
Memoria
SRAM.
La
memoria
SRAM
del
ATmega168
tiene
una
capacidad
de
1Kbyte
para
datos.
Las
32
primeras
posiciones
direccionan
a
los
registros
de
propsito
general,
los
siguientes
64
localizaciones
para
registros
estndar
de
entrada/salida
(registros
de
los
perifricos),
despus
160
posiciones
para
memoria
extendida
de
entrada/salida
y
las
ltimas
1024
para
memoria
de
datos
interna.
asociado
a
tres
registros:
un
Registro
de
Direcciones
(EEAR),
un
Registro
de
Datos
(EEDR)
y
un
Registro
de
Control
(EECR).
.
2.1.3.
Puertos
de
Entrada/Salida.
La
figura
2
muestra
la
distribucin
de
terminales
del
microcontrolador
para
un
encapsulado
PDIP:
Figura
8:
Encapsulado
PDIP.
A
continuacin
se
detallan
los
terminales
del
ATmega168.
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
9
Figura
9:
Funciones
Alternativas
Puerto
B.
o El
Puerto
C
tiene
como
funciones
alternativas
las
siguientes:
entrada
de
reset
(RESET),
canales
de
entrada
al
ADC
(ADC0..ADC5),
comunicacin
serie
TWI
(SCL,
SDA)
y
tambin
incorpora
fuentes
de
interrupcin
externas
(PCINT8..PCINT14).
Figura
10:
Funciones
Alternativas
Puerto
C.
o Las
funciones
alternativas
del
Puerto
D
son:
canales
de
entrada
al
Comparador
Analgico
(AIN0,
AIN1),
modulacin
en
pulso
de
seal
PWM
(OC0A,
OC0B,
OC2B),
entrada
de
seal
de
reloj
sncrona
externa
para
los
Temporizadores/Contadores
(T0,
T1),
comunicacin
serie
USART
(XCK,
TXD,
RXD)
y
fuentes
de
interrupcin
externas
(INT0,
INT1,
PCINT16..PCINT23).
Figura
11:
Funciones
Alternativas
Puerto
D.
Cada
pin
del
puerto
tiene
asociado
tres
registros
de
8
bits
para
cada
puerto
(x):
Registro
de
Direcciones
(DDRx)
para
configurar
la
direccin
de
los
pines
del
puerto
(entrada/salida),
el
Registro
de
Datos
del
Puerto
(PORTx)
para
escribir
o
leer
en
el
pin
correspondiente
configurado
como
salida
y
para
leer
los
pines
del
puerto
configurados
como
entrada
el
Registro
de
los
Pines
(PINx).
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
10
Figura
12:
Configuracin
de
Pines.
Figura
13:
Esquema
de
un
Pin
Genrico
2.1.4.
Interrupciones.
El
ATmega168
dispone
de
26
fuentes
de
interrupcin
asociadas
a
los
perifricos
del
microcontrolador
y
a
seales
externas
al
mismo.
En
la
siguiente
tabla
se
muestra
la
direccin
de
memoria
de
programa
asignada
a
cada
interrupcin:
Figura
14:
Tabla
de
Vectores
de
Interrupcin.
Figura
15:
Registro
de
Control
de
Interrupciones
Externas
INT0
e
INT1.
Registro
Mscara
(EIMSK):
Con
este
registro
se
habilitan
(1)
o
deshabilitan
(0)
las
fuentes
de
interrupcin
externas
INT0
e
INT1,
siempre
y
cuando
el
bit
I
del
Registro
de
Estado
este
activo.
Figura
16:
Registro
Mscara
de
Interrupciones
Externas
INT0
e
INT1.
Figura
17:
Registro
de
Bandera
de
Interrupciones
Externas
INT0
e
INT1.
Registro
de
Control
(PCICR),
Registros
Mscara
(PCMSK0..PCMSK2)
y
Registro
de
Bandera
(PCIFR).
2.1.4.
Temporizador/Contador.
Este
microcontrolador
contiene
tres
Temporizadores/Contadores:
un
Temporizadores/Contadores
de
8
bits
(TCNT0
y
TCNT2)
y
un
Temporizador/Contador
de
16
bits
(TCNT1).
Cada
uno
de
los
Temporizadores/Contadores
contiene
dos
unidades
de
comparacin
que
permiten
la
generacin
de
seales
con
modulacin
en
pulso
PWM
(OCR).
Se
explicar
el
primero
de
ellos
(TCNT0)
siendo
anlogo
el
funcionamiento
de
los
dems.
Figura
18:
Diagrama
de
Bloques
del
Temporizador/Contador
0.
A
continuacin
se
pasan
a
describir
los
principales
registros
asociados
al
Temporizador
Contador
0:
Registro
de
Control
A
(TCCR0A):
Con
este
registro
se
controla
la
funcin
alternativa
de
los
pines
de
salida
para
PWM
(OC0A,
OC1A,
OC0B
y
OC1B)
con
los
bits
COM0A0,
COM0A1,
COM0B0
y
COM0B1.
Tambin
permite
elegir
entre
varios
modos
de
funcionamiento
del
generador
de
onda
con
WGM01
y
WGM00.
Figura
19:
Registro
de
Control
A.
Registro
de
Control
B
(TCCR0B):
Las
funciones
de
este
registro
son
habilitar
los
registros
de
comparacin
para
el
generador
de
onda
(FOC0A,
FC0B),
seleccionar
el
modo
de
funcionamiento
(WGM02)
y
seleccionar
la
fuente
de
reloj
(CS00..CS02).
Figura
20:
Registro
de
Control
B.
Figura
21:
Registro
Temporizador/Contador.
Figura
22:
Registro
de
Comparacin
A
(B,
anlogo).
Figura
23:
Registro
Mscara
de
Interrupciones.
Registro
Bandera
de
Interrupcin
(TIFR0):
Sus
bits
se
ponen
a
uno
cuando
las
interrupciones
de
comparacin
y
la
de
desborde
se
activan.
Figura
24:
Registro
Bandera
de
Interrupciones.
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
15
Figura
25:
Diagrama
de
Bloques
del
ADC.
registro
ADCSRA
es
el
encargado
de
generar
las
seales
de
control
del
ADC
como
la
seal
de
enable,
la
seal
de
inicio
de
conversin,
el
prescaler
de
conversin
y
las
seales
de
interrupcin.
Para
el
control
de
las
distintas
funcionalidades
del
Convertidor
A/D
se
utilizan
los
siguientes
registros:
Registro
de
Seleccin
del
Multiplexor
(ADMUX):
Permite
seleccionar
distintos
voltajes
de
referencia
(REFS1,
REFS0)
y
tambin
el
canal
de
entrada
al
ADC
(MUX0..MUX3).
EL
bit
ADLAR
ajusta
el
resultado
a
la
derecha
o
izquierda
del
registro
de
datos.
Figura
26:
Registro
de
Seleccin
del
Multiplexor.
Figura
27:
Registro
de
Estado
y
de
Control
A.
Figura
28:
Registros
de
Datos.
Figura
29:
Registro
de
Estado
y
de
Control
B.
Figura
31:
Diagrama
de
Bloques
del
Comparador
Analgico.
Figura
32:
Registro
de
Estado
y
de
Control
B.
Figura
33:
Registro
de
Control
y
de
Estado.
Figura
34:
Registro
de
Control
y
de
Estado.
Referencias
[1]Datasheet
ATmega48/68/168/V
AVR
Atmel,
2007-2009.
Resumen
-Microcontrolador
ATmega168
Atmega328
-Tensin
de
funcionamiento:
5V.
-Entrada
de
voltaje
(recomendado):
7-12V.
-Voltaje
de
entrada
(lmites):
6-20V.
-Pins
Digitales
I
/
O:
14
(de
las
cuales
6
proporcionar
una
salida
PWM).
-Pins
de
entrada
analgica:
6.
-
Corriente
DC
de
pin
I
/
O:
40
mA..
-Corriente
DC
para
Pin
de
3.3V:
50
mA.
-Memoria
Flash:
16
KB
(ATmega168)
o
de
32
KB
(Atmega328)
de
los
cuales
2
KB
utilizado
por
el
bootloader
(arranque).
-Memoria
SRAM:
1
KB
(ATmega168)
o
2
KB
(Atmega328).
-Memoria
EEPROM
512
bytes
(ATmega168)
o
1
KB
(Atmega328).
-Velocidad
del
reloj
de
16
MHz.
Alimentacin
El
Duemilanove
Arduino
puede
ser
alimentado
a
travs
de
la
conexin
USB
o
con
una
fuente
de
alimentacin
externa.
La
fuente
de
alimentacin
se
selecciona
automticamente.
La
alimentacin
externa
(no
USB)
puede
proceder
de
un
adaptador
AC
a
DC
o
una
batera.
El
adaptador
se
puede
conectar
con
una
clavija
2,1
mm
de
centro-positivo
en
el
enchufe
de
alimentacin
de
la
placa.
Una
batera
puede
ser
insertada
entre
el
GND
y
el
pin
de
alimentacin.
La
tarjeta
puede
operar
con
una
fuente
externa
de
6
a
20
voltios.
Si
se
suministra
con
menos
de
7V,
sin
embargo,
el
pin
de
5V
puede
proporcionar
menos
de
estos
cinco
voltios
y
la
placa
puede
ser
inestable.
Si
utiliza
ms
de
12V,
el
regulador
de
voltaje
puede
sobrecalentarse
y
daar
la
placa.
El
rango
recomendado
es
de
7
a
12
voltios.
Los
pines
de
alimentacin
son
los
siguientes:
VIN.
Se
puede
proporcionar
el
voltaje
de
entrada
a
travs
de
este
pin
a
la
placa
Arduino
cuando
est
usando
una
fuente
de
alimentacin
externa
(en
lugar
de
5
voltios
de
la
conexin
USB
o
otra
fuente
de
alimentacin
regulada).
5V.
Se
consiguen
5V
mediante
una
fuente
de
alimentacin
reguladora.
Utilizada
para
alimentar
el
microcontrolador
y
otros
componentes
en
la
placa.
3V3.
Unos
3,3
voltios
generados
por
el
chip
FTDI
situado
en
la
placa.
Corriente
mxima
de
50
mA.
GND.
Conexin
de
tierra.
Memoria
El
ATmega168
tiene
16
KB
de
memoria
flash
para
almacenar
el
cdigo
(de
los
cuales
2
KB
se
utiliza
para
el
gestor
de
arranque),
la
Atmega328
dispone
de
32
KB,
(tambin
con
2
KB
utilizado
para
el
gestor
de
arranque).
El
ATmega168
tiene
1
MB
de
SRAM
y
512
bytes
de
EEPROM
(que
puede
ser
ledo
y
escrito
con
la
biblioteca
de
EEPROM);
la
Atmega328
tiene
2
MB
de
SRAM
y
1
KB
de
memoria
EEPROM.
Entrada
y
Salida
Cada
uno
de
los
14
pines
digitales
en
la
Duemilanove
puede
ser
utilizado
como
una
entrada
o
salida,
utilizando
las
funciones
pinMode
()
digitalWrite
()
y
digitalRead
().
Operan
a
5
voltios.
Cada
pin
puede
proporcionar
o
recibir
un
mximo
de
40
mA
y
tienen
una
resistencia
interna
(desconectado
por
omisin)
de
20-50
kOhms.
Adems,
algunos
pines
tienen
funciones
especializadas:
Serial:
0
(RX)
y
1
(TX).
Se
utiliza
para
recibir
(RX)
y
transmisir
(TX)
datos
TTL
serie.
Estos
pines
estn
conectados
a
los
pines
correspondientes
del
chip
serie
USB
FTDI-a-TTL.
Interrupciones:
2
y
3.
Estos
pins
se
pueden
configurar
para
activar
una
interrupcin
en
un
valor
bajo,
un
flanco
de
subida
o
bajada.
PWM:
3,
5,
6,
9,
10
y
11.
Proporcionar
8-bit
con
salida
PWM
mediante
la
funcin
analogWrite
().
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
22
SPI:
10
(SS),
11
(MOSI),
12
(MISO),
13
(SCK).
Estos
son
pines
de
apoyo
a
la
comunicacin
SPI,
que
aunque
est
implementada
por
el
hardware
subyacente,
no
est
incluida
actualmente
en
la
lengua
Arduino.
LED:
13.
Hay
un
LED
integrado
conectado
al
pin
digital
13.
Cuando
el
pin
esta
en
nivel
alto,
el
LED
est
encendido,
y
cuando
est
a
nivel
bajo
bajo,
el
Led
es
apagado.
El
Duemilanove
tiene
6
entradas
analgicas,
cada
una
de
las
cuales
ofrecen
10
bits
de
resolucin
(es
decir,
1024
valores
diferentes).
Por
defecto,
que
miden
desde
el
masa
hasta
5
voltios,
aunque
es
posible
cambiar
el
extremo
superior
de
su
rango
con
el
pin
AREF
y
la
funcin
analogReference().
Adems,
algunos
pins
se
han
especializado
ms
an
en
cuanto
a
su
funcionalidad:
I2C:
4
(SDA)
y
5
(SCL).
Apoyo
I2C
(IST)
de
comunicacin
que
utiliza
la
biblioteca
Wire.
Hay
otro
par
de
pines
en
la
placa:
Aref.
Voltaje
de
referencia
para
las
entradas
analgicas.
Usado
con
analogReference().
Reset.
Llevando
esta
lnea
a
nivel
bajo
se
puede
reiniciar
el
microcontrolador.
A
continuacin
se
muestra
el
esquema
de
conexin
de
la
placa
Comunicacin
El
Duemilanove
Arduino
tiene
una
serie
de
facilidades
para
comunicarse
con
un
ordenador,
con
otro
Arduino,
o
con
otros
microcontroladores.
El
ATmega168
y
Atmega328
proporcionan
una
comunicacin
serie
UART
TTL
(5V),
que
est
disponible
en
los
pines
digital
0
(RX)
y
1
(TX).
Un
chip
FT232RL
FTDI
canaliza
las
comunicaciones
en
serie
de
esta
placa
a
travs
del
USB
y
los
drivers
de
FTDI
(incluido
con
el
software
Arduino)
proporcionan
un
puerto
virtual
COM
siempre
y
cuando
est
el
software
correspondiente
instalado
en
el
equipo.
El
software
Arduino
incluye
un
monitor
serie
que
permite
a
que
datos
simples
de
texto
puedan
ser
enviados
hacia
y
desde
la
placa
Arduino.
El
LED
RX
y
TX
en
la
placa
parpadear
cuando
se
estn
transmitiendo
datos
a
travs
del
chip
FTDI
y
conexin
USB
con
el
ordenador
(pero
no
para
la
comunicacin
de
serie
en
los
pines
0
y
1).
Una
biblioteca
SoftwareSerial
permite
la
comunicacin
serie
en
cualquiera
de
los
pines
digital
de
la
Duemilanove's.
El
ATmega168
y
Atmega328
tambin
soporta
I2C
(IST)
y
comunicacin
SPI.
El
software
incluye
una
biblioteca
de
Arduino
Wire
para
simplificar
el
uso
del
bus
I2C.
Para
utilizar
la
comunicacin
de
la
SPI,
consultar
las
caractersticas
tcnicas
del
ATmega168
o
del
Atmega328.
Programacin
El
Duemilanove
Arduino
puede
ser
programado
con
el
software
Arduino.
Seleccione
"Arduino
Duemilanove
ATmega168"
o
"W
Arduino
Duemilanove
Atmega328"
desde
el
men
Herramientas>
Board
(de
acuerdo
con
el
microcontrolador
en
su
tablero).
El
ATmega168
o
Atmega328
en
el
Duemilanove
Arduino
de
serie
viene
con
un
cargador
de
arranque
que
le
permite
cargar
el
nuevo
cdigo,
sin
el
uso
de
un
programador
hardware
externo.
Se
comunica
usando
el
protocolo
original
STK500.
Tambin
puede
omitir
el
gestor
de
arranque
y
el
programa
del
microcontrolador
a
travs
de
la
ICSP
(In
Circuito
Serial).
Reset
por
software
En
lugar
de
exigir
apretar
el
botn
de
reinicio
antes
de
una
carga
de
software
en
el
controlador,
el
Duemilanove
Arduino
est
diseado
de
una
manera
que
le
permite
resetear
el
software
se
ejecuta
desde
un
ordenador
conectado.
Una
de
las
lneas
de
control
de
flujo
por
hardware
(DTR)
de
la
FT232RL
est
conectado
a
la
lnea
de
reset
de
la
ATmega168
o
Atmega328
a
travs
de
un
condensador
de
100
nanofaradio.
Cuando
se
activa
esta
lnea
(tomando
nivel
bajo
de
tensin),
la
lnea
de
reseteo
del
chip
permanece
activa
el
tiempo
necesario
para
restablecer
dicho
chip.
El
software
Arduino
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
24
utiliza
esta
capacidad,
ya
que
le
permite
la
carga
de
cdigo
con
tan
slo
pulsar
el
botn
de
subida
en
el
entorno
Arduino.
La
carga
de
datos
en
el
controlador
puede
llevar
poco
tiempo
ya
que
podemos
coordinar
bien
el
tiempo
en
nivel
bajo
de
DTR,
con
el
inicio
de
la
subida
de
datos.
Esta
configuracin
tiene
otras
implicaciones.
Cuando
el
Duemilanove
est
conectado
al
ordenador
ya
sea
un
Mac
OS
X
o
Linux,
se
resetea
cada
vez
que
se
realiza
una
conexin
a
ella
desde
el
software
(a
travs
de
USB).
Aproximadamente
durante
medio
segundo,
el
gestor
de
arranque
se
ejecuta
en
el
Duemilanove.
Est
programado
para
ignorar
los
datos
con
formato
incorrecto
(es
decir,
nada,
adems
de
una
carga
de
cdigo
nuevo),
y
cuando
los
primeros
bytes
de
datos
enviados
llegan
a
la
placa,
se
interceptan
dichos
datos
y
despusla
conexin
se
abre.
Si
una
aplicacin
se
ejecuta
en
la
placa
y
recibe
del
exterior
cualquier
tipo
de
datos
cuando
se
inicia
por
primera
vez,
asegrese
de
que
el
software
con
el
que
se
comunica
espera
un
segundo
despus
de
la
apertura
de
la
conexin
y
antes
de
enviar
los
datos.
El
Duemilanove
contiene
una
traza
que
se
puede
cortar
para
deshabilitar
la
auto-
reset.
Las
almohadillas
a
ambos
lados
de
la
traza
se
pueden
soldar
en
conjunto
para
volver
a
habilitarla.
Es
llamado
"reset-en".
Tambin
se
puede
deshabilitar
la
funcin
auto-reset,
conectando
una
resistencia
de
110
ohmios
de
5V
a
la
lnea
de
reajuste.
USB
Proteccin
de
sobreintensidad
El
Duemilanove
Arduino
tiene
un
fusible
reseteable
que
protege
a
los
puertos
USB
de
su
ordenador
de
cortos
y
picos
de
corriente.
Aunque
la
mayora
de
los
equipos
proporcionan
su
proteccin
interna,
el
fusible
proporciona
una
capa
adicional
de
proteccin.
Si
ms
de
500
mA
se
aplica
al
puerto
USB,
el
fusible
rompe
automticamente
la
conexin
hasta
que
se
elimina
el
corto
o
sobrecarga.
Caractersticas
fsicas
La
longitud
mxima
y
ancho
de
la
placa
Duemilanove
son
2,7
y
2,1
pulgadas
respectivamente,
con
el
conector
USB
y
conector
de
potencia
que
se
extiende
ms
all
de
la
dimensin
anterior.
Tres
orificios
de
los
tornillos
que
la
Junta
pudiera
estar
conectada
a
una
superficie
o
carcasa.
Hay
que
tener
en
cuenta
que
la
distancia
entre
los
pines
digitales
7
y
8
es
de
160
milsimas
de
pulgada
(0,16"),
por
lo
que
no
es
un
mltiplo
de
la
distancia
(de
100
milsimas
de
pulgada)
entre
los
otros
pines.
2.2.2
Diecimila
Arduino
Origen
Resumen
Microcontrolador
ATmega168
nicamente
por
lo
que
por
ejemplo
en
cuanto
a
memoria
posee
solo
las
caractersticas
de
este
controlador.
Memoria
Descripcin
general
El
Nano
Arduino
es
una
placa
pequea,
completa
basada
en
el
Atmega328
(Arduino
Nano
3,0)
o
ATmega168
(Arduino
Nano
2.x).
Tiene
ms
o
menos
la
misma
funcionalidad
de
la
Duemilanove
Arduino,
pero
en
un
paquete
diferente.
Le
falta
slo
el
conector
de
alimentacin
DC,
y
trabaja
con
un
mini
cable
USB
en
lugar
de
uno
normal.
El
Nano
fue
diseado
y
est
siendo
producido
por
Gravitech.
Especificaciones:
Dimensiones
0.73
"x
1.70".
Potencia:
El
Nano
Arduino
puede
ser
alimentado
a
travs
de
la
Mini-conexin
USB,
con
entre
6-20V
mediante
una
fuente
de
alimentacin
externa
no
regulada(pin
30),
o
5V
regulados
mediante
fuente
reguladora
(pin
27).
Se
toma
como
fuente
de
energa
la
que
tenga
mayor
tensin
y
se
activa
automticamente.
Memoria
Podemos
obtener
el
nano
con
el
controlador
ATmega168
que
tiene
16
KB
de
memoria
flash
para
almacenar
el
cdigo
(de
los
cuales
2
KB
se
utiliza
para
el
gestor
de
arranque),
o
con
la
Atmega328
que
dispone
de
32
KB,
(tambin
con
2
KB
utilizado
para
el
gestor
de
arranque).
El
ATmega168
tiene
1
MB
de
SRAM
y
512
bytes
de
EEPROM
(que
puede
ser
ledo
y
escrito
con
la
biblioteca
de
EEPROM);
la
Atmega328
tiene
2
MB
de
SRAM
y
1
KB
de
memoria
EEPROM.
2.2.4 Mega
Arduino
Resumen
Microcontrolador
ATMEGA1280.
SRAM
8
KB.
EEPROM
4
KB.
Alimentacin
La
Mega
Arduino
puede
ser
alimentada
a
travs
de
la
conexin
USB
o
con
una
fuente
de
alimentacin
externa.
La
fuente
de
alimentacin
se
selecciona
automticamente.
Entrada
y
Salida.
Cada
uno
de
los
54
pines
digital
de
la
Mega
se
puede
utilizar
como
una
entrada
o
salida,
utilizando
las
funciones
pinMode
(),
digitalWrite
(),
y
digitalRead
().
Operan
a
5
voltios.
Cada
pin
puede
proporcionar
o
recibir
un
mximo
de
40
mA
y
tiene
una
resistencia
interna
de
20-50
kOhms.
Adems,
algunos
pines
tienen
funciones
especializadas:
Serial:
0
(RX)
y
1
(TX),
1
de
serie:
19
(RX)
y
18
(TX),
2
de
serie:
17
(RX)
y
16
(TX),
3
de
serie:
15
(RX)
y
14
(TX).
Se
utiliza
para
recibir
(RX)
y
transmisin
(TX)
datos
TTL
serie.
Pins
0
y
1
son
tambin
conectados
a
los
pines
correspondientes
de
la
USB
FTDI-a-chip
TTL
serie.
Factores
externos
Interrupciones:
2
(interrupcin
0),
3
(de
interrupcin
1),
18
(interrupcin
de
5),
19
(de
interrupcin
4),
20
(de
interrupcin
3),
y
21
(de
interrupcin
2).
Estos
pins
se
pueden
configurar
para
que
activen
una
interrupcin
cuando
stos
tenga
un
valor
bajo,
o
haya
un
flanco
de
subida
o
bajada.
LED:
13.
Hay
un
built-in
LED
conectado
al
pin
digital
13.
Cuando
el
pin
es
de
alto
valor,
el
LED
est
encendido,
cuando
el
pasador
es
bajo,
es
apagado.
I2C:
20
(SDA)
y
21
(SCL).
Pins
de
apoyo
de
comunicacin
I2C
(IST)
que
utiliza
la
biblioteca
Wire.
Estos
pines
no
estn
en
la
misma
ubicacin
que
los
pines
I2C
en
el
Duemilanove
o
Diecimila.
El
Mega
cuenta
con
16
entradas
analgicas,
cada
una
de
las
cuales
ofrecen
10
bits
de
resolucin
(es
decir,
1024
valores
diferentes).
Por
defecto,
que
miden
desde
el
masa
a
5
voltios,
aunque
es
posible
cambiar
el
nivel
superior
de
su
rango
con
el
pin
AREF
y
analogReference
()
la
funcin.
Adems
hay
un
par
de
pins
en
la
placa:
Aref.
Voltaje
de
referencia
para
las
entradas
analgicas.
Usado
con
analogReference
().
Reset.
Llevando
esta
lnea
a
nivel
bajo
se
reiniciar
el
microcontrolador.
Comunicacin
La
Mega
Arduino
tiene
una
serie
de
facilidades
para
comunicarse
con
un
ordenador,
otro
Arduino,
o
de
otros
microcontroladores.
El
ATMEGA1280
proporciona
cuatro
interfaces
UART
hardware
para
TTL
(5V)
de
comunicaciones
serie.
Un
FT232RL
FTDI
que
canaliza
dicha
comunicacin
seriea
travs
de
USB
y
los
drivers
de
FTDI
(incluidos
con
el
software
Arduino)
proporcionar
un
puerto
COM
virtual,
siempre
que
se
tenga
instalado
el
software
correspondiente
en
el
equipo.
El
software
Arduino
permite
enviar
datos
simples
de
texto
hacia
y
desde
la
placa
Arduino.
El
LED
RX
y
TX
en
la
placa
parpadear
cuando
se
estn
transmitiendo
datos
a
travs
del
chip
FTDI
y
conexin
USB.
2.2.5
Otras
placas
Existen
ms
mdelos
de
placas
en
el
mercado,
pero
estas
difieren
muy
poco
a
nivel
fsico
de
las
ya
explicadas.
Por
ello
vamos
tan
solo
a
mencionar
bsicamente
las
placas
y
a
ilustrarlas
con
la
correspondiente
fotografa,
para
saber
cual
elegir
en
funcin
de
la
aplicacin
que
quisieramos
realizar.
Lilypad
->
Es
una
pequea
placa
diseada
para
aplicaciones
con
las
que
tuviramos
que
llevar
encima,
por
ejemplo
ropa
inteligente
que
en
la
aplicacin
ya
existe
implementada
con
Arduino.
Mini->
placa
que
se
caracteriza
por
ser
la
ms
pequea
de
las
disponibles
Arduino
serial->
placa
que
implementa
una
comunicacin
serie
RS232
como
principal
caracterstica
Pro mini-> diseada para aplicaciones low-cost y que requieran un tamao reducido
Bluetooth
Arduino
--
[1] http://arduino.cc/en/Main/Hardware
[2] http://arduino.cc/en/Main/ArduinoBoardDuemilanove
[3] http://arduino.cc/en/Main/ArduinoBoardDiecimila
[4] http://arduino.cc/en/Main/ArduinoBoardMega
[5] http://www.bluegiga.com/WT11_Class_1_Bluetooth_Module
3.
Libreras
en
Arduino
3.1
Introduccin
La
plataforma
Arduino
se
programa
mediante
el
uso
de
un
lenguaje
propio
basado
en
el
popular
lenguaje
de
programacin
de
alto
nivel
Processing1.
Sin
embargo,
es
posible
utilizar
otros
lenguajes
de
programacin
y
aplicaciones
populares
en
Arduino
[1].
Algunos
ejemplos
son:
Java
Flash
(mediante
ActionScript)
Processing
MaxMSP
(entorno
grfico
de
programacin
para
aplicaciones
musicales,
de
audio
y
multimedia)
VVVV
(sntesis
de
vdeo
en
tiempo
real)
Adobe
Director
Python
Ruby
C
C++
(mediante
libSerial
o
en
Windows)
C#
Cocoa/Objective-C
(para
Mac
OS
X)
Linux
TTY
(terminales
de
Linux)
3DVIA
Virtools
(aplicaciones
interactivas
y
de
tiempo
real)
SuperCollider
(sntesis
de
audio
en
tiempo
real)
Instant
Reality
(X3D)
Second
Life
Liberlab
(software
de
medicin
y
experimentacin)
BlitzMax
(con
acceso
restringido)
Squeak
(implementacin
libre
de
Smalltalk)
Mathematica
Matlab
Mono
Isadora
(Interactividad
audiovisual
en
tiempo
real)
PERL
Visual
Basic
.NET
VBscript
Esto
es
posible
debido
a
que
Arduino
se
comunica
mediante
la
transmisin
de
datos
en
formato
serie
que
es
algo
que
la
mayora
de
los
lenguajes
anteriormente
citados
soportan.
Para
los
que
no
soportan
el
formato
serie
de
forma
nativa,
es
posible
utilizar
1
En
realidad,
Arduino
est
basado
en
Wiring
que
a
su
vez
se
basa
en
Processing.
software
intermediario
que
traduzca
los
mensajes
enviados
por
ambas
partes
para
permitir
una
comunicacin
fluida.
Es
bastante
interesante
tener
la
posibilidad
de
interactuar
Arduino
mediante
esta
gran
variedad
de
sistemas
y
lenguajes
puesto
que
dependiendo
de
cuales
sean
las
necesidades
del
problema
que
vamos
a
resolver
podremos
aprovecharnos
de
la
gran
compatibilidad
de
comunicacin
que
ofrece.
No
obstante
en
este
trabajo
nos
centraremos
en
el
lenguaje
que
acepta
por
defecto:
El
lenguaje
de
programacin
Arduino.
3.2.1
Processing
Processing
es
un
lenguaje
de
programacin
orientado
al
desarrollo
gil
de
aplicaciones
interactivas
y
multimedia
cuya
sintaxis
est
influenciado
por
Java,
OpenGL,
PostScript
y
C
[2].
Es
un
lenguaje
bastante
moderno
creado
en
2001
por
Casey
Reas
y
Ben
Fry
quienes
lo
desarrollaron
en
el
MIT
Media
Lab.
Estructuras
de
control
Condicionales:
if,
if...else,
switch
case
Bucles:
for,
while,
do...
while
Bifurcaciones
y
saltos:
break,
continue,
return,
goto
Sintaxis
Delimitadores:
;,
{}
Comentarios:
//,
/*
*/
Cabeceras:
#define,
#include
Operadores
aritmticos
Asignacin:
=
Operaciones:
+,
-,
*,
/,
%
Operadores
de
comparacin
==,
!=,
<,
>,
<=,
>=
Operadores
Booleanos
&&,
||,
!
Operadores
de
bits
&,
|,
^,
~,
<<,
>>
Operadores
compuestos
Incremento/decremento
de
variables:
++,
--
Asignacin
y
operacin:
+=,
-=,
*=,
/=,
&=,
|=
Manipulacin
de
puertos
Los
registros
de
puertos
permiten
la
manipulacin
a
mas
bajo
nivel
y
de
forma
mas
rpida
de
los
pines
de
E/S
del
microcontrolador
de
las
placas
Arduino
[4].
Los
pines
de
las
placas
Arduino
estn
repartidos
entre
los
registros
B(0-7),
C
(analgicos)
y
D(8-13).
Mediante
las
siguientes
variables
podemos
ver
y
modificar
su
estado:
Por
ejemplo,
para
especificar
que
queremos
utilizar
los
pines
1
a
7
como
salidas
y
el
0
como
entrada,
bastara
utilizar
la
siguiente
asignacin:
DDRD = B11111110;
En
cuanto
al
tratamiento
de
las
variables
tambin
comparte
un
gran
parecido
con
el
lenguaje
C.
Constantes
HIGH
/
LOW:
niveles
alto
y
bajo
en
pines.
Los
niveles
altos
son
aquellos
de
3
voltios
o
ms.
INPUT
/
OUTPUT
:
entrada
o
salida
true
/
false
Tipos
de
datos
void,
boolean,
char,
unsigned
char,
byte,
int,
unsigned
int,
word,
long,
unsigned
long,
float,
double,
string,
array
Utilidades
sizeof()
En
cuanto
a
las
funciones
bsicas
del
lenguaje
nos
encontramos
con
las
siguientes:
E/S
Digital
pinMode(pin,
modo)
digitalWrite(pin,
valor)
int
digitalRead(pin)
E/S
Analgica
analogReference(tipo)
int
analogRead(pin)
analogWrite(pin,
valor)
E/S
Avanzada
shiftOut(dataPin,
clockPin,
bitOrder,
valor)
unsigned
long
pulseIn(pin,
valor)
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
36
Tiempo
unsigned
long
millis()
unsigned
long
micros()
delay(ms)
delayMicroseconds(microsegundos)
Matemticas
min(x,
y),
max(x,
y),
abs(x),
constrain(x,
a,
b),
map(valor,
fromLow,
fromHigh,
toLow,
toHigh),
pow(base,
exponente),
sqrt(x)
Trigonometra
sin(rad),
cos(rad),
tan(rad)
Nmeros
aleatorios
randomSeed(semilla),
long
random(mx),
long
random(mn,
mx)
Bits
y
Bytes
lowByte(),
highByte(),
bitRead(),
bitWrite(),
bitSet(),
bitClear(),
bit()
Interrupciones
externas
attachInterrupt(interrupcin,
funcin,
modo)
detachInterrupt(interrupcin)
Interrupciones
interrupts(),
noInterrupts()
Comunicacin
por
puerto
serie
[5]
Las
funciones
de
manejo
del
puerto
serie
deben
ir
precedidas
de
Serial.
aunque
no
necesitan
ninguna
declaracin
en
la
cabecera
del
programa.
Por
esto
se
consideran
funciones
base
del
lenguaje.
begin(),
available(),
read(),
flush(),
print(),
println(),
write()
Como
se
ha
podido
comprobar,
si
conocemos
el
lenguaje
C,
no
tendremos
dificultades
para
programar
en
Arduino
puesto
que
se
parecen
enormemente.
Tan
slo
debemos
aprender
algunas
funciones
especficas
de
que
dispone
el
lenguaje
para
manejar
los
diferentes
parmetros
de
Arduino.
Se
pueden
construir
aplicaciones
de
cierta
complejidad
sin
necesidad
de
muchos
conceptos
previos.
avr-binutils
avr-gcc
and
avr-libc
La
mayora
del
lenguaje
de
programacin
Arduino
est
escrita
con
constantes
y
funciones
de
AVR
y
ciertas
funcionalidades
slo
se
pueden
obtener
haciendo
uso
de
AVR
[6].
Interrupciones
Para
desactivar
las
interrupciones:
cli(); // desactiva las interrupciones globales
Para
activarlas:
sei(); // activa las interrupciones
Esto
afectar
al
temporizador
y
a
la
comunicacin
serie.
La
funcin
delayMicroseconds()
desactiva
las
interrupciones
cuando
se
ejecuta.
Temporizadores
La
funcin
delayMicroseconds()
crea
el
menor
retardo
posible
del
lenguaje
Arduino
que
ronda
los
2s.
Para
retardos
mas
pequeos
se
debe
utilizar
la
llamada
de
ensamblador
'nop'
(no
operacin).
Cada
sentencia
'nop'
se
ejecutar
en
un
ciclo
de
mquina
(16
Mhz):
unos
62.5ns.
Se
hara
de
la
siguiente
manera:
__asm__("nop\n\t");
Manipulacin
de
puertos
La
manipulacin
de
puertos
con
cdigo
AVR
es
mas
rpida
que
utilizar
la
funcin
digitalWrite()
de
Arduino.
Para
utilizarlas
hay
que
pasarles
como
argumento
la
variable
PORT
y
un
pin
para
establecerlo
o
limpiarlo.
Gracias
a
estos
pequeos
hacks
tendremos
la
posibilidad
de
mejorar
los
tiempos
de
ejecucin
de
ciertas
tareas
crticas
o
de
aquellas
que
se
repitan
muchas
veces
obteniendo
mejores
resultados.
No
obstante
el
cdigo
fuente
que
escribamos
resultar
probablemente
menos
legible
si
los
utilizamos
por
lo
que
habr
que
sopesarlo
en
funcin
de
nuestras
necesidades.
3.2.4
Diferencias
con
Processing
La
sintaxis
del
lenguaje
de
programacin
Arduino
es
una
versin
simplificada
de
C/C++
y
tiene
algunas
diferencias
respecto
de
Processing
[7][8].
Ya
desde
el
punto
de
que
Arduino
esta
basado
en
C/C++
mientras
que
Processing
se
basa
en
Java.
En
cuanto
a
la
sintaxis
de
ambos
lenguajes
y
el
modo
en
que
se
programan
existen
tambin
varias
diferencias:
Arrays
Arduino
Processing
Bucles
Arduino
Processing
Impresin
de
cadenas
Arduino
Processing
int
i
=
5;
int
i
=
5;
Serial.println(i);
println(i);
int
i
=
5;
int
i
=
5;
Serial.print("i
=
");
println("i
=
"
+
i);
Serial.print(i);
Serial.println();
Las
diferencias
son
escasas
por
lo
que
alguien
que
conozca
bien
Processing
tendr
muy
pocos
problemas
a
la
hora
de
programar
en
Arduino.
3.2.5
Ejemplo
prctico:
Hola
Mundo
en
Arduino
[9]
#define LED_PIN 13
void setup () {
// Bucle infinito
void loop () {
delay (1000);
delay (1000);
El
orden
de
ejecucin
ser:
Primero
se
hace
una
llamada
a
la
funcin
init()
que
inicializa
el
programa,
despus
se
ejecuta
la
funcin
setup()
que
configura
diversos
parmetros,
y
por
ltimo
se
ejecuta
un
bucle
while(1)
que
llama
repetidamente
a
la
funcin
loop.
Todo
ello
se
ejecuta
dentro
de
main()
y
podra
haberse
indicado
explcitamente
(en
el
caso
anterior
se
encarga
el
IDE
de
aadir
el
el
cdigo
que
se
ha
omitido).
Las libreras estndar que ofrece Arduino son las siguientes [10]:
Serial
Lectura
y
escritura
por
el
puerto
serie.
Ya
hemos
hablado
de
ella
anteriormente.
EEPROM
Lectura
y
escritura
en
el
almacenamiento
permanente
[11].
read(),
write()
Ethernet
Conexin
a
Internet
mediante
Arduino
Ethernet
Shield.
Puede
funcionar
como
servidor
que
acepta
peticiones
remotas
o
como
cliente.
Se
permiten
hasta
cuatro
conexiones
simultaneas
[12].
Servidor:
Server(),
begin(),
available(),
write(),
print(),
println()
Cliente:
Client(),
connected(),
connect(),
write(),
print(),
println(),
available(),
read(),
flush(),
stop()
Firmata
Comuncacin
con
aplicaciones
de
ordenador
utilizando
el
protocolo
estndar
del
puerto
serie
[13].
LiquidCrystal
Control
de
LCDs
con
chipset
Hitachi
HD44780
o
compatibles
[14].
La
librera
soporta
los
modos
de
4
y
8
bits.
Servo
Control
de
servo
motores
[15].
A
partir
de
la
versin
0017
de
Arduino
la
librera
soporta
hasta
12
motores
en
la
mayora
de
placas
Arduino
y
48
en
la
Arduino
Mega.
attach(),
write(),
writeMicroseconds(),
read(),
attached(),
detach()
El
manejo
de
la
librera
es
bastante
sencillo.
Mediante
attach(numero
de
pin)
aadimos
un
servo
y
mediante
write
podemos
indicar
los
grados
que
queremos
que
tenga
el
motor
(habitualmente
de
0
a
180).
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
42
SoftwareSerial
Comunicacin
serie
en
pines
digitales
[16].
Por
defecto
Arduino
incluye
comunicacin
slo
en
los
pines
0
y
1
pero
gracias
a
esta
librera
podemos
realizar
esta
comunicacin
con
el
resto
de
pines.
Stepper
Control
de
motores
paso
a
paso
unipolares
o
bipolares
[17].
Stepper(steps,
pin1,
pin2),
Stepper(steps,
pin1,
pin2,
pin3,
pin4),
setSpeed(rpm),
step(steps)
El
manejo
es
sencillo.
Basta
con
iniciar
el
motor
mediante
Stepper
indicando
los
pasos
que
tiene
y
los
pines
a
los
que
esta
asociado.
Se
indica
la
velocidad
a
la
que
queramos
que
gire
en
revoluciones
por
minuto
con
setSpeed(rpm)
y
se
indican
los
pasos
que
queremos
que
avance
con
step(pasos).
Wire
Envi
y
recepcin
de
datos
sobre
una
red
de
dispositivos
o
sensores
mediante
Two
Wire
Interface
(TWI/I2C)
[18].
Adems
las
libreras
Matrix
y
Sprite
de
Wiring
son
totalmente
compatibles
con
Arduino
y
sirven
para
manejo
de
matrices
de
leds.
Creamos
el
fichero
Morse.h
que
incluye
la
definicin
de
la
clase
Morse
que
tiene
3
funciones:
un
constructor
(Morse()),
una
funcin
para
enviar
1
punto
(dot())
y
una
funcin
para
enviar
una
raya
(dash()).
La
variable
_pin
permite
indicar
el
pin
que
vamos
a
utilizar.
/*
Morse.h - Library for flashing Morse code.
*/
#ifndef Morse_h
#define Morse_h
#include "WProgram.h"
class Morse
public:
Morse(int pin);
void dot();
void dash();
private:
int _pin;
};
#endif
/*
Morse.cpp - Library for flashing Morse code.
*/
#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);
--
Referencias
[10] http://arduino.cc/en/Reference/Libraries
4.
SOFTWARE
4.1
Introduccin
El
Entorno
de
Desarrollo
de
Arduino
(ms
conocido
como
IDE
Integrated
Development
Environment)
es
una
herramienta
que
funciona
en
diferentes
plataformas
(Windows,
Macintosh,
Linux)
dedicada
a
la
edicin
y
descarga
de
programas
en
la
placa
Arduino.
El
cdigo
que
se
ejecuta
en
las
placas
est
basado
en
las
librerias
de
aplicacin
Wiring
API
y
en
las
de
desarrollo
de
los
integrados
AVR.
--
[1] http://java.sun.com/javase/downloads/index.jsp
[2] http://www.arduino.cc/en/Main/Software
Entre
todas
las
carpetas
creadas
en
el
directorio
Arduino,
conviene
destacar
las
siguientes:
C:\arduino-0017\hardware\bootloader
sta
contiene
el
software
necesario
para
cargar
el
firmware
en
el
chip
Atmega168
para
trabajar
con
Arduino.
Slo
se
utiliza
si
hemos
montado
la
placa
nosotros
mismos,
o
en
el
caso
que
se
haya
estropeado
el
chip
y
se
haya
comprado
uno
nuevo.
C:
\arduino-0017\drivers
Contiene
los
drivers
necesarios
para
el
funcionamiento
de
la
placa
Arduino
con
Windows:
FTDI
USB
Drivers.
Como
se
indic
antes,
los
drivers
para
conectar
la
placa
Arduino
por
USB
se
encuentran
en
la
subcarpeta
drivers
de
la
distribucin.
Figura 4.1: Conexin del cable USB a la placa Arduino
Se
abrir
automticamente
el
asistente
Aadir
Nuevo
Hardware:
Figura 4.2: Seleccin del puerto donde est conectado la placa en Windows
As
como
seleccionar
el
modelo
de
tarjeta
apropiado.
Figura 4.3: Seleccin de la placa Arduino deseada en Windows
4.2.2
Instalacin
del
IDE
en
Mac
OS
X
(v.
10.3.9
o
posterior)
Reiniciamos el sistema.
Acto
seguido,
instalamos
y
ejecutamos
el
IDE.
Por
defecto
nos
crear
una
carpeta
en
Documentos
donde
se
guardarn
todos
los
programas
que
vayamos
haciendo.
--
[1] http://www.arduino.cc/en/Main/Software
Debemos
ahora
especificar
qu
placa
de
Arduino
tenemos:
Figura 4.4: Seleccin de la placa Arduino deseada en Mac OS X
Figura 4.5: Seleccin del puerto donde est conectado la placa en Mac OS X
4.2.3
Instalacin
del
IDE
en
GNU/Linux
Mens
Men
Tabulador
Barra
de
Herramientas
rea
de
cdigo
Figura
4.6:
Elementos
del
entorno
de
desarrollo
en
Windows
Tab
Menu
Permite
gestionar
las
rutinas
con
ms
de
un
archivo
(cada
uno
de
los
cuales
aparece
en
su
propia
pestaa).
Estos
pueden
ser:
4.3.2. Mens
Sketch
Tools
5.
Control
de
motores
con
Arduino
5.1
Control
de
motores
DC
con
puente
en
H
5.1.1
Puente
en
H.
El
integrado
L293NE,
est
preparado
para
conectarle
hasta
4
motores,
por
lo
que
para
el
diseo
de
un
robot
que
tenga
dos
o
cuatro
ruedas
motrices,
slo
necesitaremos
un
integrado.
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
56
En
la
figura
2,
podemos
observar
el
patillaje
del
integrado
y
una
tabla
de
verdad
con
las
salidas
que
provoca
cualquier
combinacin
de
entradas
al
mismo.
Utilizaremos
la
alimentacin
externa
del
Arduino,
para
lo
que
tendremos
que
cambiar
el
switch
de
alimentacin,
ya
que
el
USB
trabaja
a
5V
y
normalmente
los
motores
trabajan
a
tensiones
mayores,
en
nuestro
caso
12V.
Se
ha
colocado
un
condensador
entre
la
alimentacin
del
motor
y
tierra
para
evitar
as
los
picos
de
tensin
que
se
producen
al
conectar
y
desconectar
el
motor.
Una
vez
montado
el
circuito
slo
nos
queda
programar
nuestro
Arduino
para
que
podamos
controlar
nuestro
motor
de
corriente
continua.
5.1.3 Programacin
Lo primero ser declarar nuestras variables asociadas a los pines del Arduino [1].
A
continuacin
configuraremos
los
pines
del
Arduino
como
entrada
o
salida,
tambin
haremos
que
el
led
parpadee
3
veces,
pero
esto
slo
debera
pasar
una
sola
vez,
ya
que
si
ocurre
ms
veces
es
porque
nuestro
programa
ha
vuelto
a
reiniciarse
a
causa
probablemente
de
un
fallo
en
nuestro
motor,
como
puede
ser
un
corto.
void setup() {
pinMode(switchPin, INPUT);
pinMode(motor1Pin, OUTPUT);
pinMode(motor2Pin, OUTPUT);
pinMode(enablePin, OUTPUT);
pinMode(ledPin, OUTPUT);
digitalWrite(enablePin, HIGH);
blink(ledPin, 3, 100);
}
Funcin
para
hacer
que
el
led
parpadee
un
cierto
nmero
de
veces
cada
cierto
periodo,
que
se
le
pasan
como
parmetros.
Como
hemos
visto
en
el
cdigo
anteriormente,
nuestro
led
parpadear
3
veces
con
un
intervalo
de
100
milisegundos.
La
funcin
la
implementaremos
con
un
simple
bucle
for
y
retardos
para
encender
y
apagar
el
led.
digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}
Ya
slo
nos
queda
la
funcin
principal
de
nuestro
programa,
que
estar
implementada
de
forma
que
lea
el
valor
del
interruptor
para
saber
en
qu
direccin
debe
girar
y
activar
las
salidas
correspondientes
a
la
tabla
de
verdad
de
la
figura
2
vista
en
el
apartado
puente
en
H.
void loop() {
if (digitalRead(switchPin) == HIGH) { //direccin 1
digitalWrite(motor1Pin, LOW);
digitalWrite(motor2Pin, HIGH);
}
else { // direccin 2
digitalWrite(motor1Pin, HIGH);
digitalWrite(motor2Pin, LOW);
}
}
La
Motor
Shield
es
una
placa
de
expansin
para
el
Arduino,
la
cual
mediante
libreras
permite
el
control
de
motores
de
hasta
1
A.
Para
conectar
motores
de
mayor
consumo
hace
falta
utilizar
un
integrado
L293.
La
Motor
Shield
contiene
4
puentes
en
H
en
los
que
se
pueden
conectar
hasta
2
servos
de
5V,
4
motores
de
corriente
continua
bidireccionales
u
8
que
giren
en
una
sola
direccin
y
2
motores
paso
a
paso
(unipolares
o
bipolares)
con
bobina
simple,
doble
o
micro
paso
a
paso.
Adems
cuenta
con
una
entrada
externa
para
la
alimentacin
de
los
motores.
En
la
figura
5
podemos
observar
el
Arduino
con
la
Motor
Shield
y
sus
conectores.
Los
motores
de
corriente
continua
se
colocan
en
los
puertos
M1,
M2,
M3
o
M4,
y
si
son
bidireccionales,
se
podr
controlar
la
direccin
de
giro
y
la
velocidad
mediante
el
PWM.
Para
poder
realizar
este
control
debemos
incluir
la
librera
AFMotor.h
y
seguir
lo
siguientes
pasos
[2]:
Se
puede
ajustar
la
velocidad
de
giro
del
motor
con
la
funcin
setSpeed
(velocidad),
a
la
que
le
pasaremos
un
valor
comprendido
entre
0
(parado)
y
255
(velocidad
mxima).
Para
hacer
funcionar
el
motor
tenemos
que
llamar
a
la
funcin
run
(direccin),
a
la
que
le
pasaremos
hacia
donde
queremos
que
gire
el
motor,
las
posibilidades
con:
fORDWARE
(hacia
adelante),
BACKWARD
(hacia
atrs)
o
RELEASE
(parado).
#include <AFMotor.h>
AF_DCMotor motor(2, MOTOR12_64KHZ); // Motor #2, 64KHz pwm
void setup() {
motor.setSpeed(200); // velocidad 200 de 255
}
void loop() {
motor.run(FORWARD); // girar hacia adelante
delay(1000);
motor.run(BACKWARD); // girar hacia atrs
delay(1000);
motor.run(RELEASE); // parar
delay(1000);
}
Los
servos
se
conectan
en
los
puertos
serv
y
debido
a
que
este
tipo
de
motores
consume
una
gran
cantidad
de
energa,
se
deberan
alimentar
mediante
la
conexin
de
alimentacin
externa.
El
PWM
para
el
control
de
los
servos
es
de
16
bits
y
para
poder
realizar
este
control
debemos
incluir
la
librera
ServoTimer1.h
y
seguir
los
siguientes
pasos
[2]:
Conectar los servos al pin 9 (servo A) o pin 10 (servo B) usando la funcin attach().
Fijar
la
posicin
del
servo
con
la
funcin
write
(ngulo),
donde
el
ngulo
puede
variar
desde
0
a
180.
En
el
siguiente
ejemplo
utilizaremos
dos
servos
que
estar
cada
uno
en
la
posicin
opuesta
al
otro
durante
1
segundo.
#include <ServoTimer1.h>
ServoTimer1 servo1;
ServoTimer1 servo2;
void setup() {
servo1.attach(10);
servo2.attach(9);
}
void loop() {
servo1.write(180);
servo2.write(0);
delay(1000);
servo1.write(0);
servo2.write(180);
delay(1000);
}
Podemos
conectar
hasta
2
motores
paso
a
paso
unipolares
o
bipolares
y
las
libreras
son
las
mismas.
La
bobina
1
del
motor
debe
conectarse
a
un
puerto
por
ejemplo
M1
o
M2
y
la
otra
bobina
al
M3
o
M4.
La
nica
diferencia
es
que
si
el
motor
es
unipolar
el
cable
del
centro
ir
conectado
a
tierra,
mientras
que
en
los
bipolares
este
cable
no
existe,
pero
el
funcionamiento
es
el
mismo
en
ambos
casos.
Para
poder
realizar
este
tipo
de
control
es
necesario
incluir
la
librera
AFMotor.h
y
seguir
los
siguientes
pasos
[2]:
Crear el objeto de motor paso a paso con AF_Stepper (pasos, pasos#) para configurar el
puente en H. Pasos indica cuntos pasos por revolucin tiene el motor. Con
7.5grados/paso el motor tiene 360/7.5 = 48 pasos. Pasos# es que el puerto al que est
conectado el motor. Si ests utilizando M1 y M2, el puerto ser 1y si ests utilizando
M3 y M4 el puerto ser el 2.
Ajuste la veloicdad del motor utilizando la funcin setSpeed (rpm) donde rpm son las
revoluciones por minuto.
Cada vez que se quiera mover el motor hay que utilizar la funcin step (#pasos,
direccin, tipo_paso), donde #pasos es el nmero de pasos que quieres dar, direccin
puede tomar los valores FORWARD
o
BACKWARD
para
ir
hacia
adelante
o
hacia
atrs
respectivamente,
y
tipo_paso
puede
tomar
los
valores
SINGLE
(paso
simple),
DOUBLE
(paso
doble),
INTERLEAVE
(paso
simple
y
doble
alternado)
o
MICROSTEP
(pasos
suavizados
con
el
PWM).
Como
el
servo
por
defecto
suele
mantener
la
posicin
dada,
podemos
utilizar
la
funcin
release()
para
liberarlo.
En el siguiente ejemplo utilizaremos un servo y lo moveremos con los diferentes tipos de
pasos explicados anteriormente.
#include <AFMotor.h>
AF_Stepper motor(48, 2);
void setup() {
motor.setSpeed(10); // 10 rpm
motor.step(100, FORWARD, SINGLE);
motor.release();
delay(1000);
}
void loop() {
motor.step(100, FORWARD, SINGLE);
motor.step(100, BACKWARD, SINGLE);
motor.step(100, FORWARD, DOUBLE);
motor.step(100, BACKWARD, DOUBLE);
motor.step(100, FORWARD, INTERLEAVE);
motor.step(100, BACKWARD, INTERLEAVE);
motor.step(100, FORWARD, MICROSTEP);
motor.step(100, BACKWARD, MICROSTEP);
}
6.
Aplicaciones
de
Arduino
en
Micro-
Robots
Mviles.
6.1
Introduccin
ASURO
es
un
pequeo
robot
mvil
desarrollado
por
DLR
(el
centro
aeroespacial
alemn)
para
proyectos
educativos.
Como
se
muestra
a
continuacin,
ASURO
viene
con
un
micro
Atmega8,
dos
motores
controlados
de
forma
independiente,
un
seguidor
de
lneas
ptico,
seis
sensores
de
contacto
o
colisin,
dos
odmetros,
tres
LEDs
indicadores
de
estado
y
un
interfaz
IR-
para
programacin
y
control
remoto
va
un
PC.
6.2
Montaje
6.2.1
Componentes
Sensores
de
contacto
LEDs
obtenemos
tres
colores,
un
naranja-amarillo
(ambos
activados),
un
rojo
y
un
verde.
Para
obtener
el
color
rojo
hay
que
activar
el
pin
PD2
(salida
digital),
y
para
el
verde,
el
pin
PB0
(salida
digital).
Y
para
el
naranja
amarillo,
pues
ambos.
o El
LED
frontal
(D11)
como
parte
del
sigue
lneas
y
situado
en
la
parte
inferior.
Su
activacin
se
encuentra
en
el
pin
PD6
(salida
digital).
Medidor
del
nivel
de
bateras
o
monitor
de
voltaje
Se
proporcionan
2
discos
con
6
y/o
8
sectores
para
pegar
a
los
engranajes
que
activan
las
ruedas.
De
forma
que
se
puede
recibir
30
y/o
40
pulsos
por
revolucin.
Para
ello
el
procesador
debe
activar
el
pin
(salida
digital):
PD7
(D13
y
D14
se
iluminan
simultneamente)
y
leer
los
Pines
(entradas
analgicas):
PC1
(T11-
izquierdo)
y
PC0
(T12-derecho).
Seguidor de lneas
Para
ello
el
procesador
debe
activar
el
Pin
(salida
digital):
PD6
(D11-
frontal)
y
leer
los
Pines
(entradas
analgicas):PC3
(T9-izquierdo)
/
PC2
(T10-derecho).
Motores
Por
ejemplo,
para
controlar
el
motor
izquierdo
el
procesador
utiliza
pines
PB1,
PD4
y
PD5
(PB2,
PB4
y
PB5
para
motor
derecho).
PB1
(y/o
PB2)
proporcionan
la
seal
PWM
para
el
control
de
la
velocidad.
PD4
y
PD5
(y/o
PB4
y
PB5)
determinan
la
direccin
de
rotacin
del
motor
(salidas
digitales).
6.2.2
Construccin
http://arduino.cc/es/Ensamblado-Asuro/Ensamblado-Asuro
Unas notas:
Una
vez
montada,
el
Atmega8
que
viene
con
el
Robot,
contiene
un
programa
que
realiza
una
comprobacin
o
TEST
de
todos
sus
componentes
y
funcionalidades,
de
forma
que
se
pueda
detectar
si
se
ha
producido
algn
error
durante
el
proceso
de
montaje.
6.2.3
Test
del
Asuro
Fase 1
Antes
de
insertar
el
chip
IC1
(ATmega8)
y
el
chip
IC3
(puerta
lgica
AND)
en
los
zcalos,
activa
el
interruptor
a
ON.
Los
LEDs
situados
en
la
parte
trasera
(D15,
D16),
deberan
de
brillar
tenuemente
(prueba
en
la
oscuridad!).
Fase 2
Las
marcas
de
la
polaridad
de
los
chips
(muescas)
deben
estar
alineadas
con
las
marcas
de
los
zcalos.
Tambin,
las
patas
del
chip
o
IC
deben
ser
dobladas
muy
cuidadosamente
para
que
puedan
quedar
todas
insertadas
en
los
agujeros
de
contacto
del
zcalo.
Para
empezar
la
prueba
o
Test,
debes
insertar
el
Jumper
(J1),
en
el
caso
de
que
utilices
bateras
recargables.
Entonces
activa
el
interruptor
a
On
y
verifica
lo
siguiente:
El
LED
de
estado
(D12)
debe
emitir
una
luz
naranja
(combinacin
de
rojo
y
verde)
y
los
LEDs
traseros
(D15,
D16)
deben
estar
activos.
Si
esto
no
pasa,
desactiva
el
interruptor
inmediatamente
y
contina
leyendo
en
resolucin
de
problemas.
o Prueba de LEDs
Todos
los
Leds
activados
al
mismo
tiempo
o Odmetros
(consistentes
de
un
LED
D13/D14
y
un
fototransistor
T11/T12
respectivamente)
sern
chequeados.
Para
ello
se
situar
un
papel
blanco
en
frente
de
los
fototransistores
(T11,
T12)
lo
que
activar
el
LED
de
estado
(D12).
o IR interface
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
71
6.3
ATmega8
6.3.1
Reemplazamiento
del
ATmega8
El
ATmega8
que
viene
con
el
robot
usa
un
protocolo
para
la
descarga
de
los
programas
(va
transmisin
IR)
que
no
est
documentado
o
que
no
es
Standard,
por
lo
que
no
puede
modificarse,
y
de
este
modo,
tampoco
se
puede
utilizar
Arduino
para
dicha
descarga.
Afortunadamente,
en
lugar
de
ello
se
puede
usar
el
ATmega8
de
la
placa
de
Arduino
como
se
indica
a
continuacin.
6.3.3
Conexin
y
programacin
de
Asuro
con
Arduino
Para
poder
programar
el
Asuro
con
Arduino,
tambin
ser
necesario
soldar
algunos
cables
extras
sobre
la
placa
del
Asuro.
Como
se
muestra
en
la
foto,
los
cables
deben
ser
soldados
a
los
pines
2
(RX)
y
3
(TX)
del
ATmega8
que
se
encuentra
en
el
Asuro,
de
forma
que
puedan
ser
conectados
a
los
pines
digital
pin
0
(RX)
y
digital
pin
1
(TX)
de
la
placa
Arduino.
El
otro
cable
saldr
del
pin
de
tierra
o
GND
(pin
8)
e
ir
al
correspondiente
pin
de
tierra
de
Arduino.
De
este
modo,
se
puede
establecer
la
siguiente
correspondencia
entre
los
componentes
del
Asuro
y
los
pines
de
Arduino,
informacin
necesaria
para
su
posterior
programacin
con
Arduino:
Libreras oficiales para controlar el Asuro
http://www.arexx.com/downloads/asuro/asuro_src.zip
Una
vez
conectados
los
cables
a
los
pines
indicados
en
la
placa
Arduino,
hay
que
conectar
la
placa
Arduino
al
PC,
va
cable
USB
(u
RS232).
De
esta
forma
se
podr
descargar
programas
desde
el
entorno
de
Arduino.
Slo
hay
que
tener
en
cuenta
que
el
ATmega8
est
en
el
Asuro,
no
en
la
placa
Arduino,
as
que
ser
necesario
utilizar
el
switch
o
interruptor
de
encendido/apagado
del
robot,
en
lugar
del
pulsador
de
reset
de
la
placa
Arduino.
Para
ello
hay
que
encender
el
robot
Asuro
justo
antes
de
pulsar
el
botn
de
"upload"
en
el
entorno
de
programacin
de
Arduino.
Si
no
funciona,
comprueba
la
conexin
de
los
cables
que
van
a
los
pines
0
y
1
sobre
la
placa
Arduino.
Los
comandos
Arduino,
para
la
comunicacin
serie,
deberan
de
funcionar
sin
ningn
problema.
6.4
Funciones
En
primer
caso
decir
que
Arduino
no
se
programa
en
C,
tiene
un
lenguaje
propio
llamado
Arduino,
muy
parecido
a
C.
Con
funciones
ms
faciles
e
intuitivas.
beginSerial(9600);
El
tiempo
del
bucle,
vara
segn
el
nmero
de
instrucciones
que
contenga.
Y
se
puede
conocer
y
controlar
con
las
funciones
de
temporizacin
(millis(),
delay(),
etc).
void loop() {
if (digitalRead(buttonPin) == HIGH)
serialWrite('H');
else
serialWrite('L');
delay(1000);
pinMode(pin,
mode)
:
Configura
el
pin
especificado
para
que
se
comporte
como
una
entrada
(input)
o
una
salida
(output).
digitalWrite(pin,
value)
:
Asigna
el
valor
de
salida
HIGH
o
LOW
al
pin
especificado.
digitalRead(pin):
Lee
o
captura
el
valor
de
entrada
del
pin
especificado,
dar
valores
HIGH
o
LOW.
pulseIn(pin,
value):
Lee
un
pulso
(en
estado
HIGH
(1)
o
LOW(0))
sobre
un
pin.
Por
ejemplo,
si
el
valor
es
HIGH,
pulseIn()
espera
hasta
que
el
pin
est
en
estado
HIGH,
entonces
empieza
a
temporizar,
y
cuando
el
pin
vuelve
al
estado
LOW,
se
para
el
temporizador.
De
este
modo,
se
devuelve
el
ancho
del
pulso
en
microsegundos.
void setup() {
pinMode(pin, INPUT);
void loop() {
analogRead(pin)
:
Lee
o
captura
el
valor
de
entrada
del
especificado
pin
analgico,
la
tarjeta
Arduino
realiza
una
conversin
analgica
a
digital
de
10
bits.
Esto
quiere
decir
que
mapear
los
valores
de
voltage
de
entrada,
entre
0
y
5
voltios,
a
valores
enteros
comprendidos
entre
0
y
1024.
void setup() {
void loop() {
} else {
analogWrite(pin,
value):
Escribe
o
asigna
un
valor
analgico
(PWM)
al
pin
desado.
Se
puede
usar
para
encender
un
Led
e
ir
variando
la
intensidad
de
su
brillo
o
impulsar
un
motor
a
distintas
velocidades.
Despus
de
invocar
o
realizar
una
llamada
a
la
funcin
analogWrite,
el
pin
generar
una
seal
estable
hasta
la
prxima
invocacin
o
llamada
de
la
funcin
analogWrite
(o
una
llamada
a
digitalRead
o
digitalWrite
sobre
el
mismo
pin).
value:
representa
al
parmetro
"ciclo
de
trabajo"y
puede
tomar
valores
entre
0
y
255.
0
corresponde
a
una
seal
de
salida
de
valor
constante
de
0
v
(LOW)
o
0%
de
"ciclo
de
trabajo";
255
es
una
seal
de
salida
de
valor
constante
de
5
v
(HIGH)
o
100%
de
"ciclo
de
trabajo";
.
Para
valores
intermedios,
el
pin
rpidamente
alterna
entre
0
y
5
voltios
-
el
valor
ms
alto,
lo
usual
es
que
el
pin
est
en
high
(5
voltios).
int ledPin = 9; // LED conectado al pin digital 9
void setup() {
void loop() {
Las
funciones
que
se
explican
a
contunuacin
son
vlidas
para
la
version
0004
e
inferiores:
beginSerial(int
speed)
:
Inicializa
el
puerto
serie
asignndole
una
velocidad
de
transmisin
de
datos
(bits
por
segundo).
Dicha
funcin
debe
ser
llamada
desde
dentro
de
laseccin
setup().
serialWrite(character)
:
Enva
un
byte
(como
caracter
ASCII
que
representa
el
valor
numrico
de
dicho
byte)
al
puerto
serie.
SerialAvailable()
:
Obtiene
un
nmero
entero
con
el
nmero
de
bytes
(caracteres)
diponibles
para
leer
desde
el
puerto
serie.
Plataforma
Arduino
en
diseo
de
Robots
Mviles
Pgina
80
SerialRead():
Lee
un
byte
(un
caracter)
desde
el
puerto
serie.
void loop() {
val = serByte;
printByte(val);
printMode(mode):
Esta
funcin
determina
si
la
salida
de
la
funcin
print()
va
hacia
el
puerto
serie
o
a
un
display
LCD
(Liquid
Crystal
Display).
Mode
puede
ser
SERIAL
o
DISPLAY
printByte(b)
:
Vuelca
un
nico
byte
al
puerto
serie
(no
como
caracteres
ASCII
que
representan
el
valor
numrico
de
dicho
byte).
printString(str)
:
Vuelca
como
salida
al
puerto
serie
una
cadena
de
caracteres
;
de
esta
forma,
transmite
la
secuencia
ASCII
de
los
caracteres
contenidos
en
la
cadena.
printInteger(num)
:
Vuelca
un
nmero
entero
codificado
o
en
caracteres
ASCII
en
formato
decimal
al
puerto
serie;
de
esta
forma,
transmite
la
secuencia
de
nmeros
en
ASCII,
de
la
representacin
en
base
10
del
nmero
entero.
printHex(num)
:
Vuelca
un
entero
codificado
o
en
caracteres
ASCII,
en
formato
hexadecimal
al
puerto
serie;
de
esta
forma,
transmite
la
secuencia
de
nmeros
y
letras
en
ASCII,
de
la
representacin
en
base
16
del
nmero
entero.
printBinary(num):
Imprime
o
vuelca
un
entero
codificado
o
en
caracteres
ASCII,
en
formato
binario
(binary
integer)
al
puerto
serie;
de
esta
forma,
transmite
la
secuencia
de
ceros
y
unos
en
ASCII,
de
la
representacin
en
base
2
del
nmero
entero.
PrintNewline()
:
Imprime
o
vuelca
un
carcter
de
salto
de
lnea
('\n')
en
el
puerto
serie.
Estas
funciones
son
validas
de
la
versin
0004
en
adelante:
Serial.begin(int
speed)
:
Equivalente
a
la
funcin
beginSerial().
Serial.available()
:
Equivalente
a
la
funcin
serialAvailable().
void setup() {
void loop() {
if (Serial.available() > 0) {
incomingByte = Serial.read();
Serial.println(incomingByte, DEC);
} void loop() {
if (Serial.available() > 0) {
incomingByte = Serial.read();
Serial.println(incomingByte, DEC);
Serial.print(data,
data
type)
:
Enva
un
nmero
o
una
cadena
de
caracteres,
al
puerto
serie.
Dicho
comando
puede
tomar
diferentes
formas,
dependiendo
de
los
parmetros
que
utilicemos
para
definir
el
formato
de
volcado
de
los
nmeros.
DEC:
escribe
el
valor
en
decimal,
en
caracteres
ASCII
HEX:
escribe
el
valor
en
hexadecimal,
en
caracteres
ASCII
OCT;
escribe
el
valor
en
octal,
en
caracteres
ASCII
BIN:
escribe
el
valor
en
binario,
en
caracteres
ASCII
BYTE:
escribe
el
carcter
ASCII
asociado
a
dicho
valor
str:
escribe
la
cadena
de
caracteres.
Serial.printnl(data,
data
type)
:
Enva
un
nmero
o
una
cadena
de
caracteres
al
puerto
serie,
seguido
de
un
carcter
de
retorno
de
carro
"CR"
('\r')y
un
carcter
de
salto
de
lnea
"LF"('\n').
Toma
la
misma
forma
que
el
comando
Serial.print()
A
continuacin
hablaremos
de
las
funciones
de
tiempo
que
la
plataforma
Arduino
nos
ofrece.
Millis():
Devuelve
el
tiempo
en
milisegundos,
desde
que
la
tarjeta
Arduino
activ
el
programa
que
se
est
ejecutando.
long time;
void setup(){
Serial.begin(9600);
} void loop(){
Serial.print("Time: ");
time = millis();
Serial.println(time);
delay(1000);
delay(ms)
:
Detiene
el
programa
durante
una
cantidad
de
tiempo
(en
milisegundos)
especificado
mediante
parmetro.
int ledPin = 13; // LED conectado a pin digital 13
void setup() {
void loop() {
delayMicroseconds(us)
:
Detiene
el
programa
durante
una
cantidad
de
tiempo
(en
microsegundos)
especificado
mediante
parmetro.
int outPin = 8; // pin digital 8
void setup() {
void loop() {
Aparte
de
todas
estas
funciones,
existen
muchas
ms
funciones,
matemticas,
trigonomtricas...
ms
complejas,
en
libreras
aparte.
Por
lo
dems
es
todo
igual
que
en
C,
slo
que
no
existen
los
puertos,
sino
que
son
solo
pines.
El
programa
tiene
tres
funciones
distintas,
tiene
una
matriz
4x4
y
las
coordenadas
del
led
se
controlan
con
el
Pad
L
del
mando
de
la
Play
station.
Tambin
hay
un
servo-motor
que
es
controlado
por
el
eje
Y
del
Pad
R
del
mismo
mando,
y
finalmente
tiene
un
led,
cuya
intensidad
se
regula
con
las
flechas
de
hacia
arriba,
y
hacia
abajo
del
mando.
El cdigo es el siguiente:
#define pinX 0
#define ctr_srv 1
#define pinY 2
#define servoPin 11
#define ledraise 5
#define ledlower 4
#define led 12
#define time 50
char i, j;
void setup() {
pinMode(17, OUTPUT);
pinMode(18, OUTPUT);
pinMode(19, OUTPUT);
pinMode(20, OUTPUT);
pinMode(28, OUTPUT);
pinMode(30, OUTPUT);
pinMode(32, OUTPUT);
pinMode(34, OUTPUT);
pinMode(servoPin, OUTPUT);
void loop() {
x = analogRead(pinX)/256;
y = analogRead(pinY)/256;
pos= analogRead(ctr_srv);
portx[x]=LOW;
porty[y]=HIGH;
if(millis()-previousMillis>=time){
previousMillis= millis();
servoPulse();
salidas();
void salidas(){
char indice;
analogWrite(led, led_ilu);}
void servoPulse() {
float pulseWidth;
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseWidth);
digitalWrite(servoPin, LOW);
delay(20);