Arduino

i
INSTITUTO TECNOLOGICO DE MEXICALI
Carrera:
Ingenieria Mecatrónica
Materia:
Interfaces y Redes Industriales
Tema (s):
ARDUINO
Nombre del alumno:

Camacho Mariscal Jorge Moisés 10440806
García Balderrama Isaac Daniel 10490578
Hernández Cervantes Roberto 11490032
Luna Álvarez Juan Manuel 10490597
Morales García Miguel Ángel 10490603
Ortega Garzón Francisco 10490606
Viveros Macias Raúl Iván 11490247
Nombre del Instructor:

ING. Alejandro Ortega Nazario
Fecha: Mexicali B.C. a 26 de Mayo de 2014

Av. Tecnológico S/N Col. Elías Calles, Apdo. Postal 91-55, Mexicali Baja California, México, C.P. 21396
Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

i
Tabla de Contenido
ARDUINO
INTRODUCCIÓN ................................................................................................................................ 1
ARDUINO ANTECEDENTES ................................................................................................................. 1
ARDUINO ANTECEDENTES ................................................................................................................. 2
TIPOS DE ARDUINO ........................................................................................................................... 8
ARDUINO UNO ............................................................................................................................................. 8

Características ..................................................................................................................................... 8
Especificaciones .................................................................................................................................. 9
ARDUINO LEONARDO .................................................................................................................................... 9
Características ..................................................................................................................................... 9
Especificaciones ................................................................................................................................ 10
ARDUINO DUE .......................................................................................................................................... 10
Características ................................................................................................................................... 10
ARDUINO YÚN ........................................................................................................................................... 12
ARDUINO MICRO ....................................................................................................................................... 13
ARDUINO ROBOT ....................................................................................................................................... 15
ARDUINO ESPLORA ..................................................................................................................................... 16
ARDUINO MEGA ADK................................................................................................................................. 18

ii
ARDUINO ETHERNET ................................................................................................................................... 19
ARDUINO MEGA 2560 ............................................................................................................................... 20
ARDUINO MINI .......................................................................................................................................... 22
LILYPAD ARDUINO USB .............................................................................................................................. 22
LILYPAD ARDUINO SIMPLE ........................................................................................................................... 24
LILYPAD ARDUINO SIMPLESNAP .................................................................................................................... 25
LILYPAD ARDUINO ...................................................................................................................................... 26
ARDUINO NANO ........................................................................................................................................ 27
ARDUINO PRO MINI ................................................................................................................................... 28
ARDUINO PRO ........................................................................................................................................... 29
Características:.................................................................................................................................. 29
ARDUINO FIO ............................................................................................................................................ 30
ARDUINO ZERO. ....................................................................................................................................... 31
ARDUINO TRE ........................................................................................................................................... 32

iii
DISPOSITIVOS ALTERNOS COMPATIBLES CON ARDUINO .................................................................. 35
JAMECO ELECTRONICS ................................................................................................................................. 35

MOUSER ELECTRONICS ......................................................................................................................... 39
OLIMEX .................................................................................................................................................... 61
COMPONENTES DEL ARDUINO ........................................................................................................ 66
RESISTENCIA .............................................................................................................................................. 68
DIODO ..................................................................................................................................................... 68
TRANSISTOR .............................................................................................................................................. 69
CONDENSADOR .......................................................................................................................................... 69
PULSADOR ................................................................................................................................................ 70
REED SWITCH ............................................................................................................................................ 70
ZUMBADOR O BUZZER ................................................................................................................................. 71
EXPANSIONES DE ARDUINO CON SHIELD ......................................................................................... 72
MICROCONTROLADORES .............................................................................................................................. 75
TERMINALES DIGITALES ............................................................................................................................... 75
PINES ANALÓGICOS .................................................................................................................................... 76
PINES DE ALIMENTACIÓN ............................................................................................................................. 76
OTROS PINES ............................................................................................................................................ 77
ALAMBRE ................................................................................................................................................. 78
BREADBOARD ............................................................................................................................................ 79
FUENTE DE ALIMENTACIÓN ............................................................................................................. 80
RESISTOR .................................................................................................................................................. 80
CONDENSADOR .......................................................................................................................................... 80
INDUCTOR ................................................................................................................................................ 81
DIODO ..................................................................................................................................................... 81
LED ........................................................................................................................................................ 82
LIMITADORES DE CORRIENTE RESISTENCIAS EN SERIE .......................................................................................... 82

iv
PULSADOR ................................................................................................................................................ 83
TRANSISTOR .............................................................................................................................................. 83
RELÉ ........................................................................................................................................................ 85
FOTORESISTOR ........................................................................................................................................... 85
MODULO ARDUINO ........................................................................................................................ 86
PROGRAMACIÓN DE ARDUINO ....................................................................................................... 87
ESTRUCTURA DEL PROGRAMA ....................................................................................................................... 87

SETUP().................................................................................................................................................... 88
LOOP() ..................................................................................................................................................... 88
FUNCIÓN .................................................................................................................................................. 88
{} ENTRE LLAVES ......................................................................................................................................... 89
; PUNTO Y COMA ........................................................................................................................................ 89
/*… */ BLOQUE DE COMENTARIOS ................................................................................................................ 90
// LÍNEA DE COMENTARIOS ........................................................................................................................... 90
VARIABLES ...................................................................................................................................... 90
DECLARACIÓN DE VARIABLES......................................................................................................................... 91
UTILIZACIÓN DE UNA VARIABLE ..................................................................................................................... 91
TIPOS DE DATOS ............................................................................................................................. 92
BYTE ........................................................................................................................................................ 92
INT .......................................................................................................................................................... 92
LONG ....................................................................................................................................................... 93
FLOAT ...................................................................................................................................................... 93
ARRAYS .................................................................................................................................................... 93
ARITMÉTICA.................................................................................................................................... 94
ASIGNACIONES COMPUESTAS ........................................................................................................................ 95

OPERADORES DE COMPARACIÓN ................................................................................................................... 96
OPERADORES LÓGICOS ................................................................................................................................ 96

v
CONSTANTES .................................................................................................................................. 96
CIERTO/FALSO (TRUE/FALSE) ........................................................................................................................ 96
HIGH/LOW ................................................................................................................................................ 97
INPUT/OUTPUT .......................................................................................................................................... 97
CONTROL DE FLUJO ......................................................................................................................... 97
IF (SI) ....................................................................................................................................................... 97
IF… ELSE (SI….. SINO ..) ............................................................................................................................... 98
FOR ......................................................................................................................................................... 99
WHILE ................................................................................................................................................... 100

DO WHILE ............................................................................................................................................... 101
E/S DIGITALES ............................................................................................................................... 101
PINMODE(PIN, MODE) .............................................................................................................................. 101
DIGITALREAD(PIN) .................................................................................................................................... 102
DIGITALWRITE(PIN, VALUE) ........................................................................................................................ 102
ANALOGREAD(PIN) ................................................................................................................................... 103
ANALOGWRITE(PIN, VALUE) ....................................................................................................................... 103
TIEMPO ........................................................................................................................................ 104
DELAY(MS) .............................................................................................................................................. 104
MILLIS() .................................................................................................................................................. 104
MATEMÁTICAS ............................................................................................................................. 105
MIN(X, Y) ................................................................................................................................................ 105
MAX(X, Y) ............................................................................................................................................... 105
ALEATORIO ................................................................................................................................... 105
RANDOMSEED(SEED) ................................................................................................................................ 105
RANDOM(MAX)........................................................................................................................................ 106
RANDOM(MIN, MAX) ................................................................................................................................ 106

vi
PUERTO SERIE ............................................................................................................................... 106
SERIAL.BEGIN(RATE) ................................................................................................................................. 106

SERIAL.PRINTLN(DATA) .............................................................................................................................. 107
SERIAL.PRINT(DATA, DATA TYPE) ................................................................................................................. 107
SERIAL.AVAILABLE() .................................................................................................................................. 109
SERIAL.READ()......................................................................................................................................... 109
BIBLIOTECAS ARDUINO ................................................................................................................. 111
APLICACIONES DE ARDUINO ......................................................................................................... 116
BLINK WITHOUT DELAY ............................................................................................................................. 116

BUTTON ................................................................................................................................................. 117
LOOP.................................................................................................................................................... 118
ENTRADA ANALÓGICA ............................................................................................................................... 119
FADING .................................................................................................................................................. 120
KNOCK ................................................................................................................................................... 121
SENSOR DE INCLINACIÓN ............................................................................................................................ 123
SALIDA DIGITAL ........................................................................................................................................ 124
ENTRADA DIGITAL ..................................................................................................................................... 125
SALIDA PWM ......................................................................................................................................... 126
GENERAR TONOS CON UN BUZZER ................................................................................................................ 127
SALIDA DE ALTA CORRIENTE DE CONSUMO ..................................................................................................... 128
} Control de un relé. ......................................................................................................................... 128
Control de un relé. ........................................................................................................................... 129
EL POTENCIÓMETRO ................................................................................................................................. 131
MOTOR DC ............................................................................................................................................ 133
CONCLUSIÓNES ............................................................................................................................. 135
FUENTES DE INFORMACIÓN .......................................................................................................... 136
DOCUMENTOS CONSULTADOS..................................................................................................................................... 138

1
ARDUINO
Introducción
Es que es muy difícil hablar de gadgets, especialmente curiosos, sin que la plataforma de hardware
libre esté involucrada. Pero no todo el mundo tiene lo suficientemente claro de qué va todo esto, y es
por eso que ha llegado el tiempo de detallar un poco más qué es Arduino.
En el mundo de la informática hay una corriente que de a poco está ganando cada vez más fuerza. Se
trata de las filosofías libres. En los últimos años el software libre ha ganado mucho terreno, desde el
código que da vida a infinidad de sitios en Internet, hasta el sistema operativo más común en
dispositivos móviles a día de hoy, todo construido sobre usando como base software de código abierto.
Hacer libre el software no es demasiado difícil. Solo hace falta que quién invierte tiempo desarrollando
código esté dispuesto a compartir su tiempo y esfuerzo con otras personas de manera íntegra. El
software es replicable con impresionante facilidad, cosa que no es tan sencilla de hacer con el
hardware, por lo que pensar el hardware libre requiere tener mucha visión.
De eso se trata Arduino, un sistema que desde hace ya casi una década sirve como núcleo del
hardware libre, y será el tema central de este Hardware para novatos.

2
ARDUINO ANTECEDENTES
Emergiendo desde la “cuna filosófica” del software libre, Arduino es en sí una propuesta electrónica
fácil de programar, distintos sistemas operativos que captan la atención de especialistas, novatos y
estudiantes; ya sea, para encender un led o para construir un robot, estas sencillas y económicas
tarjetas electrónicas están revolucionando a su manera el mundo del hardware con la cantidad de
aplicaciones ya comerciales.
Hace más de un siglo, en 1901 Frank Hornby inventó en Inglaterra un sistema de construcción
consistente en perfiles metálicos estandarizados —placas, perfiles, ángulos— que junto con ejes,
engranajes y tornillos permitía armar de forma muy sencilla mecanismos complejos y modelos de todo
tipo. El sistema era un juguete y se patentó con el nombre "Mecánica Hecha Fácil".
Ilustración 1 Meccano by Frank Hornby
La característica sobresaliente del sistema era hacer fácil y accesible la construcción de mecanismos de
todo tipo a cualquier aficionado, casi sin conocimiento previo, pero con mucho entusiasmo por la

3
experimentación. Esta idea de diseñar kits con piezas prefabricadas que ahorrasen tiempo a los
"hobbystas", pero que sean lo suficientemente maleables para no limitar la creatividad, se repitió
bastante durante el siglo pasado. Y en especial, en el campo de la electrónica [1].
Massimo Banzi forma parte del equipo Arduino. Como profesor de Ivrea, hacia 2005 decidió junto con
un grupo de estudiantes crear unas placas de hardware propias porque las que había en el mercado
rondaban los 75 euros, demasiado dinero para poder trabajar con ellas en clase, y como el instituto
estaba a punto de cerrar, abrieron el proceso a través de Internet para que no quedara enterrado una
vez el centro clausurara.
Ilustración 2. Massimo Banzi forma parte del equipo Arduino
Tal y como narra el documental Arduino, dirigido porRodrigo Calvo y Raúl Alaejos y producido
por Laboral Centro de Arte, al equipo inicial se fueron sumando más personas, y el primer prototipo
evolucionó hacia modelos más accesibles y fáciles de utilizar gracias a la colaboración abierta a través
de la Red, siguiendo la filosofía del software en código abierto. Las primeras unidades se vendieron a
un euro por placa y hoy en día, la comunidad Arduino tiene más de 120 mil usuarios.

4
El documental recoge algunos de los proyectos que se han realizado utilizando hardware en open
source, desde unas maracas que interaccionan con una pantalla digital vía bluetooth, creando gráficos
cuando se agitan (un proyecto de James Tichenor y Joshua Walton, de Rockwellgroup.com), hasta
la impresora en 3D, que permite diseñar un objeto o bajarlo de Internet y crearlo físicamente en
plástico, desde un silbato o un abrebotellas hasta un coche de juguete.
Ilustración 3. Logotipo de Codigo Abierto (Open Source)
Pero la mayor revolución del hardware en open source está en la posibilidad que brinda a la gente de
aprender cómo funciona la tecnología, y ser capaz de manipular y crear objetos físicos. Según David
Cuartielles, también del equipo Arduino, "por culpa de la _blankización y las patentes, se había cerrado
la oportunidad a la gente para aprender cómo funcionan las cosas y solo los expertos y hackers podían
abrir y ver lo que hay dentro. El hardware en open source significa poder volver a abrir las cosas y ver
cómo funcionan. Cuando hay más ordenadores que personas, eso es muy importante, no ya para
repararlas sino para entender cómo funciona nuestra vida".
Esta tecnología se ha extendido a otras áreas más allá de los expertos en informática e ingeniería y
aunque está todavía lejos de ser una corriente masiva, supone una oportunidad también en el ámbito
educativo. Juan Carlos de Mena es profesor en el IES Miguel Hernández de Madrid, donde ha
introducido el open hardware en sus clases de tecnología. "Aprenden que hay otro lado a parte del

5
consumidor, que hay formas de conocer los cacharros por dentro y tener el control sobre ellos", explica
[2].
Despues de que Arduino fue un gran lanzamiento para la gente con poco conocimiento de la electronia
se convirtió en una herramienta altamente recomendada para el aprendizaje en varias universidades
como Standford y Carnegie Mellon y el MIT. Para la producción en serie de la primera versión, se
tomaron en cuenta algunas consideraciones:
 Economía (no mayor a 30 Euros)

 Debía ser Plug and Play (fácil de manejar y sin muchos problemas para la instalación).
 Debía ser capaz de trabajar en todas las plataformas (Mac, Windows y Linux).
 El color azul de la placa fue pensado para “marcar una diferencia con las placas
convencionales”.
Arduino nacio de un proyecto no comercial en ese momento, sino como un proyecto educativo en
cuanto a la limitación de la electrónica para informáticos, etc. Pero de ¿donde surgio la idea de
llamarlo Arduino?; el nombre data de tiempo atrás en la pintoresca ciudad de Ivrea, Italia. En 1002 el
rey Arduin o Arduino, se convirtió en el gobernante del país [3].
Ilustración 4. Ivrea, Italia

6
Arduino permaneció en Borgoña hasta que se autoproclamó rey de Italia tras la muerte Otón III en
1002. En un primer momento fue “elegido por los lombardos en Pavía y fue llamado «Caesar». 2 por un
nutrido grupo de vasallos en la iglesia de San Michelle, y recorrió el reino con el arzobispo de Milán
para que los magnates le profesaran lealtad. Mientras, Enrique II era aclamado emperador. Todos los
magnates del reino le profesaron lealtad, pero secretamente se mantenían leales a Enrique. Sus
enemigos en la Iglesia recordaban los antiguos enfrentamientos con Arduino y temían las
consecuencias de que acaparase el poder, así que liderados por Frederick, arzobispo de Rávena, y el
propio cronista Arnulfo, arzobispo de Milán, se aliaron al nuevo emperador y le ofrecieron la corona de
Italia. Enrique envió al duque Otto de Carintia, a quien había nombrado conde de Verona, para
enfrentarse a Arduino. Pero Arduino cosechó una serie de victorias junto al
río Adigio en Valsugana contra las tropas de los obispos y las imperiales. La batalla campal de Fábrica
(1003) supuso un grandísimo éxito para Arduino:
...se masacró a muchos y al resto se les puso en fuga en las fronteras del reino [4].
El Rey Arduino fue derrocado por el Rey Arturo II, de Alemania dos años después de que Arduino
procuró recuperar el poder del trono y tomó venganza sobre todos aquellos que le fueron infieles.
También intentó contrarrestar el poder de Arnulfo, arzobispo de Milán, abogando por que fuese
sustituido por Alrico, obispo de Asti y hermano de Olderico Manfredi II. En 1007 el emperador atacó
sus tierras y le asedió en la iglesia fortificada de Santa Croce, en Sparone (Alto Canavese), también
conocida por la tradición como la Roca di Sparone o la Roca di Arduino porque en ella resistió Arduino
sin que el emperador pudiese completar su victoria. En 1014 Enrique regresó a Italia con fuerza para
consolidar su poder y consiguió incluso vencer la resistencia de la nobleza romaba.
El 14 de Febrero era coronado emperador en Roma por el Papa Benedicto VIII. Después regresó a
Alemania. Con el emperador otra vez fuera de Italia, Arduino emprendió una nueva campaña en la que
capturó la ciudad de Vercelli, asedió Novara, invadió Como y destruyó muchas otras ciudades que se
habían dado la espalda tras el incendio de Pavía. Pero nunca acabó de finalizar sus planes por la fuerte

7
oposición de la Iglesia, encabezada por Arnulfo de Milán, y de algunos nobles como Bonifacio de
Canossa, marqués de Toscana, que veían más intereses estando del lado del emperador. Desgastado
por ver cómo sus planes nunca llegaban a culminar, por la guerra, por una grave discapacidad y privado
de su reino, Arduino se deshizo de las galas y pompa de la corte y se contentó tomando los hábitos de
monje en la abadía de Fruttuaria (1014).
Esta abadía benedictina había sido fundada en el pueblo de San Benigno Canavese el 23 de febrero de
1003, entre los ríos Orco y Malone, precisamente en presencia de Arduino, su esposa Berta y
Ottobiano, obispo de Ivrea, que habían donado bienes para su fundación. Derrocado por el Rey Arturo
dos años después de haber tomado el trono de Italia. Hoy en dia en Ivrea, Italia, y específicamente en
el Bar di Re Arduino, un pub en una calle adoquinada de la ciudad hace honor a su memoria, y ahí es
donde nacio un nuevo rey improbable.
El bar es el abrevadero de Massimo Banzi, el cofundador italiano del proyecto de electrónica que llamo
Arduino en honor al lugar. El pequeño tablero es ahora el tren de go-to para artistas, aficionados,
estudiantes y cualquier persona con un sueño artilugios. Más de 250 000 placas Arduino se han
vendido en todo el mundo, y eso no incluye los montones de clones. "Se hizo posible que la gente haga
cosas que no habrían hecho de otra manera", dice David A. Mellis , que era un estudiante en IDII antes
de seguir estudios de postgrado en el Laboratorio de Medios del MIT y es el desarrollador de software
líder de Arduino [5].

8
Tipos de Arduino
Arduino uno
Características
El Arduino Uno es una placa electrónica basada en el ATmega328.
Cuenta con 14 entradas / salidas digitales pines (de los cuales 6 pueden ser utilizados 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
micro, sólo tiene que conectarlo a un ordenador con un cable USB o el poder con un adaptador AC-DC
o la batería para empezar.
El Arduino Uno difiere de todas las placas anteriores en que no utilizan el chip controlador USB FTDI a
serie.
Las características adicionales que vienen con la versión R3 son: *Lugar 8U2 como USB a serie
convertidor de ATmega16U2. *1,0 pin out: añadido el SDA y SCL pines para la comunicación TWI coloca
cerca de la pin AREF y dos pasadores de otros nuevos que se pongan cerca del pin de RESET, el IOREF
que permiten a los escudos de adaptarse a la tensión proporcionada por la junta directiva y el segundo
un No conecté el pin, que se reserva para usos futuros.

9
Especificaciones
 Microcontroller: ATmega328
 Operating Voltage: 5V
 Supply Voltage (recommended): 7-12V
 Maximum supply voltage (not recommended): 20V
 Digital I/O Pins: 14 (of which 6 provide PWM output)
 Analog Input Pins: 6
 DC Current per I/O Pin: 40 mA
 DC Current for 3.3V Pin: 50 mA
 Flash Memory: 32 KB (ATmega328) of which 0.5 KB used by bootloader
 SRAM: 2 KB (ATmega328)
 EEPROM: 1 KB (ATmega328)
 Clock Speed: 16 MHz
Arduino Leonardo
Características
Utiliza un microcontrolador ATmega32U4 que permite un diseño mucho más sencillo y económico. Una
de las ventajas de este nuevo microcontrolador es que dispone de USB nativo por hardware y por lo
tanto no necesita de ninguna conversión serie-USB. También permite a la placa ser utilizada y
programada como un dispositivo de entrada para emular un teclado, ratón, etc.

10
Tiene 12 entradas analógicas y dado que el puerto de comunicación USB es emulado, deja el puerto
serial hardware libre para la programación! De esta forma ya no ocurren conflictos de programación
mientras tenemos periféricos seriales conectados a la placa.
Especificaciones
 Microcontrolador: ATmega32u4
 Tensión de funcionamiento: 5V
 Alimentación recomendada: 7-12V
 Pines I/O Digitales: 20
 Canales PWM: 7
 Entradas analógicas: 12
 Corriente Maxima de los pines I/O: 40 mA
 Corriente Maxima de los pines 3.3V: 50 mA
 Memoria Flash: 32 KB (4 KB usados para el bootloader)
 SRAM: 2.5 KB
 EEPROM interna: 1 KB
 Velocidad: 16 MHz
Arduino DUE
Características
El Due es el primer Arduino basado en ARM. Esta placa se basa en un potente microcontrolador ARM
CortexM3 de 32 bits hecho programable a través de la conocida IDE Arduino. Aumenta la potencia de

11
cálculo disponible para los usuarios de Arduino mantenimiento el lenguaje de programación lo más
compatible posible para que muchos programas se puedan migrar a esta plataforma en cuestión de
minutos!
El Arduino Due dispone de 54 entradas / salidas digitales pines (de los cuales 12 se pueden utilizar
como salidas PWM), 12 entradas analógicas, 4 UARTs (puertas seriales), un reloj de 84 MHz, una
conexión USB-OTG, 2 DAC (convertidor digital a analógico), 2 TWI, un conector de alimentación, una
cabecera de SPI, un encabezado JTAG, un botón de reset y un botón de borrado. Hay también algunas
características interesantes como DACs, Audio, DMA, una biblioteca experimental multitarea y mucho
más.
Para compilar código para el procesador ARM, necesitarás la última versión del IDE de Arduino: v1.5
(Después de un período de prueba y depuración de ésta se sustituirá por la IDE 1.0.1)
Debido a las limitaciones de tensión del sistema impuestas por la SAM3X8E Atmel, los escudos Arduino
que se basan en los modelos de 5V no funcionará correctamente. Todos los escudos que apliquen
plenamente la disposición R3 Arduino son compatibles directamente (como el escudo Arduino Shield
Ethernet y WiFi), pero otros escudos podría no ser compatible. Tenga cuidado cuando usted está
conectando cosas en su Arduino Due.
Especificaciones
 Microcontrolador: AT91SAM3X8E
 Voltaje de operación: 3,3V
 Voltaje de entrada (recomendado): 7-12V
 Límites de voltaje: 6-20V
 Pines I/O: 54 (12 con PWM)
 Salidas analógicas: 2 (DAC)
 Salida máxima I/O: 130mA
 Corriente máxima: 800mA
 SRAM: 96 KB (64 + 32 KB)

12
 Memoria para programa: 512 KB

Arduino Yún
Características
El Arduino Yún combina la potencia de Linux junto con la sencillez característica de Arduino. Cuenta
con el chip del modelo Leonardo (ATMega32U4) junto con un módulo SOC (System-On-a-Chip)
corriendo una distribución de Linux llamada Linino, basada en OpenWRT. Soporta red cableada
ethernet 10/100 mbps y otra Wifi (IEEE 802.11 b/g/n, 2,4GHz) que puede montarse como cliente o
como punto de acceso.
El puerto serial del AR9331 está conectado al serial del 32U4 con los pines 0 y 1. Tarjeta microsd para
almacenamiento de datos.
Especificaciones
 Tensión de funcionamiento: 5V
 Alimentación recomendada: 7-12V
 Pines I/O Digitales: 20
 Canales PWM: 7
 Corriente Maxima de los pines I/O: 40 mA

13
 Corriente Maxima de los pines 3.3V: 50 mA

 Memoria Flash: 32 KB (4 KB usados para el bootloader)
 SRAM: 2.5 KB
 EEPROM interna: 1 KB
 LINUX:
 Procesador: Atheros AR9331
 Arquitectura: MIPS @400MHz
 Alimentación: 3.3V
 Puerto Ethernet: IEEE 802.3 10/100Mbit/s
 Conexión WiFi: IEEE 802.11b/g/n
 USB Type-A: 2.0 Host/Device
 Lector de tarjetas: Micro-SD
 RAM: 64 MB DDR2
 Memoria Flash: 32 MB
 Soporte para PoE tipo 802.3af
Arduino Micro

14
Características
El Arduino Micro tiene toda la potencia del Arduino Leonardo en un formato compacto de solo 48 x 18
mm.
Viene con con el chip ATmega32u4 y una de las mayores ventajas de este chip es que dispone de un
puerto USB nativo que permite entre otras cosas evitar tener que usar un conversor serie/USB.
Funciona a 5V con un cristal de 16MHz.
La placa incluye un conector micro USB, un puerto ICSP, un botón de reset y algunos diodos LED de
estado. Todos los pines de entrada y salida son los mismos que el modelo Leonardo.
Especificaciones
 Funcionamiento: 5V
 Alimentación recomedada: 7-12V
 Límites de entrada (max): 6-20V
 Pines I/O totales: 20
 Pines PWM: 7
 Pines analógicos: 12
 Imax de los pines I/O: 40 mA
 Corriente máxima del pin 3.3V: 50 mA
 Memoria flash: 32 KB (4 KB usados por el bootloade)
 SRAM: 2.5 KB
 EEPROM: 1 KB
 Dimensiones: 48x18mm
 Peso: 6.5g

15
Arduino Robot
Con el Arduino Robot, usted puede aprender acerca de la electrónica, la mecánica y el software. Se
trata de una pequeña computadora sobre ruedas. Viene con una serie de ejemplos de proyectos se
puede replicar fácilmente, y es una potente plataforma de robótica que se puede hackear para realizar
todo tipo de tareas.
El robot cuenta con un gran número de entradas; dos potenciómetros, cinco botones, una brújula
digital, cinco sensores de piso, y un lector de tarjetas SD. También cuenta con un altavoz, dos motores,
y una pantalla a color como salidas. Usted puede controlar todos estos sensores y actuadores a través
de la biblioteca de robot.
Hay dos tablas diferentes en el robot: la Junta de Control (arriba) y la Junta de Motor (abajo). Si estás
empezando con la electrónica y la programación, usted debe trabajar con la Junta de Control. A
medida que adquiera más experiencia, es posible que desee jugar con la Junta de motor.

16
Arduino Esplora
Características
El Arduino Esplora es una placa electronica derivada de la Arduino Leonardo. El Esplora difiere de todas
las placas Arduino precedentes, en el que proporciona un número de sensores de a bordo listos para
trabajar con ellos.
Está diseñado para personas que quieren empezar a trabajar con Arduino sin tener que aprender
acerca de la electrónica más basica.
El Esplora tiene sonido de a bordo, salidas de luz, y varios sensores de entrada, incluyendo una palanca
de mando, un control deslizante, un sensor de temperatura, un acelerómetro, un micrófono, y un
sensor de luz. También tiene el potencial de ampliar sus capacidades con conectores de entrada y
salida, y una toma de una pantalla a color TFT LCD.

17
Al igual que el Arduino Leonardo, la Esplora utiliza un microcontrolador AVR ATMEGA32U4 con 16 MHz
oscilador de cristal y una conexión micro USB capaz de actuar como un dispositivo de cliente USB,
como un ratón o un teclado.
En la esquina superior izquierda de la placa hay un pulsador de rearme, que se puede utilizar para
reiniciar el Esplora.
Entre los sensores y actuadores se encuentran:
- Sensor de luz
- Sensor de temperatura
- Acelerometro de 3 ejes
- Joystick
- Pulsadores
- Potenciometro deslizante
- Leds RGB – Zumbador
Especificaciones
 Microcontroladores ATMEGA32U4
 5V Tensión de funcionamiento
 Memoria Flash 32 KB de los cuales 4 KB utilizado por gestor de arranque
 SRAM 2.5 KB
 EEPROM 1 KB
 Velocidad de reloj 16 MHz

18
Arduino Mega ADK
Características
El Arduino ADK es una placa electronica basada en el microprocesador Atmega2560
Cuenta con una interfaz de host USB para conectar con los teléfonos basados en Android, basado en el
CI MAX3421e.
Cuenta con 54 entradas / salidas digitales pines (de los cuales 14 se pueden utilizar como salidas
PWM), 16 entradas analógicas, 4 UARTs (puertos de hardware de serie), 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.
Especificaciones
 Microcontrolador: ATmega2560
 Tensión de alimentación: 5V
 Tensión de entrada recomendada: 7-12V
 Límite de entrada: 6-20V
 Pines digitales: 54 (14 con PWM)
 Corriente máxima por pin: 40 mA
 Corriente máxima para el pin 3.3V: 50 mA
 Memoria flash: 256 KB
 SRAM: 8 KB
 EEPROM: 4 KB
 Velocidad de reloj: 16 MHz

19
Arduino Ethernet
Características
Arduino Ethernet es una placa basada en el microcontrolador ATmega328 al igual que el modelo
Arduino UNO. Dispone de 14 pines I/O, 6 entradas analógicas, un cristal de 16MHz, un conector de red
RJ45, conector de alimentación, un zócalo ICSP y un pulsador de RESET. Es la combinación en una sola
placa de un Arduino UNO y una Ethernet Shield para los proyectos que necesiten de menor espacio
físico.
Dispone también de un zócalo para tarjetas de memoria MicroSD que puede ser utilizado para leer y
escribir datos
El módulo de alimentación PoE (Power One Ethernet) que permite alimentar el Arduino Ethernet a
través de ethernet no está incluído (ver productos relacionados)
La placa difiere un poco de los otros modelos ya que no dispone de un conector USB ni del chip
conversor USB/Série, por lo tanto es necesario un cable FTDI 5V para poder programarla (ver
productos relacionados)
Especificaciones
 Alimentación: 5V
 Entrada recomendada:
 7-12V

20
 Entrada (max):
 6-20V
 Pines I/O 14 (4 con PWM)
 Pines reservados: 10 a 13 para SPI
 4 para SD
 2 para interrupción W5100 (en bridge)
 Analog Input Pins 6
 DC Current per I/O Pin 40 mA
 DC Current for 3.3V Pin 50 mA
 Flash Memory 32 KB (ATmega328) of which 0.5 KB used by bootloader
 SRAM 2 KB (ATmega328)
 EEPROM 1 KB (ATmega328)
 Clock Speed 16 MHz
 W5100 TCP/IP Embedded Ethernet Controller
 Power Over Ethernet ready Magnetic Jack
 Micro SD card, with active voltage translators
Arduino Mega 2560
Características
El Arduino Mega 2560 es una placa electrónica basada en el Atmega2560

21
Cuenta con 54 entradas / salidas digitales pines (de los cuales 14 se pueden utilizar como salidas PWM)
y 16 entradas analógicas, 4 UARTs (puertos de hardware de serie), un oscilador de cristal de 16 MHz,
un puerto USB de conexión, un conector de alimentación, una cabecera de ICSP, . y un botón de
reinicio Contiene todo lo necesario para apoyar a la micro, sólo tiene que conectarlo a un ordenador
con un cable USB o el poder con un adaptador AC-DC o la batería para empezar. La Mega es
compatible con la mayoría de los escudos diseñados para el Arduino Duemilanove o Diecimila.
Especificaciones
 Tensión de alimentación: 5V
 Tensión de entrada recomendada: 7-12V
 Límite de entrada: 6-20V
 Pines digitales: 54 (14 con PWM)
 Corriente máxima por pin: 40 mA
 Corriente máxima para el pin 3.3V: 50 mA
 Memoria flash: 256 KB
 SRAM: 8 KB
 EEPROM: 4 KB
 Velocidad de reloj: 16 MHz

22
Arduino Mini
Características
Arduino Mini miniaturizado versión de placa Arduino (w / o parte de USB) sin conector a la baja las
dimensiones mínimas (30x18mm) permiten el ahorro de espacio. Se utiliza un ATMega328 con 32K de
espacio de programa y se puede utilizar con USB / Serial converter para la programación y para agregar
al puerto USB.
Especificaciones
 Chip ATmega328 a 16MHz con cristal de cuarzo externo (toleracia: 0.5%)
 Auto-reset
 Regulador 5V integrado
 Max: 150mA por salida
 Protección de sobrecarga
 Protección contra inversión de polaridad
 Entrada DC de 5V hasta 12V
 LED de power y estado
LilyPad Arduino USB

23
El LilyPad Arduino USB es una placa electronica basada en el ATMEGA32U4 ( ficha técnica ). Cuenta con
9 pines digitales de entrada / salida (de los cuales 4 pueden utilizarse para salidas PWM y 4 entradas
analógicas), como un niño de 8 MHz resonador, una conexión micro USB, un conector JST de 3.7V LiPo
batería 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 alimentarla con una batería para empezar.
El LilyPad Arduino USB difiere de anteriores LilyPad tableros en que el ATMEGA32U4 ha incorporado en
la comunicación USB, lo que elimina la necesidad de un adaptador independiente de USB a serie. Esto
permite que la LilyPad Arduino USB aparezca a una computadora conectada como un ratón y el
teclado, además de un (CDC) de puerto serie / COM virtual. También tiene otras implicaciones para el
comportamiento de la junta.
Especificaciones
 Microcontroladores ATMEGA32U4
 Tensión de funcionamiento 3.3V
 Voltaje de entrada 3.8V a 5V
 Digital I / O Pins 9
 Canales PWM 4
 Canales de Entrada Analógica 4
 Corriente continua para las E / S Pin 40 mA
 Memoria Flash 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por el gestor de
arranque
 SRAM 2,5 KB ( ATMEGA32U4 )
 EEPROM 1 KB ( ATMEGA32U4 )
 Velocidad del reloj 8 MHz

24
LilyPad Arduino Simple
Se trata de la Junta simple LilyPad Arduino. Está controlado por un microprocesador Atmega328 con el
bootloader de Arduino. Tiene menos pines que la placa principal Arduino LilyPad , una de un
interruptor integrado en el zócalo de alimentación y encendido / apagado. Cualquiera de nuestras
baterías LiPo se pueden enchufar a la derecha en el zócalo. La placa simple está diseñado para
optimizar su próximo proyecto sewable por mantener las cosas simples y que le da más espacio para
trabajar y eliminando la necesidad de coser una fuente de alimentación. Esta revisión elimina la
cabecera de ISP y añade un circuito de carga basado en el MCP73831 IC.
LilyPad es una tecnología e-textil portátil desarrollada por Leah Buechley y diseñado por Leah y
Sparkfun. Cada LilyPad fue creativamente diseñado para tener grandes almohadillas de conexión que
les permitan ser cosidos en la ropa. Varias tarjetas de entrada, de salida, de energía, y los sensores
están disponibles. Son aún lavable.

25
LilyPad Arduino SimpleSnap
El LilyPad SimpleSnap es una nueva forma, fácil de crear los proyectos con LilyPad que son modulares
y se pueden desmontar o descompuestos, también es una gran manera de crear prototipos! La junta
SimpleSnap es similar a la placa LilyPad simple, y tiene la misma funcionalidad, excepto por dos
diferencias principales: Un built-in recargable de baterías de polímero de litio y de conexión por
presión de sexo femenino. Mediante la adición de encaje de tela a la junta, LilyPad ha hecho posible la
conexión de esta tarjeta a la SimpleSnap Protoboard o simplemente un arreglo de coser en tela
broches de presión de manera que la placa se puede retirar de su proyecto para el lavado o para que
varios proyectos se puede compartir un tablero. Es importante, sin embargo, que no se lava el
SimpleSnap debido a que la batería puede estar dañada.
La batería de polímero de litio a bordo se puede cargar simplemente uniendo un desglose FTDI (la
misma tarjeta utilizada para la programación) y al igual que el sencillo, el SimpleSnap se puede
programar en Arduino!
LilyPad es una tecnología e-textil portátil desarrollada por Leah Buechley y diseñado por Leah y
Sparkfun. Cada LilyPad fue creativamente diseñado para tener grandes almohadillas de conexión que
les permitan ser cosidos en la ropa. Varias tarjetas de entrada, de salida, de energía, y los sensores
están disponibles.

26
LilyPad Arduino
El LilyPad Arduino es una placa con microcontrolador. Puede utilizar con complementos similares como
fuentes de alimentación, sensores actuadores unidos por hilo conductor. La placa está basada en el
ARmega168V (la versión de baja consumo del ATmega168) (hoja de datos), o el ATmega328V
(datasheet). El LilyPad Arduino ha sido diseñado y desarrollado por Leah Buechley y SparkFun
Electronics.
Especificaciones
 Atención: No alimentes el LilyPad Arduino con más de 5,5 voltios, ni inviertas la polaridad al
conectarlo.
 Microcontroladores ATmega168V o ATmega328V
 Voltaje de funcionamiento 2.7 a 5.5 V
 Voltaje de entrada 2.7 a 5.5 V
 Pines E/S Digitales 14 (de las cuales 6 proporcionan salida PWM)
 Pines Entradas Analógicas Input Pins 6
 Intensidad por pin 40 mA
 Flash Memorabl 16 KB (de las cuales 2 KB las usa el gestor de arranque(bootloader))
 SRAM 1 KB
 EEPROM 512 bytes
 Velocidad de reloj 8 MHz

27
Arduino Nano
Características
Arduino Nano igual que el Arduino Mini pero aún más diminuto. Es la nueva generación de placas que
permite realizar rápidos prototipos sobre protoboard
Ésta vez, incorpora un conector mini USB, un chip ATMega328, 2 entradas analógicas más que la placa
Arduino Diecimila y un conector ICSP para programarlo mediante un programador externo si se desea,
sin necesidad de cablear el contector externamente.
Especificaciones
 RESET automatico al descargar el programa
 LED azul en la base para indicar el encendido
 LED Verder (TX), Rojo (RX) y Naranja (L)
 Jumper para +5V conectado a AREF
 Regulador de tensión integrado
 Conector mini-B USB para programación y comunicación série integrado en placa
 Conector ICSP para programación
 Pines con espaciado de 0.1" DIP para insertarlo directamente sobre una protoboard
 Boton de reset integrado
 Bootloader integrado que permite programarlo con el entorno de desarrollo Arduino sin
necesidad de un programador externo

28
Arduino Pro Mini
Características
El Mini Arduino es una placa de pequeño microcontrolador basado originalmente en el ATMega168 ,
pero ahora se suministra con el 328, destinado a montarse en placas base y cuando el espacio es
primordial. Cuenta con 14 entradas / salidas digitales pines (de los cuales 6 pueden ser utilizados como
salidas PWM), 8 entradas analógicas, y una de 16 MHz del oscilador de cristal. Se puede utilizar con
USB / Serial converter para la programación y para agregar al puerto USB
Especificaciones
 Chip ATmega328 a 16MHz con cristal de cuarzo externo (toleracia: 0.5%)
 Auto-reset
 Regulador 5V integrado
 Max: 150mA por salida
 Protección de sobrecarga
 Protección contra inversión de polaridad
 Entrada DC de 5V hasta 12V
 LED de power y estado

29
Arduino Pro
Arduino Pro, enfoque de diseño minimalista de Sparkfun para Arduino. Esta es una de 5V Arduino
ejecutar el gestor de arranque de 16MHz en un factor de forma super-elegante que cabe fácilmente en
su próximo proyecto pequeño.
Arduino Pro no viene con conectores pobladas de modo que usted puede soldar en cualquier conector
o cable con cualquier orientación que necesita. Recomendamos primera vez que los usuarios de
Arduino comienzan con el Uno R3. Es un gran tablero que te llevará a trabajar rápidamente. La serie
Pro Arduino está pensado para los usuarios que entienden las limitaciones de esta falta de conectores
USB y fuera bordo.
Para mantener las cosas perfil asequible y de bajo, que hemos elegido para hacer la huella de gato de
la corriente continua disponible, pero no para poblarlo. Se recomienda ejecutar el tablero con una
batería de Li-Po para una mejor portabilidad. Además, para mantener el costo bajo, hicimos cambios,
como el uso de todos los componentes SMD y el cambio a un PCB de dos capas.
Esta tarjeta se conecta directamente a la placa FTDI Básico Breakout y soporta auto-reset. El Arduino
Pro también trabaja con el cable de FTDI pero el cable FTDI no saca el pin DTR por lo que la función de
restablecimiento automático no funcionará. En esta última versión de la Arduino Pro también hemos
movido los encabezados FTDI espalda sólo un skoach modo que los pasadores no se cuelguen del
borde del tablero. También hemos pobló con un interruptor de selección de potencia más robusto.
Características:
 ATmega328 funcionando a 16MHz resonador externo

30
 Conexión USB de tablero

 Regulador de 5V
 Salida máxima 150 mA
 Sobre corriente protegida
 Protegido contra inversión de polaridad
 Entrada DC 5V hasta 12V
 Fusible rearmable evita daños a la placa en caso de corto
 Poder seleccionar switch actúa como interruptor on / off
 Dimensiones: 2.1x2.05 "(53.34x52.08mm)
Arduino Fio
Características
Arduino Fio es ideal para proyectos inalámbricos.
Dispone de un zócalo para un mózulo XBee, un conector mini-USB y puede ser alimentado
directamente por una batería LiPo. Incluye también un cargador de batería basado en el MAX1555 de
Maxim.
Como todos los modelos de Arduino, se ofrece con un bootloader integrado que además permite
cargar programar de forma inalámbrica mediante XBee sin necesidad de conectarlo por USB.
El Arduino Fio está basado en el diseño de Arduino Funnel I/O (Fio) diseñado por Shigeru Kobayashi y a
su vez basado en LilyPad. Arduino Fio ofrece mejoras en el diseño de la placa y está oficialmente
soportado por la comunidad Arduino.

31
Especificaciones
 ATmega328V a 8MHz
 Incluye el Arduino Bootloader
 Zócalo para XBee (módulo xbee no incluido)
 Compatible con baterías de Litio Polímeto
 Cargador LiPo MAX1555 integrado
 botón de RESET
 Interruptor On/Off integrado
 Indicadores LED: Status/Charge/RSSI
Arduino ZERO.
La nueva creación de Arduino se llama Arduino ZERO y es una placa de 32bits basada en un
microcontrolador ATMEL Cortex-M0 SAMD21 que además incorpora la tecnología EDBG (Atmel’s
Embedded Debugger) que permite realizar un debug de la aplicación sin necesidad de hardware
externo. Por el momento sólo se ha hecho el anuncio oficial aunque el primer prototipo será mostrado
en la Maker Faire Bay Area y donde muy probablemente se ofrezcan aún más detalles.

32
Como se puede ver, el formato es muy similar a su primo pequeño Arduino UNO, salvo la
incorporación de dos conectores de tipo Micro USB. Uno se utilizará para debug y otro para
programación y muy probablemente como puerto OTG o USB host.
La plataforma se está actualizando con nuevos microcontroladores y facilitando aún más la vida al
usuario. También existen otras placas anunciadas recientemente como el Arduino TRE o el Arduino
Galilleo, que soportan incluso Linux nativo o Android, sin embargo el nuevo Arduino ZERO parece más
orientado a proyectos de tipo wearable o IoT (Internet de las cosas).
Arduino TRE
La primera semana de Octubre del año 2013 ha sido una semana de grandes noticias y anuncios por
parte de la Fundación Arduino. El 3 de Octubre del 2013, poco después de haber anunciado la
colaboración con la compañía Intel que se tradujo en el desarrollo de la placa Galileo, Arduino ha
anunciado ahora el lanzamiento de una nueva placa diseñada en colaboración con la Fundación
Beagleboard, la creadora de las placas Beagleboard, Beaglebone y Beaglebone Black, hasta ahora
rivales ostensibles del movimiento Arduino.
El Arduino TRE (por si acaso UNO, DUE, TRE en italiano se traduce al español como UNO, DOS, TRES)
será en realidad dos Arduinos en uno; por una parte contendrá el mismo controlador que potencia a la
placa Arduino Leonardo y por otra parte contendrá el procesador de 32 bits Sitara AM335x ARM
Cortex-A8 de la compañía Texas Instruments, la cual corre a 1GHz y cuenta con una gama variada de
periféricos y E/S de propósito general. Un aspecto destacable de este procesador (que es el mismo
procesador usado en la placa Beaglebone Black) es el hecho de que cuenta con dos microcontroladores
PRU (Programmable Real-time Unit) de 32 bits que corren a 200MHz y que están incluidos en el mismo
chip que contiene el núcleo principal ARM Cortex, los cuales están pensados para su uso en
innumerables aplicaciones de tiempo real (control de motores, PWM, etc.)
El nuevo Arduino TRE será efectivamente como tener un Arduino Leonardo combinado con una placa
BeagleBone Black en un solo sistema. Correrá el sistema operativo Linux y permitirá compilar y correr
sketches de Arduino sin necesidad de una PC adicional. La placa será compatible con la gran mayoría

33
de los shields ya disponibles e incorporará ademas conectividad mediante Ethernet, XBee, USB y CAN
entre otros.
Gracias a la potencia del procesador AM335x los usuarios podrán implementar aplicaciones avanzadas
que incluyan displays LCD de alta resolución, gráficos acelerados por hardware y tendrán además
mayores opciones de conectividad. Otras aplicaciones pensadas incluyen impresoras 3D, portales de
acceso de red para automatización doméstica, concentradores para telemetría mediante sensores
inalámbricos y otras aplicaciones que requieran conectividad y operación en tiempo real.
Más allá de la gran popularidad de la que ya goza actualmente, ciertamente la plataforma Arduino está
demostrando que quiere insertarse aún mucho más agresivamente en el ámbito del bricolaje
electrónico por afición, en el ámbito educativo y más aún también en el ámbito del desarrollo
profesional de cara al cada vez más próximo "boom" del Internet de las Cosas, que según opiniones de
algunos expertos para el 2020 se traducirá en la conexión a la red de 50 billones de dispositivos.
El Arduino TRE estará disponible para la venta recién a partir del segundo cuarto del año próximo 2014
a un precio todavía no revelado.
Ya sea como estudiante, profesional o aficionado, sin duda esta es una excelente época para dedicarse
a la electrónica!

34

35
Dispositivos Alternos compatibles con ARDUINO

A continuación se presentan las distribuidoras de componentes electrónicos, donde cuentan con
elementos adicionales para la realización de proyectos con Arduino.
Jameco Electronics

36

37

38

39
MOUSER ELECTRONICS
En la dirección electrónica www.mouser.com, donde buscaremos varios elementos de Arduino un

sistema que complementa fuertemente a precios módicos; el cual es un gran levantamiento para este
software/hardware de código OpenSource. Para ingresar la búsqueda de Arduino, se coloca la palabra
Arduino en el cuadro de búsqueda y en la parte derecha del cuadro hay una lupa en azul; se da clic y
muestra una lista detallada de cada elemento en venta y el tipo de fabricante de cada uno de ellos,
como se muestra en la captura siguiente:

40
A continuación se muestra una captura de pantalla de la pagina www.mouser.com donde muestra los
artículos de búsqueda de Arduino; asi como, su fabricante, el modelo, el precio y la disponibilidad del
articulo, etc.

41

42

43
A continuación se mostrar cada artículo con su fabricante, de forma detallada:
Módulos de Pantalla 4D Systems:

44
Herramientas de Ingeniería de potenciómetro digital:

45
Herramientas de desarrollo de pantalla:

46
Herramientas de desarrollo de procesador integrado, Tarjetas hija y Tableros OEM:

47

48

49
Tipos de Herramientas de Procesador Integrado:

50

51
Arduino Corriente Alterna (CA), Corriente Directa (DC) y Servo Motores:

52
Arduino Cables USB / Cables IEEE 1394:
Antenas para Arduino:

53
Productos de Prototipos:

54

55
Herramientas de desarrollo de iluminación:

56
Módulos de sensor:

57
Arduino accesorios para módulo:

58
Procesadores y Controladores integrados:

59

60
Alojamiento de cables y cabecera:

61
Olimex
Una empresa que se dedica a la electrónica, sacó el producto derivado del Arduino más pequeño en el
mercado. Se trata de un ATtiny85, al cual Olimex llamó Olimexino 85s, y sin duda fue el Arduino más
pequeño que haya salido a la venta. Es impresionante en cierta medida. Sin embargo, se ha
desarrollado uno aún más pequeño, con su entrada a USB. Es francamente increíble.
El nanite 85 fue diseñado con mucho cuidado, con la intención de hacerlo pequeño y funcional. No
solamente es un 20% más chico que el Olimexino, sino que hasta tiene un botón de reset. Uno de los
aspectos más novedosos en el diseño es que tiene tiene sus pins del tamaño de un ATtiny85. Esto
significa que se puede usar el Nanite 85 para desarrollar código con el bootloader y entonces se puede
reemplazar directamente con un ATtiny85 preprogramado. El único pero que podría tener este mini
dispositivo es que no tiene un regulador de voltaje, por lo que solamente se conecta al USB y
esperemos que no se vaya a quemar lo cual, finalmente, no tiene tampoco por qué ocurrir.

62
Memoria
El ATmega168 tiene 16 KB de memoria Flash para almacenar código (de los cuales 2 KB se usa para el
bootloader). Tiene 1 KB de SRAM y 512 bytes de EEPROM (que puede ser leida y escrita con la librería
EEPROM1
Hay muchos otros microcontroladores y plataformas microcontroladoras disponibles para computación

física. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard, y muchas otras ofertas de
funcionalidad similar. Todas estas herramientas toman los desordenados detalles de la programación
de microcontrolador y la encierran en un paquete fácil de usar. Arduino también simplica el proceso de
trabajo con microcontroladores, pero ofrece algunas ventajas para profesores, estudiantes y acionados
interesados sobre otros sistemas
Placas E/S
Diecimila: Esta es la placa Arduino más popular. Se conecta al ordenador con un cable estándar USB y
contiene todo lo que necesitas para programar y usar la placa. Puede ser ampliada con variedad de
dispositivos: placas hijas con características especícas.
Nano: Una placa compacta diseñada para uso como tabla de pruebas, el Nano se conecta al ordenador
usando un cable USB Mini-B.
Bluetooth: El Arduino BT contiene un modulo bluetooth que permite comunicación y programación sin
cables. Es compatible con los dispositivos Arduino.
LilyPad: Diseñada para aplicaciones listas para llevar, esta placa puede ser conectada en fábrica, y un
estilo sublime.
Mini: Esta es la placa más pequeña de Arduino. Trabaja bien en tabla de pruebas o para aplicaciones en
las que prima el espacio. Se conecta al ordenador usando el cable Mini USB.
Serial: Es una placa básica que usa RS232 como un interfaz con el ordenador para programación y
comunicación. Esta placa es fácil de ensamblar incluso como ejercicio de aprendizaje.

63
Serial Single Sided: Esta placa está diseñada para ser grabada y ensamblada a mano. Es ligeramente
más grande que la Diecimila, pero aun compatible con los dispositivos.
El Arduino Diecimila puede ser alimentado a través de la conexión USB o con un suministro de energía
externo. La fuente de energía se selecciona mediante el jumper PWR_SEL: para alimentar a la placa
desde la conexión USB, colocarlo en los dos pines más cercanos al conector USB, para un suministro de
energía externo, en los dos pines más cercanos al conector de alimentación externa.
La alimentación externa (no USB) puede venir o desde un adaptador AC-a-DC (wall-wart) o desde una
batería. El adaptador puede ser conectado mediante un enchufe centro-positivo en el conector de
alimentación de la placa. Los cables de la batería pueden insertarse en las cabeceras de los pines Gnd y
Vin del conector POWER. Un regulador de bajo abandono proporciona eficiencia energética mejorada.
Otros productos olimex

64

65
Olimex © 1997-2014

66
Componentes del Arduino
1. Conector USB para el cable tipo AB

2. Pulsador de Reset
3. Pines de Entradas y salidas digitales y PWM
4. LED verde de placa encendida
5. LED naranja conectado al pin13
6. ATmega 16U2 encargado de la comunicación con el PC
7. LED TX (transmisor) y RX (receptor) de la comunicación serial
8. Puerto ICSP para programación serial
9. Microcontrolador ATmega 328, cerebro del Arduino
10. Cristal de cuarzo de 16 Mhz
11. Regulador de voltaje
12. Conector hembra 2.1mm con centro positivo
13. Pines de voltaje y tierra
14. Entradas análogas

67
Microcontrolador
Un microcontrolador (abreviado μC,UC o MCU) es un circuito

integrado programable, capaz de ejecutar las órdenes grabadas
en su memoria. Está compuesto de varios bloques funcionales,
los cuales cumplen una tarea específica. Un microcontrolador
incluye en su interior las tres unidades funcionales principales:
unidad central de procesamiento (CPU), memoria y periféricos de
entrada y salida (I/O).
Para que pueda controlar algún proceso es necesario crear y luego grabar en la memoria EEPROM del
microcontrolador algún programa, el cual puede ser escri-to en lenguaje ensamblador u otro len-guaje
para microcontroladores; debe ser codificado en sistema numérico hexade-cimal que es finalmente el
sistema que hace trabajar al microcontrolador cuan-do éste es alimentado con el voltaje adecuado y
asociado a dispositivos analógicos y discretos para su funcionamiento.
Los microcontroladores representan la inmensa mayoría de los chips vendidos, tie-nes distribuidos
seguramente entre los electrodomésticos de tu hogar una o dos docenas de microcontroladores.
Pueden encontrarse en casi cualquier dispositivo electrónico como automóviles, lavadoras, hornos
microondas, teléfonos, Arduino.
Los microcontroladores utilizan la mayoría para recibir
señales de dispositivos de entrada/salida, con la gran ventaja
de que se puede prescindir de cualquier otra circuitería
externa.
Los puertos de E/S (entrada/salida ó I/O) en el
microcontrolador, se agrupan en puertos de 8 bits de
longitud, lo que permite leer datos del exterior o escribir en
ellos desde el interior del microcontrolador, el destino es el trabajo con dispositivos simples como
relés, LED, motores, fotoceldas, pulsado-res o cualquier otra cosa que se le ocurra al programador.

68
Resistencia
Es un material formado por carbón y otros elementos resistivos para disminuir la corriente que pasa.
Se opone al paso de la corriente. La corriente máxima en un resistor viene condicionado por la máxima
potencia que puede disipar su cuerpo. Esta potencia se puede identificar visualmente a partir del
diámetro sin que sea necesaria otra indicación. Los valores más comunes son 0,25 W, 0,5 W y 1 W.
El valor de la resistencia eléctrica se obtiene leyendo las cifras como un número de una, dos o tres
cifras; se multiplica por el multiplicador y se obtiene el resultado en Ohmios (Ω).
Diodo
Un diodo es un componente electrónico de dos terminales que permite la circulación de la corriente

eléctrica a través de él en un solo sentido. Tiene dos partes: el cáto-do y el ánodo.

69
Transistor
El transistor es un dispositivo electrónico semiconductor que cumple funciones de amplificador,

oscilador, conmutador o rectificador. Tiene tres partes: la base (B), el emisor (E) y colector (C).
Actualmente se encuentran prácticamente en todos los aparatos domésticos de uso diario: radios,
televisores, grabadoras, reproductores de audio y video, hornos de microondas, lavadoras,
automóviles, equipos de refrigeración, alarmas, relojes de cuarzo, ordenadores, calculadoras,
impresoras, lámparas fluorescentes, equipos de rayos X, tomógrafos, ecógrafos, reproductores mp3,
teléfonos celulares, etc.
Condensador
Un condensador o capacitor es un dispositivo utilizado en electrónica, capaz de almacenar energía

sustentando un campo eléctrico. Está formado por un par de superficies conductoras, generalmente en
forma de láminas o placas, en situación de influencia total separadas por un material dieléctrico o por
el vacío. Las placas, sometidas a una diferencia de potencial, adquieren una determinada carga
eléctrica, positiva en una de ellas y negativa en la otra.

70
Pulsador
Un botón o pulsador es utilizado para activar alguna función. Los botones son por lo general activados
al ser pulsados, normalmente con un dedo. Un botón de un dispo-sitivo electrónico funciona por lo
general como un interruptor eléctrico, es decir en su interior tiene dos contactos, si es un dispositivo
NA (normalmente abier-to) o NC (normalmente cerrado), con lo que al pulsarlo se activará la fun-ción
inversa de la que en ese momento este realizando.
Reed switch
Reed switch es un interruptor eléctrico activado por un campo magnético, por ejemplo con un imán.
Cuando los contactos están normalmente abiertos se cierran en la presencia de un campo magnético;
cuando están normalmente cerrados se abren en presencia de un campo magnético. Un uso muy
extendido se pue-de encontrar en los sensores de las puertas y ventanas de las alarmas anti-robo, el
imán va unido a la puerta y el reed switch al marco.

71
Zumbador o Buzzer
El zumbador, buzzer en inglés, es un transductor electroacústico que produce un sonido o zumbido

continuo o intermitente de un mismo tono. Sirve como mecanismo de señalización o aviso, y son
utilizados en múltiples sistemas como en automóviles o en electrodomésticos. Inicialmente este
dispositivo estaba basado en un sistema electromecánico que era similar a una campana eléctrica pero
sin el badajo metálico, el cual imitaba el sonido de una campana.
Su construcción consta de dos elementos, un electroimán y una lámina metálica de acero. El zumbador
puede ser conectado a circuitos integrados especiales para así lograr distintos tonos. Cuando se
acciona, la corriente pasa por la bobina del electroimán y produce un campo magnético variable que
hace vibrar la lámina de acero sobre la armadura.

72
Expansiones de Arduino con shield

Un Shield o escudo es una placa que permite expandir funcionalidades a tu Arduino, con lo cual puedes
conectar motores, o a la red celular, a una red WiFi, a una red Ethernet o tener un MP3 en el Arduino,
etc.

73

74
 Terminal de referencia analógica (naranja)

 Tierra digital (verde claro)
 Terminales digitales 2-13 (verde)
 Terminales digitales 0-1/ E/S serie - TX/RX (verde oscuro) serie (por ejemplo Serial.begin).
 Botón de reinicio - S1 (azul oscuro)
 Programador serie en circuito "In-circuit Serial Programmer" o "ICSP" (azul celeste)
 Terminales de entrada analógica 0-5 (azul claro)
 Terminales de alimentación y tierra (alimentación: naranja, tierras: naranja claro)
 Entrada de alimentación externa (9-12VDC) - X1 (rosa)
 Selector de alimentación externa o por USB (coloca un jumper en los dos pines mas cercanos de
la alimentación que quieras) - SV1(púrpura). En las versiones nuevas de Arduino la selección de
alimentacion es automática por lo que puede que no tengas este selector.
 USB (utilizado para subir programas a la placa y para comunicaciones serie entre la placa y el
ordenador; puede utilizarse como alimentación de la placa) (amarillo)

75
Microcontroladores
ATmega168 (utilizado en la mayoría de las ATmega8 (utilizado en algunas placas antiguas)

placas Arduino) 14 (3 de ellos pueden
Pines de E/S
14 (6 de ellos pueden proporcionar salidas
Terminales de digital
proporcionar salidas PWM)
E/S digital
PWM) Pines de
Terminales de entrada 6
entrada 6 (DIP) o 8 (SMD) analógica
analógicos Corriente DC
40 mA
Corriente DC por por pin de E/S
40 mA
terminal de E/S Memoria Flash 8 KB
Memoria Flash 16 KB SRAM 1 KB
SRAM 1 KB EEPROM 512 bytes
EEPROM 512 bytes
Terminales Digitales
En adición a las funciones específicas listadas abajo, las terminales digitales de una placa Arduino
pueden ser utilizados para entradas o salidas de propósito general a través de los
comandos pinMode(), digitalRead(), y digitalWrite(). Cada terminal tiene una resistencia pull-up que
puede activarse o desactivarse utilizando DigitalWrite() (con un valor de HIGH o LOW,
respectivamente) cuando el pin esta configurado como entrada. La corriente máxima por salida es 40
mA.
 Serial: 0 (RX) y 1 (TX). Utilizado para recibir (RX) y transmitir (TX) datos serie TTL.
 Interrupciones externas: 2 y 3. Estas terminales pueden ser configuradas para disparar una
interrupción con un valor bajo, un pulso de subida o bajada, o un cambio de valor.
 PWM: 3, 5, 6, 9, 10, y 11. Proporcionan salidas PWM de 8 bit con la función analogWrite().

76
 Reset BT: 7. (solo en Arduino BT) Conectado a la línea de reset del módulo bluetooth.
 SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estas terminales soportan comunicación SPI.
Aunque esta funcionalidad esta proporcionada por el hardware, no está incluida actualmente el el
lenguaje Arduino.
 LED: 13. En el Diacemila y el LilyPad hay un led en placa conectado al pin digital 13. cuando el
pin tiene valor HIGH, el LED está encendido, cuando el pin está en LOW, está apagado
Pines Analógicos
En adición a las funciones específicas listadas abajo, los pines de entrada analógicos soportan
conversiones analógico-digital (ADC) de 10 bit utilizando la función analogRead(). Las entradas
analógicas pueden ser también usadas como pines digitales: entrada analógica 0 como pin digital 14
hasta la entrada analógica 5 como pin digital 19. Las entradas analógicas 6 y 7 (presentes en el Mini y el
BT) no pueden ser utilizadas como pines digitales.
 I2C: 4 (SDA) y 5 (SCL). Soportan comunicaciones I2C (TWI) utilizando la librería

Wire (documentación en la página web de Wiring).
Pines de alimentación
 VIN (a veces marcada como "9V"). Es el voltaje de entrada a la placa Arduino cuando se está
utilizando una fuente de alimentación externa (En comparación con los 5 voltios de la conexión USB o
de otra fuente de alimentación regulada). Puedes proporcionar voltaje a través de este pin. Date
cuenta que diferentes placas aceptan distintos rangos de voltaje de entrada, por favor, mira
la documentación de tu placa. También date cuenta que el LilyPad no tiene pin VIN y acepta solo una
entrada regulada.
 5V. La alimentación regulada utilizada para alimentar el microcontrolador y otros componentes
de la placa. Esta puede venir de VIN a través de un regulador en placa o ser proporcionada por USB u
otra fuente regulada de 5V.

77
 3V3. (solo en el Diacemila) Una fuente de 3.3 voltios generada por el chip FTDI de la placa.
 GND. Pines de tierra.
Otros Pines
 AREF. Referencia de voltaje para las entradas analógicas. Utilizada con la

función analogReference().
 Reset. (Solo en el Diacemila) Pon esta línea a LOW para resetear el microcontrolador. Utilizada
típicamente para añadir un botón de reset a shields que bloquean el de la placa principal.

78
Alambre
Un alambre es uno de los componentes más básicos, y cruciales disponibles. Un alambre permite el
flujo sin trabas de la electricidad. Un alambre se utiliza para conectar los componentes de un circuito
juntos. Un alambre puede ser pensado como cualquier dispositivo que se destina a la electricidad ruta
desde un componente a otro. En este sentido, un cable puede ser el núcleo de metal tradicional,
envuelta aislante alambre. Además también puede ser la huella en una placa de circuito o la conexión
de soldadura entre dos componentes en la ausencia de un alambre " tradicional.
{Nota: un cable impedirá el flujo de la electricidad, pero es tan leve que usualmente podemos ignorar
sus efectos.}
Alambre físico
Cable físico (a diferencia de las trazas de PCB , o alambres en los esquemas ) se puede dividir en dos
categorías generales : sólido y trenzado . La diferencia es la facilidad con que se dobla el alambre, y la
facilidad con que se rompe. Todos los cables que se necesitan para flexionar, como los cables de la
línea de aparatos o cables a los altavoces de audio deben ser trenzados de alambre. El alambre sólido
se utiliza cuando el alambre no necesita flexionarse y donde tener un conductor sólido hace que el
alambre más fácil trabajar con.
Los ejemplos de lugares donde se utiliza alambre sólido están dentro de las paredes de los edificios y
en paneras electrónicos. En ambos casos, el cable no va a hacer una gran cantidad de flexión, y es más
fácil de usar como un conductor sólido , en lugar de un montón de hebras más pequeñas .
Medidores de alambre
Breadboards están generalmente diseñados para utilizar un cable de calibre 22, aunque pueden
acomodar un medidor o dos de cualquier manera. Cabeceras femeninas Arduino no están diseñadas
para la inserción de alambre, pero funciona bastante bien para muchas situaciones de prototipo.
Calibre 20 es probablemente más dependendable en los encabezados de Arduino que un calibre 22,

79
pero tanto va a funcionar. En calibres de alambre, los números más grandes corresponden con alambre
más pequeño.
Radio Shack, aunque uno siempre vacila en recomendar, vende alambre sólido y trenzado. Busque
sólido calibre 22 (o alternativamente calibre 20 sólido) de alambre para el uso con su ' duino y un
tablero.
Si usted necesita una buena cantidad de alambre breadboard lo puede obtener a bajo costo, y en
varios colores, con la compra de un cable telefónico conductor sólido. Asegúrese de que sea conductor
sólido, aunque como se venden tanto sólido y trenzado. Usted puede encontrar esto en tiendas de
mejoras para el hogar y en la RS Esto es comúnmente de calibre 24, por lo que es un tamaño más
pequeño que ideal, y se puede doblar sobre sí mismo para realizar conexiones seguras en ' cabeceras
femeninas Duino .
Cables de la computadora antiguas contienen una gran cantidad de cable trenzado en varios calibres y
colores que es extremadamente útil para el cableado de pequeños proyectos electrónicos. Obtener
dondequiera basura tech se descarta.
Breadboard
A Breadboard es un dispositivo que facilita la construcción y prueba de circuitos. Típicamente se
utilizan para diseños de circuitos de prototipos.
Algunos tipos comunes son:
Placa sin soldadura - tiene una placa frontal de plástico con agujeros que los componentes se pueden
insertar en. Los componentes hacen contacto eléctrico con tiras de metal debajo de la placa frontal. De
esta manera no se necesita ninguna soldadura para sujetar los componentes en su lugar.

80
Fuente de alimentación
Una fuente de alimentación es un dispositivo que proporciona una fuente de energía eléctrica para un
circuito. Una fuente de alimentación crea una tensión entre sus pines de salida. La medida de la
tensión y la corriente que se suministra varía entre los dispositivos.
Algunos tipos comunes de fuentes de alimentación:
Sobremesa Power Supply - proporciona los cargadores AC (corriente alterna) de origen a DC (corriente
continua).
Batería - Un dispositivo autónomo que produce energía por reacciones químicas en la batería.
Propiedades de estas reacciones son conocidas y por lo tanto el voltaje y la corriente son conocidos.
"Wall Wart " - típicamente un pequeño dispositivo que se conecta a una toma de corriente y la
convierte de AC a DC con un voltaje y corriente predeterminada.
Células solares - Convierte la luz en voltaje eléctrico y corriente. Estos pueden variar en función de la
intensidad de la luz.
Resistor
Una resistencia es un dispositivo que resiste el flujo de electricidad. Esta resistencia al flujo de
electricidad puede ser usado para limitar la cantidad de corriente que fluye en un componente
eléctrico. Su capacidad para resistir la corriente se mide en ohmios [R] o [Capital de Omega ] .
Condensador
Un condensador es un dispositivo que puede almacenar y liberar carga eléctrica en un circuito.
Normalmente, un condensador consta de dos placas de carga con un material en el medio que evita la
descarga eléctrica. Aunque otros tipos de condensadores se pueden producir. Estos dispositivos

81
pueden ser utilizados para suavizar las señales en un circuito. Además, grandes condensadores se
pueden utilizar como sistemas de almacenamiento de corriente. Su capacidad para almacenar carga se
mide en faradios [F].
Inductor
Un inductor es un dispositivo que almacena energía eléctrica en un campo magnético. Un inductor es
una bobina de alambre. Cuando una corriente se envía por el cable se genera un campo magnético.
Cuando el flujo aumenta, más energía se almacena en el campo magnético; cuando el flujo disminuye,
la energía se libera en forma de energía eléctrica. Un inductor se puede utilizar para suavizar o filtrar
las variaciones en la corriente, tanto en la misma forma en que un condensador se puede. La capacidad
de un inductor para almacenar energía eléctrica se mide en Henrys [H].
Diodo
Un diodo es un dispositivo que sólo permite el flujo de electricidad para pasar en una dirección. Estos
componentes se utilizan a menudo para aislar el efecto de un componente de otro.
Algunos tipos comunes de Diodos:
Diodo emisor de luz (LED)
Foto diodo - detecta la luz
Diodo láser - emite un haz de luz coherente (láser)
Diodo Zener - impide que el flujo de corriente hasta un umbral de tensión.

82
LED
Un LED es un diodo que genera una longitud de onda específica de la luz cuando se aplica un voltaje a
través de sus clientes potenciales. Esta tensión se conoce como la tensión directa del LED. El brillo de la
luz varía según la corriente es muy variada.
Un LED no tiene limitantes, por lo que la aplicación de tensiones actuales inherentes superiores a la
tensión directa se suele producir un recalentamiento o quemar el LED . A menudo, el LED está dañada
por esto y todavía se enciende, pero nunca será tan brillante como la configuración original.
Limitadores de corriente resistencias en serie
La manera más simple para limitar la corriente a un LED es usar una resistencia en serie con el LED,
Para calcular el valor correcto de la resistencia, es más fácil utilizar la ley de Ohm para calcular la
corriente eléctrica a través de la resistencia, y no el LED. Esto funciona bien porque la corriente a través
de un circuito en serie es la misma en cada punto en un circuito, lo que significa que la corriente será la
misma a través del LED como la corriente a través de la resistencia.
He aquí un ejemplo: Un LED va a ser alimentados por una fuente de 5 voltios. Comprobación de hoja
de datos del LED, la tensión directa es 3 voltios. Así que una resistencia en serie con el LED tendría 5
voltios - 3 voltios = 2 voltios a través de la resistencia.
Para decirlo de 20 miliamperios a través del LED (una especificación típica para un LED iluminado), la
ley de Ohm se vería así .
E = IR
E = Tensión en voltios I = corriente en amperios R = resistencia en ohmios

83
2 voltios / amperios 0.02 = 100 ohmios, por lo que usar una resistencia de 100 ohmios en serie con el
LED se iluminarán que a una corriente de 0,02 amperios ( 20 miliamperios) .
Así que puedo conectar un LED en un Arduino sin una resistencia?
La respuesta es sí , aunque esto no es necesariamente la mejor de las técnicas . Un pasador ATmega

sólo puede abastecer a unos 40 miliamperios , que no es suficiente corriente para dañar stndard LED.
Una mejor opción sería una resistencia en serie con un valor de entre 100 ohmios y 1k , conectado
entre el LED y el suelo.
Pulsador
Un pulsador es un dispositivo que ya sea completa o interrumpe el flujo de electricy en un circuito
debido a la fuerza en el botón. Los pulsadores vienen en muchas configuraciones y tipos. Un tipo
común es el interruptor momentáneo. Cuando se aplica una fuerza al botón del botón se completar ya
sea la conexión (esto se conoce como un interruptor normalmente abierto ) o interrumpirá la conexión
( esto se conoce como un interruptor normalmente cerrado) . Estos dispositivos pueden ser útiles para
la interrupción de las señales al microcontrolador ( Arduino ) para la entrada .
Transistor
Un transistor es un dispositivo que restringe o permite el flujo de corriente entre dos contactos en
función de la presencia o ausencia de corriente en un tercer contacto. Un transistor tiene tres
terminales: colector, emisor y base. El colector y actuar como emisor de la entrada y la salida para el
transistor. Mientras que la base es el detonante de la señal.
Dos tipos comunes de los transistores son:

84
PNP - Si la tensión de base es menor que la tensión de emisor, a continuación, la corriente fluye desde
el emisor al colector.
NPN - Si la tensión de base es mayor que la tensión de emisor, a continuación, la corriente fluye desde
el colector al emisor.
{Nota: La P significa semiconductor tipo P y el N es N- tipo semiconductor}
Dos usos comunes para los transistores son para actuar como un interruptor activado eléctricamente.
También transistores se pueden utilizar para aumentar (amplificar) la corriente de salida .

85
Relé
Un relé es un dispositivo que completa una conexión entre dos puntos de contacto por medio de un
movimiento mecánico. Un relé puede utilizar un solenoide para mover magnéticamente un interruptor
de contacto. Se envía una señal al relé que puede ser usado como la fuente del electroimán. Se suelen
utilizar como mecanismos que permitan la pequeña corriente DC para cambiar grandes corrientes AC o
DC de conmutación. En esta aplicación se pueden aislar los circuitos de control más sensible de los
componentes más grandes.
Fotoresistor
Una fotorresistencia es un tipo especial de resistencia que es la foto (o la luz ) sensible es decir, la
resistencia cambia según la cantidad de luz que se encuentra en la fotorresistencia.

86
Modulo Arduino
El módulo Arduino ha sido usado como base en diversas aplicaciones electrónicas:
Xoscillo: Osciloscopio de código abierto.
Equipo científico para investigaciones.
Arduinome: Un dispositivo controlador MIDI.
OBDuino: un económetro que usa una interfaz de diagnóstico a bordo que se halla en los
automóviles modernos.
Humane Reader: dispositivo electrónico de bajo costo con salida de señal de TV que pueden manejar
una biblioteca de 5000 títulos en una tarjeta microSD.
The Humane PC: equipo que usa un módulo Arduino para emular un computador personal, con un
monitor de televisión y un teclado para computadora.
Ardupilot: software y hardware de aviones no tripulados.
ArduinoPhone: un teléfono móvil celular construido sobre un módulo Arduino.
Arduino puede tomar información del entorno a través de sus pines de entrada de toda una gama de
sensores y puede afectar aquello que le rodea controlando luces, motores y otros actuadores. El
microcontrolador en la placa Arduino se programa mediante el lenguaje de programación Arduino
(basasdo en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Los proyectos hechos
con Arduino pueden ejecutarse sin necesidad de conectar a un ordenador, si bien tienen la posibilidad
de hacerlo y comunicar con diferentes tipos de software

87
Programación de Arduino
Estructura del programa
La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al
menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen
declaraciones, estamentos o instrucciones.
void setup()
{
estamentos;
}
void loop()
{
estamentos;
}
En donde setup() es la parte encargada de recoger la configuración y loop() es la que contienen el
programa que se ejecutará cíclicamente (de ahí el termino loop –bucle-).
Ambas funciones son necesarias para que el programa trabaje.
La función de configuración debe contener la declaración de las variables. Es la primera función a

ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para configurar o inicializar pinMode
(modo de trabajo de las E/S), configuración de la comunicación en serie y otras.
La función bucle (loop) siguiente contiene el código que se ejecutara continuamente (lectura de
entradas, activación de salidas, etc) Esta función es el núcleo de todos los programas de Arduino y la
que realiza la mayor parte del trabajo.

88
Setup()
La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los
modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya
declaración que ejecutar.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
}
loop()
Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se ejecuta
de forma cíclica, lo que posibilita que el programa este respondiendo continuamente ante los eventos
que se produzcan en la tarjeta
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ´pin´
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ´pin´
delay(1000);
}
Función
Una función es un bloque de código que tiene un nombre y un conjunto de estamentos que son
ejecutados cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado. Las
funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un
programa. Las funciones se declaran asociadas a un tipo de valor “type”. Este valor será el que
devolverá la función, por ejemplo 'int' se utilizará cuando la función devuelva un dato numérico de tipo
entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que
significa “función vacía”. Después de declarar el tipo de dato que devuelve la función se debe escribir el
nombre de la función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben
pasar a la función para que se ejecute.

89
type nombreFunción(parámetros)
{
estamentos;
}
La función siguiente devuelve un número entero, delayVal() se utiliza para poner un valor de retraso en
un programa que lee una variable analógica de un potenciómetro conectado a una entrada de Arduino.
Al principio se declara como una variable local, ´v´ recoge el valor leído del potenciómetro que estará
comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un margen comprendido
entre 0 y 255, finalmente se devuelve el valor ´v´ y se retornaría al programa principal. Esta función
cuando se ejecuta devuelve el valor de tipo entero ´v´.
int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potenciómetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}
{} entre llaves
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para los
bloques de programación setup(), loop(), if.., etc.
Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si no es así el programa
dará errores.
; punto y coma
El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación de Arduino.
También se utiliza para separar elementos en una instrucción de tipo “bucle for”.
Olvidarse de poner fin a una línea con un punto y coma se traducirá en un error de compilación.

90
/*… */ bloque de comentarios

Los bloques de comentarios, o multi-línea de comentarios, son áreas de texto ignorados por el
programa que se utilizan para las descripciones del código o comentarios que ayudan a comprender el
programa. Comienzan con / * y terminan con * / y pueden abarcar varias líneas.
// línea de comentarios
Una línea de comentario empieza con / / y terminan con la siguiente línea de código. Al igual que los
comentarios de bloque, los de línea son ignoradas por el programa y no ocupan espacio en la memoria.
Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más
información acerca de lo que hace esta o para recordarla más adelante.
Variables
Una variable es una manera de nombrar y almacenar un valor numérico para su uso posterior por el
programa. Como su nombre indica, las variables son números que se pueden variar continuamente en
contra de lo que ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser declarada y,
opcionalmente, asignarle un valor. El siguiente código de ejemplo declara una variable llamada variable
Entrada y luego le asigna el valor obtenido en la entrada analógica del PIN2:
int variableEntrada = 0; // declara una variable y le asigna el valor 0

variableEntrada = analogRead(2);// la variable recoge el valor analógico del PIN2
'variableEntrada' es la variable en sí. La primera línea declara que será de tipo entero “int”. La segunda
línea fija a la variable el valor correspondiente a la entrada analógica PIN2. Esto hace que el valor de
PIN2 sea accesible en otras partes del código.
Una vez que una variable ha sido asignada, o re-asignada, usted puede probar su valor para
ver si cumple ciertas condiciones (instrucciones if...), o puede utilizar directamente su valor. Como
ejemplo ilustrativo veamos tres operaciones útiles con variables: el siguiente código prueba si la

91
variable “entradaVariable” es inferior a 100, si es cierto se asigna el valor 100 a “entradaVariable” y, a

continuación, establece un retardo (delay) utilizando como valor “entradaVariable” que ahora será
como mínimo de valor 100:
if (entradaVariable < 100) // pregunta si la variable es menor de 100

{
entradaVariable = 100;// si es cierto asigna el valor 100 a esta
}
delay(entradaVariable); // usa el valor como retardo
Las variables deben tomar nombres descriptivos, para hacer el código más legible.
Declaración de variables
Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para declarar una variable
se comienza por definir su tipo como int (entero), long (largo), float (coma flotante), etc, asignándoles
siempre un nombre, y, opcionalmente, un valor inicial. Esto sólo debe hacerse una vez en un programa,
pero el valor se puede cambiar en cualquier momento usando aritmética y reasignaciones diversas.
El siguiente ejemplo declara la variable entradaVariable como una variable de tipo entero “int”, y
asignándole un valor inicial igual a cero. Esto se llama una asignación.
int entradaVariable = 0;
Una variable puede ser declarada en una serie de lugares del programa y en función del lugar en donde
se lleve a cabo la definición esto determinará en que partes del programa se podrá hacer uso de ella.
Utilización de una variable

Una variable puede ser declarada al inicio del programa antes de la parte de configuración setup(), a
nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo if...
for..., etc. En función del lugar de declaración de la variable así se determinara el ámbito de aplicación,
o la capacidad de ciertas partes de un programa para hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un
programa. Esta variable se declara al comienzo del programa, antes de setup().

92
Una variable local es aquella que se define dentro de una función o como parte de un bucle. Sólo es
visible y sólo puede utilizarse dentro de la función en la que se declaró.
Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes partedel mismo
programa que pueden contener valores diferentes. La garantía de que sólo una función tiene acceso a
sus variables dentro del programa simplifica y reduce el potencial de errores de programación.
El siguiente ejemplo muestra cómo declarar a unos tipos diferentes de variables y la visibilidad de cada
variable:
int value; // 'value' es visible para cualquier función

void setup()
{
// no es necesario configurar
}
void loop()
{
for (int i=0; i<20;) // 'i' solo es visible
{ // dentro del bucle for
i++;
}
float f; // 'f' es visible solo
} // dentro del bucle
Tipos de datos
Byte
Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y
255
byte unaVariable = 180; // declara 'unaVariable' como tipo byte
Int
Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales
comprendidos en el rango 32,767 to -32,768.
int unaVariable = 1500; // declara 'unaVariable' como una variable de tipo entero

93
Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como
consecuencia de una operación. Por ejemplo, si x = 32767 y una posterior declaración agrega 1 a x, x =
x + 1 entonces el valor se x pasará a ser -32.768. (algo así como que el valor da la vuelta)
long
El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin
decimales que se encuentran dentro del rango -2147483648 a 2147483647.
long unaVariable = 90000; // declara 'unaVariable' como tipo long
float
El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los
números de punto flotante tienen una mayor resolución que los de 32 bits con un rango comprendido
3.4028235E +38 a +38-3.4028235E.
float unaVariable = 3.14; // declara 'unaVariable' como tipo flotante

Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las
comparaciones. Los cálculos matemáticos de punto flotante son también mucho más lentos que los del
tipo de números enteros, por lo que debe evitarse su uso si es posible.
arrays
Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede
ser recogido haciendo uso del nombre de la matriz y el número del índice.
El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto
es el de la posición 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada
posición antes de ser utilizado
int miArray[] = {valor0, valor1, valor2...}

94
Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño y
posteriormente, asignar valores a una posición especifica:
int miArray[5]; // declara un array de enteros de 6 posiciones

miArray[3] = 10; // asigna l valor 10 a la posición 4
Para leer de un array basta con escribir el nombre y la posición a leer:
x = miArray[3]; // x ahora es igual a 10 que está en la posición 3 del array

Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que la variable de incremento
del contador del bucle se utiliza como índice o puntero del array. El siguiente ejemplo usa una matriz
para el parpadeo de un LED.
Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la posición
de índice 0 en la serie que hemos escrito dentro del array parpadeo[], en este caso 180, que se envía a
la salida analógica tipo PWM configurada en el PIN10, se hace una pausa de 200 ms y a continuación se
pasa al siguiente valor que asigna el índice “i”.
int ledPin = 10; // Salida LED en el PIN 10

byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array de 8 valores diferentes
void setup()
{
pinMode(ledPin, OUTPUT); //configura la salida PIN 10
}
void loop() // bucle del programa
{
for(int i=0; i<8; i++) // crea un bucle tipo for utilizando la variable i de 0 a 7
{
analogWrite(ledPin, parpadeo[i]); // escribe en la salida PIN 10 el valor alque apunta i
//entro del array parpadeo[]
delay(200); // espera 200ms
}
}
Aritmética
Los operadores aritméticos que se incluyen en el entorno de programación son suma, resta,
multiplicación y división. Estos devuelven la suma, diferencia, producto, o cociente (respectivamente)
de dos operandos.

95
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;
La operaciones se efectúa teniendo en cuanta el tipo de datos que hemos definido para los operandos
(int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de
resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen
los decimales con este tipo de datos.
Esto también significa que la operación puede sufrir un desbordamiento si el resultado es más grande
que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos
numéricos que ya hemos explicado anteriormente.
Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los
operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo
integer, para el cálculo se utilizará el método de float es decir el método de coma flotante.
Elija el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los
resultados sean lo precisos que usted desea.
Asignaciones compuestas
Las asignaciones compuestas combinan una operación aritmética con una variable asignada. Estas son
comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones
compuestas pueden ser:
x ++ // igual que x = x + 1, o incrementar x en + 1

x -- // igual que x = x - 1, o decrementar x en -1
x += y // igual que x = x + y, o incrementra x en +y
x -= y // igual que x = x - y, o decrementar x en -y
x *= y // igual que x = x * y, o multiplicar x por y
x /= y // igual que x = x / y, o dividir x por y

96
Operadores de comparación
Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras
condicionales del tipo if.. para testear si una condición es verdadera. En los ejemplos que siguen en las
próximas páginas se verá su utilización práctica usando los siguientes tipo de condicionales:
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
Operadores lógicos
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un
VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y
NOT (!), que a menudo se utilizan en estamentos de tipo if..:
Logical AND:
if (x > 0 && x < 5) // cierto sólo si las dos expresiones son ciertas
Logical OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es cierta
Logical NOT:
if (!x > 0) // cierto solo si la expresión es falsa
Constantes
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados
constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en
grupos.
cierto/falso (true/false)
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se
refieren al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia con

97
1, pero TRUE también puede ser cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -
1, 2 y -200 son todos también se define como TRUE. (esto es importante tenerlo en cuanta)
if (b == TRUE);
{
ejecutar las instrucciones;
high/low
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la escritura
digital para las patillas. ALTO se define como en la lógica de nivel 1, ON, ó 5 voltios, mientras que BAJO
es lógica nivel 0, OFF, o 0 voltios.
digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de
los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o
una salida OUTPUT.
pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida
input/output
Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de
los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o
una salida OUTPUT.
pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida
Control de flujo
if (si)
if es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por
ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de
declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no

98
se cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves, El formato
para if es el siguiente:
if (unaVariable ?? valor)
{
ejecutaInstrucciones;
}
En el ejemplo anterior se compara una variable con un valor, el cual puede ser una variable o
constante. Si la comparación, o la condición entre paréntesis se cumple (es cierta), las declaraciones
dentro de los corchetes se ejecutan. Si no es así, el programa salta sobre ellas y sigue.
Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10), podría parecer que es
válido pero sin embargo no lo es ya que esa expresión asigna el valor 10 a la variable x, por eso dentro
de la estructura if se utilizaría X==10 que en este caso lo que hace el programa es comprobar si el valor
de x es 10.. Ambas cosas son distintas por lo tanto dentro de las estructuras if, cuando se pregunte por
un valor se debe poner el signo doble de igual “==”
if… else (si….. sino ..)

if… else viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto
otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o
hacer otra cosa si la entrada es baja, usted escribiría que de esta manera:
if (inputPin == HIGH) // si el valor de la entrada inputPin es alto

{
instruccionesA; //ejecuta si se cumple la condición
}
else
{
instruccionesB; //ejecuta si no se cumple la condición
}
Else puede ir precedido de otra condición de manera que se pueden establecer varias estructuras
condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente
excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos

99
condicionales. Recuerde sin embargo qué sólo un conjunto de declaraciones se llevará a cabo
dependiendo de la condición probada:
if (inputPin < 500)

{
instruccionesA; // ejecuta las operaciones A
}
else if (inputPin >= 1000)
{
instruccionesB; // ejecuta las operaciones B
}
else
{
instruccionesC; // ejecuta las operaciones C
}
Nota: Un estamento de tipo if prueba simplemente si la condición dentro del paréntesis es verdadera o
falsa. Esta declaración puede ser cualquier declaración válida. En el anterior ejemplo, si cambiamos y
ponemos (inputPin == HIGH). En este caso, el estamento if sólo chequearía si la entrada especificado
esta en nivel alto (HIGH), o +5v.
for
La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número
determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la
condición. La declaración for tiene tres partes separadas por (;) vemos el ejemplo de su sintaxis:
for (inicialización; condición; expresión)

{
ejecutaInstrucciones;
}
La inicialización de una variable local se produce una sola vez y la condición se testea cada vez que se
termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las
instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.
El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es inferior a 20 y si es

cierto i se incrementa en 1 y se vuelven a ejecutar las instrucciones que hay dentro de las llaves:

100
for (int i=0; i<20; i++) // declara i, prueba que es menor que 20, incrementa i en 1
{
digitalWrite(13, HIGH); // envía un 1 al pin 13
delay(250); // espera ¼ seg.
digitalWrite(13, LOW); // envía un 0 al pin 13
delay(250); // espera ¼ de seg.
}
Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados en algunos otros
lenguajes de programación, incluyendo BASIC. Cualquiera de los tres elementos de cabecera puede
omitirse, aunque el punto y coma es obligatorio. También las declaraciones de inicialización, condición
y expresión puede ser cualquier estamento válido en lenguaje C sin relación con las variables
declaradas. Estos tipos de estados son raros pero permiten disponer soluciones a algunos problemas
de programación raras.
While
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada
entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del
bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también
por el cambio de un valor en una entrada de un sensor
while (unaVariable ?? valor)

{
ejecutarSentencias;
}
El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es verdad, ejecuta las
declaraciones dentro de los corchetes y continuará ejecutando el bucle hasta que 'unaVariable' no sea
inferior a 200.
While (unaVariable < 200) // testea si es menor que 200

{
instrucciones; // ejecuta las instrucciones entre llaves
unaVariable++; // incrementa la variable en 1
}

101
do while
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la
condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una
vez.
do
{
Instrucciones;
} while (unaVariable ?? valor);
El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milisegundos, y luego
continua mientras que el valor de la 'x' sea inferior a 100:
do
{
x = leeSensor();
delay(50);
} while (x < 100);
E/S digitales
pinMode(pin, mode)
Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de
trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura ‘pin’ como salida

Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es
necesario definirlos en el caso de que vayan a trabajar como entradas. Los pines configurados como
entrada quedan, bajo el punto de vista eléctrico, como entradas en estado de alta impedancia.
Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede acceder mediante
software. Estas resistencias se accede de la siguiente manera:
pinMode(pin, INPUT); // configura el ‘pin’ como entrada

digitalWrite(pin, HIGH); // activa las resistencias internas

102
Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores. En el
ejemplo anterior no se trata de convertir un pin en salida, es simplemente un método para activar las
resistencias interiores.
Los pins configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia estado
y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta corriente
es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es lo
suficiente grande como para alimentar cargas de mayor consumo como relés, solenoides, o motores.
Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el
chip Atmega. A menudo es una buena idea conectar en la OUTUPT (salida) una resistencia externa de
470 o de 1000 Ω.
digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW
(bajo). El pin se puede especificar ya sea como una variable o una constante (0-13).
valor = digitalRead(Pin); // hace que 'valor sea igual al estado leído en ´Pin´
digitalWrite(pin, value)
Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El
pin se puede especificar ya sea como una variable o como una constante (0-13).
digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH (alto o 1)

El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el
´pin´ de salida LED:
digitalRead(pin)
digitalWrite(pin, value)
int led = 13; // asigna a LED el valor 13
int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el valor 0
void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13) como salida

103
pinMode(boton, INPUT); // configura botón (pin7) como entrada

}
void loop()
{
valor = digitalRead(boton); //lee el estado de la entrada botón
digitalWrite(led, valor); // envía a la salida ´led´ el valor leído
}
analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica con una resolución de 10 bits.
Esta instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila de 0 a 1023.
valor = analogRead(pin); // asigna a valor lo que lee en la entrada ´pin'

Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declarados como
INPUT u OUPUT ya que son siempre INPUT´s.
analogWrite(pin, value)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de
modulación por ancho de pulso (PWM) a uno de los pin´s de Arduino marcados como “pin PWM”. El
más reciente Arduino, que implementa el chip ATmega168, permite habilitar como salidas analógicas
tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los modelos de Arduino más antiguos que implementan el chip
ATmega8, solo tiene habilitadas para esta función los pines 9, 10 y 11. El valor que se puedeenviar a
estos pines de salida analógica puede darse en forma de variable o constante, pero siempre con un
margen de 0-255.
analogWrite(pin, valor); // escribe 'valor' en el 'pin' definido como analógico

Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera una
salida de 5 voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca tensiones
entre 0 y 5 voltios - el valor HIGH de salida equivale a 5v (5 voltios). Teniendo en cuenta el concepto de
señal PWM , por ejemplo, un valor de 64 equivaldrá a mantener 0 voltios de tres cuartas partes del
tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en 0
la mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener en la
salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del tiempo restante.

104
Debido a que esta es una función de hardware, en el pin de salida analógica (PWN) se generará una
onda constante después de ejecutada la instrucción analogWrite hasta que se llegue a ejecutar otra
instrucción analogWrite (o una llamada a digitalRead o digitalWrite en el mismo pin).
Nota: Las salidas analógicas a diferencia de las digitales, no necesitan ser declaradas como INPUT u
OUTPUT.El siguiente ejemplo lee un valor analógico de un pin de entrada analógica, convierte el valor
dividiéndolo por 4, y envía el nuevo valor convertido a una salida del tipo PWM o salida analógica:
int led = 10; // define el pin 10 como ´led´

int analog = 0; // define el pin 0 como ´analog´
int valor; // define la variable ´valor´
void setup(){} // no es necesario configurar entradas y salidas
void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo asocia a la variable valor
valor /= 4; //divide valor entre 4 y lo reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor
}
Tiempo
delay(ms)
Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia instrucción.
De tal manera que 1000 equivale a 1seg.
delay(1000); // espera 1 segundo
millis()
Devuelve el número de milisegundos transcurrido desde el inicio del programa en Arduino hasta el
momento actual. Normalmente será un valor grande (dependiendo del delay(ms) millis() tiempo que
este en marcha la aplicación después de cargada o después de la última vez que se pulsó el botón
“reset” de la tarjeta).
valor = millis(); // valor recoge el número de milisegundos

105
Nota: Este número se desbordará (si no se resetea de nuevo a cero), después de aproximadamente 9
horas.
Matemáticas
min(x, y)
Calcula el mínimo de dos números para cualquier tipo de datos devolviendo el número más pequeño.
valor = min(valor, 100); // asigna a valor el más pequeños de los dos números //especificados.
Si 'valor' es menor que 100 valor recogerá su propio valor si ´valor´ es mayor que 100 valor pasara a
valer 100.
max(x, y)
Calcula el máximo de dos números para cualquier tipo de datos devolviendo el número mayor de los
dos.
valor = max(valor, 100); // asigna a valor el mayor de los dos números 'valor' y 100.
De esta manera nos aseguramos de que valor será como mínimo 100.
aleatorio
randomSeed(seed)
Establece un valor, o semilla, como punto de partida para la función random().
randomSeed(valor); // hace que valor sea la semilla del random

Debido a que Arduino es incapaz de crear un verdadero número aleatorio, randomSeed le permite
colocar una variable, constante, u otra función de control dentro de la función random, lo que permite
generar números aleatorios "al azar". Hay una variedad de semillas, o funciones, que pueden ser
utilizados en esta función, incluido millis () o incluso analogRead () que permite leer ruido eléctrico a
través de un pin analógico.

106
random(max)
random(min, max)
La función random devuelve un número aleatorio entero de un intervalo de valores especificado entre
los valores min y max.
valor = random(100, 200); // asigna a la variable 'valor' un numero aleatorio comprendido // entre
100-200
Nota: Use esta función después de usar el randomSeed(). El siguiente ejemplo genera un valor
aleatorio entre 0-255 y lo envía a una salida analógica PWM :
int randNumber; // variable que almacena el valor aleatorio

int led = 10; // define led como 10
void setup() {} // no es necesario configurar nada
void loop()
{
randomSeed(millis()); // genera una semilla para aleatorio a partir de la función millis()
randNumber = random(255); // genera número aleatorio entre 0-255
analogWrite(led, randNumber); // envía a la salida led de tipo PWM el valor
delay(500); // espera 0,5 seg.
}
Puerto serie
Serial.begin(rate)
Abre el puerto serie y fija la velocidad en baudios para la transmisión de datos en serie.
El valor típico de velocidad para comunicarse con el ordenador es 9600, aunque otrasvelocidades
pueden ser soportadas.
void setup()
{
Serial.begin(9600); // abre el Puerto serie
} // configurando la velocidad en 9600 bps
Nota: Cuando se utiliza la comunicación serie los pins digital 0 (RX) y 1 (TX) no puede utilizarse al
mismo tiempo.

107
Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro automático y salto de línea. Este
comando toma la misma forma que Serial.print (), pero es más fácil para la lectura de los datos en el
Monitor Serie del software.
Serial.println(analogValue); // envía el valor 'analogValue' al puerto

Nota: Para obtener más información sobre las distintas posibilidades de Serial.println () y Serial.print ()
puede consultarse el sitio web de Arduino.
El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos al ordenador cada 1
segundo.
void setup()
{
Serial.begin(9600); // configura el puerto serie a 9600bps
}
void loop()
{
Serial.println(analogRead(0)); // envía valor analógico
Serial.print(data, data type)

Vuelca o 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.
Parámetros
data: el número o la cadena de caracteres a volcar o enviar.
data type: determina el formato de salida de los valores numéricos (decimal, octal, binario,
etc...) DEC, OCT, BIN, HEX, BYTE , si no se pe nada vuelva ASCII
Vuelca o envía un número o una cadena de caracteres al puerto serie, seguido de un carácter de
retorno de carro "CR" (ASCII 13, or '\r') y un carácter de salto de línea "LF"(ASCII 10, or '\n'). Toma la
misma forma que el comando Serial.print()

108
Serial.println(b) vuelca o envía el valor de b como un número decimal en caracteres ASCII seguido de
"CR" y "LF".
int b = 79; Serial.print(b); // prints the string "79".

Serial.println(b, DEC) vuelca o envía el valor de b como un número decimal en caracteres ASCII seguido
de "CR" y "LF".
int b = 79;
Serial.print(b, DEC); // prints the string "79".
Serial.println(b, HEX) vuelca o envía el valor de b como un número hexdecimal en caracteres ASCII
seguido de "CR" y "LF".
int b = 79;
Serial.print(b, HEX); // prints the string "4F".
Serial.println(b, OCT) vuelca o envía el valor de b como un número Octal en caracteres ASCII seguido
de "CR" y "LF".
int b = 79;
Serial.print(b, OCT); // prints the string "117".
Serial.println(b, BIN) vuelca o envía el valor de b como un número binario en caracteres ASCII seguido
de "CR" y "LF".
int b = 79;
Serial.print(b, BIN); // prints the string "1001111".
Serial.print(b, BYTE) vuelca o envía el valor de b como un byteseguido de "CR" y "LF".
int b = 79;
Serial.print(b, BYTE); // Devuelve el caracter "O", el cual representa el caracter ASCII del
//valor 79. (Ver tabla ASCII ).
Serial.println(str) vuelca o envía la cadena de caracteres como una cadena ASCII seguido de "CR" y
"LF".
Serial.print("Hello World!"); // vuelca "Hello World!".
Serial.println() sólo vuelca o envía "CR" y "LF". Equivaldría a printNewline().

109
Serial.available()
int Serial.available()
Obtiene un número entero con el número de bytes (caracteres) diponibles para leer o capturar desde
el puerto serie. Equivaldría a la función serialAvailable().
Devuelve Un entero con el número de bytes disponibles para leer desde el buffer serie, o 0 si no hay
ninguno. Si hay algún dato disponible, SerialAvailable() será mayor que 0. El buffer serie puede
almacenar como máximo 64 bytes.
Ejemplo
int incomingByte = 0; // almacena el dato serie

void setup() {
Serial.begin(9600); // abre el puerto serie, y le asigna la velocidad de 9600
bps
}
void loop() {
// 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()
int Serial.Read()
Lee o captura un byte (un caracter) desde el puerto serie. Equivaldría a la función
serialRead(). Devuelve :El siguiente byte (carácter) desde el puerto serie, o -1 si no hay ninguno.
Ejemplo
int incomingByte = 0; // almacenar el dato serie

void setup() {
Serial.begin(9600); // abre el puerto serie,y le asigna la velocidad de 9600
bps
110
}
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);
}
}

111
Bibliotecas ARDUINO
Para hacer uso de una biblioteca en Sketch (el IDE de Arduino), basta con hacer clic sobre “Import
Library” en el menú, escoger una biblioteca y se añadirá el #include correspondiente.
A continuación mencionare algunas de las librerías estándar que maneja Arduino:
• EEPROM: Para leer y escribir en memorias "permanentes".
• 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
simultáneas.
• Firmata: Para comunicarse con aplicaciones en la computadora usando un protocolo estándar

Serial.
• LiquidCrystal: Esta librería es para controlar Displays, soporta modos de 4 y 8 bits.
• Servo: Para el control de Servo motores. La biblioteca soporta hasta 12 motores en la mayoría
de placas Arduino y 48 en la Arduino Mega. El manejo de la biblioteca es bastante sencillo. Mediante
attach(número de pin) añadimos un servo y mediante write podemos indicar los grados que queremos
que tenga el motor.
• Stepper: Control de motores paso a paso. 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.
Ademas de estas librerías existen otras que también son compatibles como:
• Matrix - Librería para manipular displays de matrices de LED básicas.
• Sprite - Libreri¬a básica para manipulación de sprites para usar en animaciones con matrices de
LEDs.

112
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 biblioteca.
Esto es muy interesante por varias razones: permite disponer de código que puede reutilizarse en otros
proyectos de forma cómoda; nos permite mantener el código fuente principal separado de las
bibliotecas de forma que sean mantenibles de forma separada; y la organización de los programas
construidos es más clara y elegante.
Este documento explica cómo crear una librería para Arduino. Se inicia con un programa de código
Morse y explica cómo convertir sus funciones en una librería. Esto permite que otras personas usen el
código que has escrito y puedan actualizarlo facilmente a medida que mejora la librería.
Comenzamos con un programa de código Morse:
int pin = 13;
void setup() {
pinMode(pin, OUTPUT);
void loop() {
punto(); punto(); punto();
raya(); raya(); raya();
punto(); punto(); punto();
delay(3000);
void punto() {
digitalWrite(pin, HIGH);
delay(250);
digitalWrite(pin, LOW);
delay(250);

113
void raya() {
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(250);
Si ejecuta este programa, se representará el código de SOS (llamada de auxilio) en el pin 13.
El programa tiene unas pocas partes que tendremos que poner en nuestra librería. En primer lugar,
tenemos las funciones punto() y raya() que hacen el parpadeo. En segundo lugar, tenemos la variable
ledPin que indica el pin a utilizar. Por último, está la llamada a pinMod () que inicializa el pin como
salida.
Vamos a empezar a convertir el programa en una librería!
Para una librería necesita al menos dos arcivos: un archivo de cabecera (w / con extensión. H) y el
código fuente (w / extensión. cpp). El archivo de cabecera contiene definiciones para la librería:
básicamente un listado de todo lo que hay dentro, mientras que el archivo del código fuente tiene el
código real. Vamos a llamar a nuestra librería "Morse", por lo que nuestro archivo de cabecera será
Morse.h. Echemos un vistazo a lo que contiene. Puede parecer un poco extraño al principio, pero
tendrá más sentido una vez que vea el código fuente que lo acompaña.
El archivo de cabecera consiste básicamente en una clase con una línea para cada función de la librería,
junto con las variables que se van a usar:
class Morse {
public:
Morse(int pin);
void punto();
void raya();
private:

114
int _pin;
};
Una clase es simplemente una colección de funciones y variables agrupadas en un mismo lugar. Estas
funciones y variables pueden ser públicas, lo que significa que las podrán usar las personas que están
utilizando la librería, o privada, lo que significa que sólo se puede acceder a ellas desde la propia clase.
Cada clase tiene una función especial conocida como constructor, que se utiliza para crear una
instancia de la clase (o sea, un objeto). El constructor tiene el mismo nombre que la clase, y no
devuelve nada.
Se necesitan un par cosas más en el archivo de encabezado. Una de ellas es una instrucción # include
que da acceso a los tipos estándar y las constantes del lenguaje Arduino (esto se agrega
automáticamente a los programas normales, pero no a las librerías). Se parece a esto (y se coloca antes
de la definición de la clase mostrada anteriormente):
1. Include "WProgram.h"
Por último, es común añadir las siguientes líneas de código :
1. Ifndef Morse_h
2. Define Morse_h
// La declaración # include y el código van aquí ...
1. endif
Básicamente, esto evita problemas si alguien accidentalmente usa dos veces el #include con la librería
que estamos construyendo, evitando que se declaren las variables y funciones más de una vez.
Por último, se suele poner un comentario en la parte superior de la librería con su nombre, una breve
descripción de lo que hace, quién lo escribió, la fecha y el tipo de licencia.
Echemos un vistazo a la cabecera completa:
/*

115
Morse.h - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.
• /
1. ifndef Morse_h
2. define Morse_h
3. include "WProgram.h"
class Morse {
public:
Morse(int pin);
void punto();
void raya();
private:
int _pin;
};
1. endif
Vamos a repasar las distintas partes del código fuente de Morse.cpp.
Lo primero son un par de # include. Con esto el resto del código tendrá acceso a las funciones estándar
de Arduino, y a las definiciones definidas en Morse.h:
1. Include "WProgram.h"
2. Include "Morse.h"

116
Aplicaciones de ARDUINO
Entre las aplicaciones, debido a las posibilidades que presentan sus entradas, nos permite utilizar una
gran variedad de sensores, como se ha dicho. Esto es sólo el arranque de una aventura con la
compañía de Arduino.
Blink Without Delay

A veces es necesario abrir y cerrar de (alguna otra función sensibles al tiempo o) LED al mismo tiempo
que otra cosa (como viendo por una pulsación de botón). Eso significa que usted no puede utilizar
delay (), o que le deje todo lo demás del programa, mientras que el LED parpadea. Aquí hay algo de
código que muestra cómo parpadea el LED sin usar delay (). Se realiza un seguimiento de la última vez
que convertido el LED encendido o apagado. Entonces, cada vez que a través de loop () comprueba si
un intervalo suficiente ha pasado - si tiene un rato, la LED apagado si estaba encendido y viceversa.
Code
int ledPin = 13; // LED connected to digital pin 13
int value = LOW; // previous value of the LED
long previousMillis = 0; // will store last time LED was updated
long interval = 1000; // interval at which to blink (milliseconds)
void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output
}
void loop()
{
// here is where you'd put code that needs to be running all the time.
// check to see if it's time to blink the LED; that is, is the difference
// between the current time and last time we blinked the LED bigger than
// the interval at which we want to blink the LED.
if (millis() - previousMillis > interval) {
previousMillis = millis(); // remember the last time we blinked the LED
// if the LED is off turn it on and vice-versa.
if (value == LOW)
value = HIGH;
else
value = LOW;
digitalWrite(ledPin, value);
}
}

117
Button
El pulsador es un componente que conecta dos puntos en un circuito al presionarlo. El ejemplo se
enciende un LED cuando pulsa el botón.
Conectamos tres cables a la placa Arduino. La primera va desde una pata del pulsador a través de una
resistencia de pull-up (en este caso 2.2 Ohms) a la alimentación de 5 voltios. El segundo va desde la
pata correspondiente del botón pulsador a tierra. La tercera se conecta a una E / S digital pin (en este
caso el pin 7), que lee el estado del botón.
Cuando el pulsador está abierto (sin prensar) no hay conexión entre las dos patas de la pulsador, por lo
que el pasador es conectados a 5 voltios (a través de la resistencia pull-up) y leemos un ALTO. Cuando
se cierra el botón (pulsado) , se hace una conexión entre sus dos piernas , que conecta la clavija a tierra
, por lo que leemos un BAJO. (El pasador está todavía conectado a 5 voltios, pero la resistencia en -
entre ellos significa que el pin es " más cerca" de tierra. ) También puede conectar este circuito en
sentido contrario, con una resistencia de pull-down mantener el bajo nivel de insumos, y yendo ALTA
cuando el se pulsa el botón. Si es así, el comportamiento del boceto se invertirá, con el LED
normalmente y apagado cuando se presiona el botón.
Si desconecta el i / o digitales pin de todo, el LED parpadee erráticamente. Esto es porque la entrada es
"flotante " - es decir, se volverá más o menos al azar, ya sea alta o baja. Es por eso que usted necesita
un pull-up o resistor pull-down en el circuito.
Code
int ledPin = 13; // choose the pin for the LED

int inPin = 2; // choose the input pin (for a pushbutton)
int val = 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inPin, INPUT); // declare pushbutton as input
}
void loop(){
val = digitalRead(inPin); // read input value
if (val == HIGH) { // check if the input is HIGH (button
released)
digitalWrite(ledPin, LOW); // turn LED OFF
} else {
digitalWrite(ledPin, HIGH); // turn LED ON
}
}

118
LOOP
También hacemos un llamamiento este ejemplo "El coche fantástico", en memoria a una serie de
televisión de los años 80, donde el famoso David Hasselhoff tenía una Máquina AI conducía su Pontiac.
El coche había sido aumentado con un montón de LEDs en todos los tamaños posibles escénicas
llamativo efectos.
Así que decidimos que el fin de aprender más sobre programación secuencial y buenas técnicas de
programación para la E / S bordo, sería interesante usar el coche fantástico como una metáfora.
Este ejemplo hace uso de 6 LEDs conectados a los pines 2-7 en el tablero utilizando resistencias de 220
ohmios. El primer ejemplo de código hará que los LED parpadean en secuencia, uno por uno utilizando
sólo digitalWrite (PinNum, ALTA / BAJA) y el retardo (el tiempo). la segundo ejemplo muestra cómo
utilizar un for (;;) construcción para llevar a cabo la misma cosa, pero en menos líneas. La tercera y
último ejemplo se centra en el efecto visual de convertir los indicadores LED de encendido / apagado
de una manera más suave.
Code
int timer = 100; // The higher the number, the slower the timing.
int pins[] = { 2, 3, 4, 5, 6, 7 }; // an array of pin numbers
int num_pins = 6; // the number of pins (i.e. the length of the array)
void setup()
{
int i;
for (i = 0; i < num pins; i++) // the array elements are numbered from 0 to num pins - 1
pinMode(pins[i], OUTPUT); // set each pin as an output
}
void loop()
{
int i;
for (i = 0; i < num_pins; i++) { // loop through each pin...
digitalWrite(pins[i], HIGH); // turning it on,
delay(timer); // pausing,
digitalWrite(pins[i], LOW); // and turning it off.
}
for (i = num_pins - 1; i >= 0; i--) {
digitalWrite(pins[i], HIGH);
delay(timer);
digitalWrite(pins[i], LOW);
}

119
Entrada Analógica
Un potenciómetro es una perilla simple que proporciona una resistencia variable, que se puede leer en
la placa Arduino como un análogo valor. En este ejemplo, el valor controla la velocidad a la que un LED
parpadea.
Conectamos tres cables a la placa Arduino. El primero va al suelo de una de las patas exteriores del
potenciómetro. Los segundos va de 5 voltios en la otra patilla exterior del potenciómetro. El tercero va
desde la entrada analógica 2 al pin central del potenciómetro. Al girar el eje del potenciómetro,
cambiamos la cantidad de resistencia a cada lado de la escobilla que está conectado
en la patilla central del potenciómetro. Esto cambia la "cercanía" relativa de ese pin a 5 voltios y tierra,
nos da una diferente de entrada analógica. Cuando se gira el eje de todo el camino en una dirección,
hay 0 voltios que van a la estaca, y leemos 0. Cuando se gira el eje de todo el camino en la otra
dirección, hay 5 voltios que van a la clavija y que leen 1023. En entre, analogRead ( ) devuelve un
número entre 0 y 1023 que es proporcional a la cantidad de voltaje que se aplica a el pasador.
Code
/*
* AnalogInput
* by DojoDave <http://www.0j0.org>
*
* Turns on and off a light emitting diode(LED) connected to digital
* pin 13. The amount of time the LED will be on and off depends on
* the value obtained by analogRead(). In the easiest case we connect
* a potentiometer to analog pin 2.
*/
int potPin = 2; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int val = 0; // variable to store the value coming from the sensor
void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
}
void loop() {
val = analogRead(potPin); // read the value from the sensor
digitalWrite(ledPin, HIGH); // turn the ledPin on
delay(val); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
delay(val); // stop the program for some time
}

120
Fading
Muestra el uso de la salida analógica (PWM) a desvanecerse un LED.
Circuit
An LED connected to digital pin 9.
Code
int value = 0; // variable to keep the actual value
int ledpin = 9; // light connected to digital pin 9
void setup()
{
// nothing for setup
}
void loop()
{
for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
analogWrite(ledpin, value); // sets the value (range from 0 to 255)
delay(30); // waits for 30 milli seconds to see the dimming effect
}
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
analogWrite(ledpin, value);
delay(30);
}
}

121
Knock
Aquí se utiliza un elemento piezoeléctrico para detectar el sonido, lo que nos permitirá utilizarlo como
un sensor de detonación. Estamos tomando ventaja de la capacidad de los procesadores para leer
señales analógicas a través de su ADC - convertidor analógico a digital. Estos convertidores leen un
voltaje valor y transformarlo en un valor codificado digitalmente. En el caso de las placas Arduino,
transformamos el voltaje en un valor en el rango 0. 1024. 0 representa 0volts, mientras que 1024
representa 5volts en la entrada de uno de los seis pines analógicos.
Un Piezoeléctrico no es más que un dispositivo electrónico que se puede utilizar tanto para reproducir
tonos y detectar tonos. En nuestro ejemplo estamos enchufar el Piezo en la entrada número pin
analógico 0 , que es compatible con la funcionalidad de la lectura de un valor entre 0 y 5volts , y no
sólo una llanura alta o baja.
La otra cosa a recordar es que Piezos tienen polaridad, los dispositivos comerciales son por lo general
con un rojo y un cable negro indicando cómo conectarlo a la placa. Conectamos el negro a masa y el
rojo a la entrada. También tenemos que conectar una resistencia en la gama de los Megaohms en
paralelo al elemento piezoeléctrico; en el ejemplo que hemos conectado directamente
en los conectores hembra. A veces es posible adquirir elementos piezoeléctricos sin una carcasa de
plástico, entonces sólo se verá como un disco metálico y son más fáciles de usar como sensores de
entrada. El ejemplo de código capturará el golpe y si es más fuerte que un cierto umbral, se enviará la
cadena "Knock! " de nuevo al equipo a través del puerto serie. Para ver este texto puede utilizar el
monitor serie de Arduino.

122
code
/* Knock Sensor
* by DojoDave <http://www.0j0.org>
*
* Program using a Piezo element as if it was a knock sensor.
*
* We have to basically listen to an analog pin and detect
* if the signal goes over a certain threshold. It writes
* "knock" to the serial port if the Threshold is crossed,
* and toggles the LED on pin 13.
*
* http://www.arduino.cc/en/Tutorial/Knock
*/
int ledPin = 13; // led connected to control pin 13
int knockSensor = 0; // the knock sensor will be plugged at analog pin 0
byte val = 0; // variable to store the value read from the sensor pin
int statePin = LOW; // variable used to store the last LED status, to toggle the light
int THRESHOLD = 100; // threshold value to decide when the detected sound is a knock or not
void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
Serial.begin(9600); // use the serial port
}
void loop() {
val = analogRead(knockSensor); // read the sensor and store it in the variable "val"
if (val >= THRESHOLD) {
statePin = !statePin; // toggle the status of the ledPin (this trick doesn't use time cycles)
digitalWrite(ledPin, statePin); // turn the led on or off
Serial.println("Knock!"); // send the string "Knock!" back to the computer, followed by
newline
delay(10); // short delay to avoid overloading the serial port
}
}

123
Sensor de inclinación
El sensor de inclinación es un componente que puede detectar la inclinación de un objeto. Sin
embargo, es sólo el equivalente a un pulsador activado a través de un mecanismo físico diferente. Este
tipo de sensor es la versión respetuosa del medio ambiente de un switch de mercurio.
Contiene una bola metálica en el interior que se conmuten las dos clavijas del dispositivo de encendido
a apagado y viceversa si el sensor alcanza un cierto ángulo.
El ejemplo de código es exactamente como el que usaríamos para un pulsador pero sustituyendo éste
con el sensor de inclinación. Utilizamos una resistencia de pull-up (por lo tanto el uso activo de baja
para activar los pines) y conectar el sensor a un pin de entrada digital que leeremos cuando sea
necesario.
La placa de prototipo se ha rellenado con un resitor 1K para hacer el pull-up y el propio sensor.
Code
Use the Digital > Button example to read the tilt-sensor, but you'll need to make sure that the inputPin
variable in the code matches the digital pin you're using on the Arduino board.

124
Salida digital
Este es el programa básico _hola mundo_ usado simplemente para activar o desactivar algo.
En este ejemplo, un LED está conectado al pin 13, y parpadea cada segundo. La resistencia puede
omitirse en este pin ya que el Arduino tiene una integrada.

125
Entrada digital
Esta es la forma más simple de entrada con sólo dos estados posibles: ON u OFF. Este ejemplo lee un
interruptor simple o pulsador conectado al pin 2. Cuando el interruptor está cerrado el pin de entrada
leerá HIGH y activará un LED.

126
Salida PWM
La modulación de ancho de pulso (PWM) es una forma de _falsi_car_ una salida analógica por la salida
pulsante. Esto podría usarse para atenuar e iluminar un LED o posteriormente controlar un
servomotor. El siguiente ejemplo ilumina y atenúa lentamente un LED usando bucles for.

127
Generar tonos con un buzzer

/*
Programa que hace uso de un buzzer (chicharra) y un potenciómetro, la idea es generar diversos tonos en el buzzer a partir del estado
análogo del potenciómetro. Además se hace uso de la función tone que es muy útil para generar diversas
*/
//Declara puertos de entradas y salidas y variables
int buzzer = 9; //Declara Pin del buzzer
int tono = 0; //Declara Pin del potenciómetro
//Funcion principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
// No se configuran parámetros inciales, pero se debe
// colocar el encabezado de la función setup()
} Diagrama
//Funcion ciclicla
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Variable entera donde se almacena el valor del potenciómetro
int sensor = analogRead(tono);
//Variable donde se escala la frecuencia de 100 a 5000Hz
int frecuencia = map(sensor,0,1023,100,5000);
//Variable entera para guardar el tiempo deseado en ms
int duracion = 250; Esquema
//Funcion tone(), que recibe:
// 1ra posición: Pin del elemento sonoro
// 2da posición: Frecuencia deseada en Hz
// 3ra posición: Duración del tono
tone(buzzer, frecuencia, duracion);
delay(100);
//Fin programa

128
Salida de alta corriente de consumo
A veces es necesario controlar cargas de más de los 40 mA que es capaz de suministrar la tarjeta
Arduino. En este caso se hace uso de un transistor MOSFET que puede alimentar cargas de mayor
consumo de corriente. El siguiente ejemplo muestra como el transistor MOSFET conmuta 5 veces cada
segundo. El esquema muestra un motor con un diodo de protección por ser una carga inductiva.
int outPin = 5; // pin de salida para el MOSFET
void setup()
pinMode(outPin, OUTPUT); // pin5 como salida
void loop()
for (int i=0; i<=5; i++) // repetir bucle 5 veces
digitalWrite(outPin, HIGH); // activa el MOSFET
delay(250); // espera 1/4 segundo
digitalWrite(outPin, LOW); // desactiva el MOSFET
delay(250); // espera 1/4 segundo

}

129
Control de un relé.
Para empezar, una aplicación sencilla, ésta consiste en activar un relé mediante un sensor. El sensor
puede ser cualquiera que se adapte a las necesidades del proyecto. En ente caso, vamos a utilizar un
simple mini relevador de los que podemos encontrar en el comercio o si lo preferimos en multitud de
equipos que ya no nos sirven y de los cuales podemos recuperar dichos relevadores entre otros
componentes. Un relé cuya tensión de trabajo puede ser de 12V, un diodo de protección que puede
ser un 1N4148 o en su defecto un 1N4001.
Este es el circuito que necesitaría para activar un relé de 12V controlado por una salida digital del
Arduino, en él se puede ver los componentes que se utilizan habitualmente, el diodo D1, evita la
destrucción del transistor por la contra corriente producida por la inducción del relé. El esquema es
muy simple, se puede apreciar en la imagen de abajo, generada con la ayuda del programa gratuito
fritzing.

130
/*
* Pulsador.pde
*
* Autor: V. García
* Cambia estado de un relé, conectado al pin digital 13, con un transistor
* si es necesario, cuando presionas un pulsador conectado al pin 7.
* Se desconecta al liberar el pulsador.
*/
int switchPin = 2; // elige el pin 2 de entrada (para un botón)

int relePin = 8; // elige el pin 13 para el relé
int val = 0; // variable para leer el estado de pin2
void setup () {
pinMode (relePin, OUTPUT); // declara relePin como salida
digitalWrite(switchPin, HIGH); // activa la rpa al pin 2
pinMode (switchPin, INPUT); // declara el botón como entrada
}
void loop () {
val = digitalRead (switchPin); // lee valor de la entrada
if (val == HIGH) { // comprueba si la entrada es ALTA (botón libre)
digitalWrite (relePin, LOW); // si, cambia y desactiva el relé.
} else {
digitalWrite (relePin, HIGH); // no, cambia y activa el relé.
}
}

131
El potenciómetro
Como ya dije al principio, este es el momento de leer la posición de un pot. Seguramente esta
pensando, para que sirve leer la posición de un pot. Para que mediante un programa (software), lograr
mover el eje de un motor, una cantidad de grados, es una respuesta posible o igualmente controlar la
velocidad del motor. Observe la figura que sigue.
Hay infinidad de programas en la red que, muestran como hacer esto, por lo tanto, no hay necesidad
de "inventar" nada nuevo.
Los extremos del potenciómetro se conectan al +5V y a 0V. El punto central, se conecta a una entrada
analógica pin2 (pin0 - pin3), con la ayuda de un voltímetro se puede leer la tensión de salida, los
valores así obtenidos, los procesaremos y esperemos a ver los resultados obtenidos. Realmente,
hemos hecho un divisor de tensión, el programa leerá los valores de tensión de la entrada por el pin
analógico 2 conectado al terminal central del pot. El valor leído así, varía de 0 a 5.000mV y es
proporcional a la posición de mando del potenciómetro, por ese motivo debe utilizarse un pot lineal.
El valor obtenido se puede analizar a través de la conexión serie que se controlará visualmente
mediante la pantalla del monitor.

132
Aclaremos esto de los pines analógicos, estas entradas analógicas en Arduino son manejadas por un
convertidor analógico/digital de 10 bits, por lo que entregan a su salida, valores entre 0 y 1023 (2^10 -
1=1023). Así que, la tensión que entrega el pot a la entrada analógica, en la función analogRead,
variará entre 0 (cuando esté a 0V) y 1023 (cuando esté a 5V).
El programa se basa en un simple código, con el cual, una entrada analógica recibe las variaciones de
niveles de tensión que posteriormente convierte a números que podemos interpretar. Este ejemplo,
muestra cómo se desvanece un LED conectado al pin 9, no olvide utilizar la función analogWrite().
/*
* PotDimer
* ---------
*
* Uso de un potenciometro para adjustar el brillo del LED PWM's
*
* Como el máximo valor de salida del convertidor es 255, el
* valor leido del pot, tenemos que vividirlo por 4
* de esta forma podremos mostrar sus valores.
*
*/
int potPin = 2; // selec. el pin entrada del potenciómetro

int ledPin = 9; // selec el pin para el LED
int val = 0; // variable para guardar el valor leído por el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin como OUTPUT
Serial.begin(9600);
}
void loop() {
val = analogRead(potPin); // lee el valor del sensor
analogWrite(ledPin, val/4); // pone el ledPin encendido
Serial.print(val); // imprime valor del pot y vuelve al panel de
depuración
Serial.println(" ");
delay(20); // espera 20 seg
}

133
Motor DC
El motor, girará en el momento que se aplique una tensión de rango adecuado en sus bornes o
terminales. Normalmente, los motores tienen una referencia en su cuerpo que nos indica sus
características.
Qué podemos hacer.
Con la capacidad de Arduino, vemos que se pueden controlar dispositivos de bajo consumo, como los
LEDs, servos, etc. sin embargo, cuando tratamos de mayores consumos, sobre todo, con cargas con
inducciones, como un motor de corriente continua, relés, etc., por precaución, se necesita utilizar al
menos, un transistor externo.
Un transistor externo, es increíblemente útil, con él, se controla una mayor cantidad de corriente con
la pequeña aportación de la señal procedente de Arduino. Cuando a un transistor NPN, se le conecta la
carga al colector y el emisor a tierra, de modo que aplicamos a la base, la salida de Arduino del pin
elegido, podemos mover el motor que girará en proporción a la señal que le entrega el pin.

134
Controlando la velocidad.
Anteriormente, en un ejemplo, jugamos con el control de brillo de un LED mediante la modulación por
ancho de pulso (PWM), ahora, vamos a utilizar la misma característica, para controlar la velocidad de
giro de un pequeño motor. En el mundo real, vemos girar un motor de parado a máxima velocidad,
variando la tensión que aplicamos. En el mundo de la electrónica ocurre lo mismo, se pasa de 0 a 5
voltios y con la informática se hace, mediante un byte de 0 a 255.
Con Arduino, se puede utilizar algo llamado, modulación por ancho de pulso (PWM), esto se consigue,
mediante un A/D de 10bits, se basa en la capacidad de Arduino para operar muy, muy rápido. En lugar
de controlar directamente la tensión procedente del pin, Arduino cambiará el pin de encendido a
apagado muy rápidamente. Por ejemplo, si ponemos el PWM de Arduino al 50%, vemos una luz tenue,
debido a la persistencia de nuestros ojos que, no reaccionan tan rápido como para ver que parpadea,
la mitad del ciclo está apagada y la otra mitad del ciclo está encendida.
El mismo principio, servirá a nuestro propósito que, aplicando un transistor, dotará de una mayor
capacidad de carga, al pin de salida que hayamos elegido, para manejar un motor, como podemos
comprobar con el ejemplo que muestro a continuación.
// Función: motor_cc_control_pot
// Uso de un potenciómetro para controlar un motor CC
int sensor_pin = 2;
int motor_pin = 9; // un pin digital PWM output
void setup() {
Serial.begin(9600);
pinMode(motor_pin, OUTPUT);
}
void loop() {
long pot_val, motor_speed;
pot_val = analogRead( sensor_pin );
motor_speed = pot_val*255.0/1024.0; // Incluir decimales
/* Sutil: No utilice valores enteros cono 255 y 1024 aquí.

Compiladores parcos pre-calculan la division entera
del 255/1024 como cero.
*/
analogWrite( motor_pin, motor_speed);

}

135
Conclusiónes
 Arduino es un sistema, y no una placa única. Por esto, el funcionamiento concreto dependerá
del proyecto. Así, en un móvil hecho con Arduino tendremos varios microcontroladores,
encargados de las conexiones de red, los datos necesarios para la entrada de números y
mostrar información en pantalla, entre otras cosas. Así mismo, un reloj hecho con Arduino
solamente haría falta un chip que cuantifique la hora y la muestre en una pantalla.
 Como ya se ha dicho, Arduino es casi sinónimo de hardware libre, y con eso, estamos hablando
de una de las plataformas más complejas y variables que podrían existir.
 Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y
un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos
multidisciplinares
 Arduino puede detectar el medio ambiente mediante la recepción de la entrada de una

variedad de sensores y puede afectar a sus alrededores por las luces de control, motores, y
otros actuadores. El microcontrolador en la placa se programa mediante el lenguaje de
programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en
Processing). Proyectos Arduino puede ser independiente o se pueden comunicar con el
software que se ejecuta en un ordenador (por ejemplo, Flash, Processing, MaxMSP).
 Las tablas se pueden construir a mano o compradas preensamblado; el software se puede

descargar de forma gratuita. Los diseños de referencia de hardware (archivos CAD) están
disponibles bajo una licencia de código abierto, usted es libre para adaptarlos a sus
necesidades.

136
Fuentes de Información
[1] dalwiki.derechoaleer.org, «http://dalwiki.derechoaleer.org/Arduino/,» 14 Julio 2013. [En línea]. Available: http://dalwiki
[2] euskadinnova.net, «http://www.euskadinnova.net/es/innovacion-social/noticias/documental-arduino-narra-historia-ope
[3] D. Kushner, «http://spectrum.ieee.org/geek-life/hands-on/the-making-of-arduino,» 31 Julio 2011. [En línea]. Available: w
[4] www.wikipedia.com, «http://es.wikipedia.org/wiki/Arduino_de_Ivrea,» 14 Abril 2014. [En línea]. Available: http://es.wik
[5] D. Kushner, «http://spectrum.ieee.org/geek-life/hands-on/the-making-of-arduino,» 11 Julio 2011. [En línea]. Available: s
[6] [En línea]. Available: http://arduino.cc/en/Guide/Robot. [Último acceso: 20 Mayo 2014].
[7] [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardEsplora. [Último acceso: 20 Mayo 2014].
[8] [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardMegaADK. [Último acceso: 20 Mayo 2014].
[9] [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardEthernet. [Último acceso: 20 Mayo 2014].
[10 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardMega2560. [Último acceso: 20 Mayo 2014].

]
[11 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardMini. [Último acceso: 20 Mayo 2014].

]
[12 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardLilyPadUSB. [Último acceso: 20 Mayo 2014].

]
[13 [En línea]. Available: https://www.sparkfun.com/products/10274. [Último acceso: 20 Mayo 2014].

]
[14 [En línea]. Available: https://www.sparkfun.com/products/10941. [Último acceso: 20 Mayo 2014].

]
[15 [En línea]. Available: http://arduino.cc/es/Main/ArduinoBoardLilyPad. [Último acceso: 20 Mayo 2014].

]
[16 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardNano. [Último acceso: 20 Mayo 2014].

]
[17 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardProMini. [Último acceso: 20 Mayo 2014].

]
[18 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardPro. [Último acceso: 20 Mayo 2014].

]

137
[19 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardFio. [Último acceso: 20 Mayo 2014].

]
[20 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardMicro. [Último acceso: 20 Mayo 2014].

]
[21 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardDue. [Último acceso: 20 Mayo 2014].

]
[22 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardYun. [Último acceso: 20 Mayo 2014].

]
[23 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardLeonardo. [Último acceso: 20 Mayo 2014].

]
[24 [En línea]. Available: http://arduino.cc/en/Main/ArduinoBoardUno. [Último acceso: 20 Mayo 2014].

]
[25 [En línea]. Available: http://playground.arduino.cc/Main/Components. [Último acceso: 20 Mayo 2014].

]
[26 [En línea]. Available: http://arduino.cc/es/Reference/Board. [Último acceso: 20 Mayo 2014].

]
[27 Libro kit basico.

]
[28 [En línea]. Available: http://gizmologia.com/2014/03/hardware-novatos-arduino . [Último acceso: 15 Mayo 2014].

]
[29 [En línea]. Available: http://www.arduino.cc/es/ . [Último acceso: 15 Mayo 2014].

]
[30 [En línea]. Available: http://es.wikipedia.org/wiki/Arduino. [Último acceso: 16 Nayo 2014].

]
[31 [En línea]. Available: http://createdigitalmusic.com/2008/08/arduinome-an-arduino-based-monome-clone-behind-the-sc

]
[32 [En línea]. Available: http://hispavila.com/3ds/atmega/introduino.html. [Último acceso: 20 Mayo 2014].

]
http://www.jameco.com/webapp/wcs/stores/servlet/StoreCatalogDrillDownView?rf=1&history=o26o519s%7C
33 e~15%5Epage~SEARCH%252BNAV%40w6jjp4rc%7Cposition~31%5Erf~1%5Erefine~1%5EprodPage~15%5Epage

138
2BNAV&position=31&refine=1&langId=-1&catalogId=10001&storeId=10001
[34 M. Electronics, «http://mx.mouser.com/Search/Refine.aspx?Keyword=ARDUINO,» 21 05 2014. [En línea].

]
Documentos consultados
 Guía de usuario Arduino, Rafael Henríquez Herrador, 13 de noviembre 2009 (20/05/14 – 23: 04 hrs)
 Guia basica de Arduino, Tienda de robotica (20/05/14 – 23:21)
 Manual de Programación Arduino, Arduino Notebook: A Beginner’s Reference Written and compiled by
Brian W. Evans (20/0514 – 23: 38 hrs)
 Including material written by:
Massimo Banzi
Hernando Barragin
David Cuartielles
Tom Igoe
Todd Kurt
David Mellis

Arduino

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arduino

Uploaded by

Copyright:

Available Formats

i

INSTITUTO TECNOLOGICO DE MEXICALI

Nombre del alumno:

García Balderrama Isaac Daniel 10490578

Hernández Cervantes Roberto 11490032

Luna Álvarez Juan Manuel 10490597

Morales García Miguel Ángel 10490603

Ortega Garzón Francisco 10490606

Viveros Macias Raúl Iván 11490247

Nombre del Instructor:

Fecha: Mexicali B.C. a 26 de Mayo de 2014

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

ARDUINO ANTECEDENTES ................................................................................................................. 1

ARDUINO ANTECEDENTES ................................................................................................................. 2

TIPOS DE ARDUINO ........................................................................................................................... 8

ARDUINO UNO ............................................................................................................................................. 8

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

DISPOSITIVOS ALTERNOS COMPATIBLES CON ARDUINO .................................................................. 35

JAMECO ELECTRONICS ................................................................................................................................. 35

COMPONENTES DEL ARDUINO ........................................................................................................ 66

EXPANSIONES DE ARDUINO CON SHIELD ......................................................................................... 72

FUENTE DE ALIMENTACIÓN ............................................................................................................. 80

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

MODULO ARDUINO ........................................................................................................................ 86

PROGRAMACIÓN DE ARDUINO ....................................................................................................... 87

ESTRUCTURA DEL PROGRAMA ....................................................................................................................... 87

TIPOS DE DATOS ............................................................................................................................. 92

ASIGNACIONES COMPUESTAS ........................................................................................................................ 95

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

CIERTO/FALSO (TRUE/FALSE) ........................................................................................................................ 96

CONTROL DE FLUJO ......................................................................................................................... 97

IF… ELSE (SI….. SINO ..) ............................................................................................................................... 98

WHILE ................................................................................................................................................... 100

E/S DIGITALES ............................................................................................................................... 101

PINMODE(PIN, MODE) .............................................................................................................................. 101

DIGITALREAD(PIN) .................................................................................................................................... 102

DIGITALWRITE(PIN, VALUE) ........................................................................................................................ 102

ANALOGREAD(PIN) ................................................................................................................................... 103

ANALOGWRITE(PIN, VALUE) ....................................................................................................................... 103

TIEMPO ........................................................................................................................................ 104

DELAY(MS) .............................................................................................................................................. 104

MILLIS() .................................................................................................................................................. 104

MATEMÁTICAS ............................................................................................................................. 105

MIN(X, Y) ................................................................................................................................................ 105

MAX(X, Y) ............................................................................................................................................... 105

ALEATORIO ................................................................................................................................... 105

RANDOMSEED(SEED) ................................................................................................................................ 105

RANDOM(MIN, MAX) ................................................................................................................................ 106

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

PUERTO SERIE ............................................................................................................................... 106

SERIAL.BEGIN(RATE) ................................................................................................................................. 106

BIBLIOTECAS ARDUINO ................................................................................................................. 111

APLICACIONES DE ARDUINO ......................................................................................................... 116

BLINK WITHOUT DELAY ............................................................................................................................. 116

CONCLUSIÓNES ............................................................................................................................. 135

FUENTES DE INFORMACIÓN .......................................................................................................... 136

DOCUMENTOS CONSULTADOS..................................................................................................................................... 138

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

Ilustración 1 Meccano by Frank Hornby

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali

Ilustración 2. Massimo Banzi forma parte del equipo Arduino

Interfaces y Redes Industriales Instituto Tecnológico de Mexicali