Date post: | 26-Dec-2015 |
Category: |
Documents |
Upload: | jorge-roberto |
View: | 84 times |
Download: | 1 times |
UNIVERSIDAD DE SAN CARLOS DE GUATEMALA
FACULTAD DE INGENIERIA
ESCUELA DE CIENCIAS Y SISTEMAS
ARQUITECTURA DE COMPUTADORES Y ENSAMBLADORES 1
Portada
INTRODUCCION Y TUTORIAL
ARDUINO
JORGE ROBERTO GODINEZ BARRIOS
201020588
09/16/2014
Ley de Derecho de Autor y Derechos Conexos de Guatemala (documento) La Ley de derecho de Autor y Derechos Conexos de Guatemala (documento) es una ley que tiene por
objeto la protección de los derechos de los autores de obras literarias y artísticas, de los artistas
intérpretes o ejecutantes, de los productores de fonogramas y de los organismos de radiodifusión. Todo
ello de acuerdo al Decreto 33-1998 del Congreso de la República de Guatemala.
- See more at:
http://wikiguate.com.gt/wiki/Ley_de_Derecho_de_Autor_y_Derechos_Conexos_de_Guatemala_(docu
mento)#sthash.P2VIjAIv.dpuf
Este documento ha sido una recopilacion de varias Fuentes sobre ARDUINO, y toda la informacion aqui
presentada son propias del autor. Como también de las fuentes en donde fueron tomadas, en las que se
hizo referencia durante el desarrollo de este documento.
PREFACIO Esta guía de usuario intenta ser una forma de acercarse al diseño y desarrollo de proyectos basados en
Arduino para aquellas personas que nunca han trabajado con él pero que poseen un buen nivel en
programación y electrónica. Por esta razón y para hacerlo fácil, se ha excluido mucha información
existente en Internet y otros manuales para centrarse en los aspectos más básicos de las características
y la programación de Arduino.
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 se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a
software del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). Las placas
se pueden montar a mano o adquirirse. El entorno de desarrollo integrado libre se puede descargar
gratuitamente.
Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, puede utilizarse
libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.
Este document ha sido desarrollado con el fin de ayudar aquellas personas que estan introduciendo sus
conocimientos en la implementacion de arduino.
http://arduino.cc/
http://es.wikipedia.org/wiki/Arduino
http://mymemory.translated.net/t/Italian/English/arduino-tutorial%3A
INDICE Portada .......................................................................................................................................................... 1
Ley de Derecho de Autor y Derechos Conexos de Guatemala (documento) ............................................... 2
PREFACIO ...................................................................................................................................................... 2
INDICE ........................................................................................................................................................... 3
INTRODUCCION ............................................................................................................................................. 6
¿Qué es Arduino? ...................................................................................................................................... 6
¿Por qué Arduino? .................................................................................................................................... 6
http://arduino.cc/en/pmwiki.php?n=Guide/Introduction ....................................................................... 7
OBJETIVOS ..................................................................................................................................................... 7
INSTALACION Y CONFIGURACION ................................................................................................................. 8
1. DESCARGA: ........................................................................................................................................ 8
2. INSTALACION .................................................................................................................................... 9
TIPOS ARDUINO .......................................................................................................................................... 11
ARDUINO UNO: ............................................................................................................................... 11
ARDUINO LEONARDO: ............................................................................................................................ 13
ARDUINO DUE ......................................................................................................................................... 16
ARDUINO YUN ......................................................................................................................................... 19
ARDUINO ROBOT .................................................................................................................................... 21
ARDUINO BOTTOM ROBOT ..................................................................................................................... 24
ARDUINO ESPLORA ................................................................................................................................. 26
ARDUINO MEGA ADK .............................................................................................................................. 28
ARDUINO ETHERNET ............................................................................................................................... 29
ARDUINO MEGA 2560 ............................................................................................................................. 32
ARDUINO MINI ........................................................................................................................................ 35
ARDUINO NANO ...................................................................................................................................... 36
ARDUINO PRO MINI ................................................................................................................................ 37
ARDUINO PRO ......................................................................................................................................... 38
ARDUINO MICRO .................................................................................................................................... 40
ARDUINO FIO .......................................................................................................................................... 41
ARDUINO LILY PAD USB .......................................................................................................................... 42
ARDUINO LILY PAD SIMPLE ..................................................................................................................... 43
LENGUAJE DE PROGRAMACION ARDUINO ................................................................................................. 44
Estructuras ...................................................................................................................................... 44
Variables.......................................................................................................................................... 44
Operadores matemáticos, lógicos y booleanos .............................................................................. 44
Estructuras de control (Condicionales y ciclos) .............................................................................. 44
Funciones ................................................................................................................................ 44
ESTRUCTURA DE UN PROGRAMA DESARROLLADO PARA ARDUINO .......................................................... 45
setup() ..................................................................................................................................................... 45
loop() ....................................................................................................................................................... 46
funciones ................................................................................................................................................. 46
Comentarios Multilinea .......................................................................................................................... 47
Comentarios Simples .............................................................................................................................. 47
Variables ................................................................................................................................................. 47
CONSTANTES ........................................................................................................................................... 48
Tipos De Datos ........................................................................................................................................ 48
byte ..................................................................................................................................................... 48
int ........................................................................................................................................................ 48
long ..................................................................................................................................................... 49
float ..................................................................................................................................................... 49
arrays................................................................................................................................................... 49
OPERADORES .......................................................................................................................................... 51
Sentencias condicionales ........................................................................................................................ 52
if (si condicional) ................................................................................................................................. 52
if… else (si….. sino ..) ........................................................................................................................... 52
for ........................................................................................................................................................ 53
while .................................................................................................................................................... 54
do… while ............................................................................................................................................ 55
Entradas y salidas digitales y analógicas ................................................................................................. 56
Función pinMode(pin, mode) ............................................................................................................. 56
Función digitalRead(pin) ..................................................................................................................... 56
Funcion digitalWrite(pin, value) ......................................................................................................... 56
Función analogRead(pin) .................................................................................................................... 56
Función analogWrite(pin, value) ......................................................................................................... 56
Funciones de tiempo ........................................................................................................................... 56
delay(ms) ......................................................................................................................................... 56
millis() .............................................................................................................................................. 56
min(x,y). max(x,y). ........................................................................................................................... 56
Funciones de generación aleatoria ..................................................................................................... 57
randomSeed(seed). ......................................................................................................................... 57
random(max), random(min, max). ................................................................................................. 57
COMUNICACIÓN SERIAL.......................................................................................................................... 57
BEGIN() ................................................................................................................................................ 58
END() ................................................................................................................................................... 59
AVAILABLE() ........................................................................................................................................ 59
READ() ................................................................................................................................................. 60
FLUSH() ................................................................................................................................................ 61
PRINT() ................................................................................................................................................ 61
PRINTL() ............................................................................................................................................... 63
WRITE() ............................................................................................................................................... 64
PROBLEMAS COMUNES .............................................................................................................................. 65
INSTALACION DE DRIVERS ...................................................................................................................... 65
CONCLUSIONES ........................................................................................................................................... 70
BIBLIOGRAFIA .............................................................................................................................................. 70
INTRODUCCION
¿Qué es Arduino?
Arduino es una herramienta para la toma de computadoras que pueden detectar y controlar más del
mundo físico que el equipo de escritorio. Es una plataforma de computación física de código abierto
basado en una placa electronica simple, y un entorno de desarrollo para escribir software para la placa.
Arduino se puede utilizar para desarrollar objetos interactivos, teniendo las entradas de una variedad de
interruptores o sensores, y el control de una variedad de luces, motores y otras salidas físicas. Proyectos
de Arduino pueden ser autónomos, o pueden comunicarse con el software que se ejecuta en el
ordenador (por ejemplo, Flash, Processing,MaxMSP.) Las tablas se pueden montar a mano o comprados
preensamblado; el IDE de código abierto se puede descargar de forma gratuita.
El lenguaje de programación Arduino es una implementación de cableado, una plataforma similar
computación física, que se basa en el entorno de programación multimedia de procesamiento.
¿Por qué Arduino?
Hay muchos otros microcontroladores y plataformas de microcontroladores disponibles para la
computación física.Parallax Basic Stamp, de Netmedia BX-24, Phidgets, Handyboard del MIT, y muchos
otros ofrecen una funcionalidad similar. Todas estas herramientas toman los detalles sucios de
programación de microcontroladores y se envuelve en un paquete fácil de usar. Arduino también
simplifica el proceso de trabajar con los microcontroladores, pero ofrece algunas ventajas para los
profesores, estudiantes y aficionados interesados sobre otros sistemas:
Asequible - placas Arduino son relativamente baratos en comparación con otras plataformas de
microcontroladores. La versión menos costosa del módulo Arduino puede ser montada a mano, e
incluso los módulos de Arduino premontados cuestan menos de $ 50
Multiplataforma - El software de Arduino funciona en sistemas operativos Windows, Macintosh OSX y
Linux. La mayoría de los sistemas de microcontroladores están limitados a Windows.
Entorno de programación simple, clara - El entorno de programación de Arduino es suficiente para los
usuarios avanzados que aprovechan así de fácil uso para los principiantes, pero flexible. Para los
profesores, se basa convenientemente en el entorno de programación Processing, por lo que los
estudiantes aprenden a programar en ese entorno estarán familiarizados con la apariencia de Arduino
El código abierto y extensible en software El software de Arduino se publica como herramientas de
código abierto, disponible para la extensión por programadores experimentados. El lenguaje puede
ampliarse a través de librerías C ++, y la gente con ganas de entender los detalles técnicos pueden dar el
salto de Arduino para el lenguaje de programación AVR C en la que se basa. Del mismo modo, puede
agregar código AVR-C directamente en sus programas de Arduino si quieres.
El código abierto y el hardware extensible - El Arduino se basa en de
Atmel ATMEGA8 y ATmega168 microcontroladores. Los planes para los módulos están publicados bajo
una licencia de Creative Commons, por lo que los diseñadores de circuitos con experiencia pueden hacer
su propia versión del módulo, ampliándolo y mejorándolo. Incluso los usuarios con poca experiencia
pueden construir la versión tablero del módulo con el fin de entender cómo funciona y ahorrar dinero.
http://arduino.cc/en/pmwiki.php?n=Guide/Introduction
http://arduino.cc/en/Main/Software
http://arduino.cc/en/pmwiki.php?n=Guide/Introduction#
http://arduino.cc/en/Reference/HomePage
OBJETIVOS Conocer el funcionamiento de las cosas es algo que nos hemos planteado desde el inicio de los tiempos;
hoy en día nos enfrentamos a una realidad donde abundan la automatización, la domótica
(automatización de las casas y edificios), la interacción de las personas con las máquinas, la electrónica,
la mecánica y la programación.
Conocer el funcionamiento de las cosas es algo que nos hemos planteado desde el inicio de los tiempos;
hoy en día nos enfrentamos a una realidad donde abundan la automatización, la domótica
automatización de las casas y edificios), la interacción de las personas con las máquinas, la electrónica,
la mecánica y la programación.
El propósito de esta guía es abordar el concepto de computación física que es la capacidad de
interacción y comunicación de una máquina con los humanos, usando sensores y actuadores. Las
decisiones de esto las va a tomar un microcontrolador que se encuentra ubicado en la placa Arduino. La
tarjeta Arduino es el corazón de la presente guía.
Conocer la plataforma Arduino como una herramienta para la experimentación de domótica mediante
el diseño de dispositivos digitales interactivos. Aprender los conceptos básicos de programación y
electrónica necesarios para el desarrollo de aplicaciones y dispositivos interactivos simples.
INSTALACION Y CONFIGURACION 1. DESCARGA:
Inicialmente necesitaremos visitor la pagina official de ARDUINO para proceder a descargar el
IDE oficial para poder desarrollar el código que necesitaremos implementar para el uso de
nuestro hardware. La pagina oficial del sitio es www.arduino.cc o podremos encontrar la pagina
mediante un buscador web.
En la pagina oficial podremos encontrar información sobre ARDUINO, y nos ubucaremos en la
pestana de descarga de la aplicación para poder obtener el IDE oficial. En esta pestana
encontraremos las versiones disponibles para el IDE de ARDUINO. Será en base a nuestra
conveniencia el que queramos descargar, preferiblemente es descargar una versión estable del
IDE.
En esta caso procederemos a descargar la versión ARDUINO IDE 1.0.5, que es una versión
estable de este IDE.
2. INSTALACION
Esta plataforma esta disponible tanto para Windows,Linux como para MacOS. Por lo que este
software esta creado para varios sistemas, de esta manera no tendremos ningún problema en el
poder implementar nuestro código para nuestra hardware ARDUINO.
Descargamos el instalador para Windows que es en este caso. Y procedemos a instalar el IDE.
Aceptamos los términos y políticas. Luego empezamos la instalación del software.
Seleccionamos e instalamos todos los componentes necesarios para para que el software y la
conexión con nuestro hardware ARDUINO funcionen correctamente.
Seleccionamos la ubicación donde será instalado el software y esperamos a que termine el
progreso de instalación.
Cuando el proceso de instalación haya concluido podremos cerrar la ventana.
Ahora ya podremos ejecutar el software mediante el acceso directo creado automáticamente en
el escritorio o buscando el software en el bloque de programas instalados.
Y la ventana principal del software es la siguiente, en esta ventana ya podremos crear o editar
proyectos de ARDUINO, y poder hacer pruebas.
Mas adelante veremos el uso y estructura del lenguaje ARDUINO , como también la manera de
implementarlo en nuestro hardware.
TIPOS ARDUINO
ARDUINO UNO:
El Arduino Uno es una placa electronica basada en el ATmega328 .Cuenta con 14 pines digitales
de entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 6 entradas analógicas,
un 16 MHz resonador cerámico, una conexión USB, un conector de alimentación, un header
ICSP, y un botón de reinicio. Contiene todo lo necesario para apoyar el microcontrolador; basta
con conectarlo a un ordenador con un cable USB o el poder con un adaptador o la batería AC-to-
DC para empezar.
El Uno se diferencia de todas las demás placas en que no utiliza el chip controlador de USB a
serial FTDI. En lugar de ello, cuenta con la Atmega16U2 ( Atmega8U2 hasta la versión R2)
programado como un convertidor de USB a serie.
Consultado en: http://arduino.cc/en/Main/arduinoBoardUno
La placa arduino tiene la siguiente apariencia:
Arduino uno R3 Frontal Arduino uno R3 Atrás.
A continuacion se mostrara las partes de ARDUINO UNO.
Empezando según las agujas del reloj:
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) - Estos pines no se pueden utilizar
como e/s digitales (digitalRead() y digitalWrite()) si estás utilizando comunicación 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)
Consultado en: http://www.menosmedia.org/spip.php?article43
CARACTERISTICAS PRINCIPALES ARDUINO UNO
Microcontrolador: ATmega328
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 6
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados por el bootloader
SRAM: 2 KB (ATmega328)
EEPROM: 1 KB (ATmega328)
Velocidad de reloj: 16 MHz
ARDUINO LEONARDO:
El Arduino Leonardo es una placa electronica basada en el ATMEGA32U4. Tiene 20 pines digitales de
entrada / salida (de los cuales 7 puede utilizarse para salidas PWM y 12 entradas como analógicas), un
16 MHz oscilador de cristal, una conexión micro USB, un conector de alimentación, un header ICSP, y un
botón de reinicio. Contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a
un ordenador con un cable USB o el poder con un adaptador o la batería AC-to-DC para empezar.
El Leonardo difiere de todas las placas anteriores en que el ATMEGA32U4 ha incorporado en la
comunicación USB, eliminando la necesidad de un procesador secundario. Esto permite que el Leonardo
aparezca a una computadora conectada como un ratón y el teclado, además de una virtual (CDC) de
puerto serie / COM. También tiene otras implicaciones para el comportamiento de la placa.
Consultado en : http://arduino.cc/en/Main/arduinoBoardLeonardo
La placa ARDUINO LEONARDO tiene la siguiente apariencia:
Arduino Leonardo Frontal Arduino Leonardo Atrás
Arduino Leonardo Frontal sin adaptadores para pines
A continuación se presentan las partes de ARDUINO LEONARDO
Consultado en : http://makezine.com/2014/03/24/skill-builder-arduino-101-arduinod14/
CARACTERISTICAS PRINCIPALES ARDUINO LEONARDO:
Microcontrolador: ATmega32u4
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 20
Canales PWM: 7
Pines de entradas análogas: 12
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader
SRAM: 2 KB (ATmega32u4)
EEPROM: 1 KB (ATmega32u4)
Velocidad de reloj: 16 MHz
ARDUINO DUE
El Arduino Due es una placa electronica basada en el Atmel SAM3X8E ARM Cortex-M3 CPU. Es la
primera placa Arduino basado en un microcontrolador núcleo ARM de 32 bits. Cuenta con 54 pines
digitales de entrada / salida (de los cuales 12 pueden utilizarse para salidas PWM), 12 entradas
analógicas, 4 UARTs (puertas seriales), un 84 MHz de reloj, una conexión capaz USB OTG, 2 DAC (de
digital a analógico) , 2 TWI, un conector de alimentación, una cabecera de SPI, un encabezado JTAG, un
botón de reinicio y un botón de borrado.
Advertencia : A diferencia de otras placas Arduino, la placa Arduino Debido funciona a 3.3V. El voltaje
máximo que los pines de E / S pueden tolerar es 3.3V. Proporcionar voltajes más altos, como 5V a un pin
de I / O podría dañar la placa .
La placa contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a un
ordenador con un cable micro-USB o el poder con un adaptador o la batería AC-to-DC para empezar. El
Due es compatible con todos los escudos de Arduino que trabajan a 3.3V y cumplan con el 1,0 Arduino
pinout.
El Due sigue el pinout 1.0:
TWI: SDA y SCL pasadores que están cerca al pin AREF.
El pasador de instrucción IOREF que permite un blindaje conectado con la configuración adecuada para
adaptarse a la tensión proporcionada por la junta. Esto permite la compatibilidad escudo con un tablero
de 3.3V como las tarjetas basadas en AVR Due y que operan a 5V.
Un pin sin conectar, reservado para un uso futuro.
Beneficios del nucleo ARM
Arduino Due tiene un núcleo ARM de 32 bits que puede superar las juntas típicas de microcontroladores
de 8 bits. Las diferencias más significativas son:
Un núcleo de 32 bits, que permite operaciones en 4 bytes de datos de ancho dentro de un único
reloj de la CPU.
Reloj del CPU en 84Mhz.
96 Kbytes de SRAM.
512 Kbytes de memoria flash para el código.
un controlador de DMA, que puede aliviar la CPU de hacer tareas 16ntensives de memoria.
La apariencia de Arduino Due es la siguiente:
Arduino Due Frontal
Arduino Due Atrás
Consultado en: http://arduino.cc/en/Main/arduinoBoardDue
A continuación se presentan las partes de ARDUINO DUE
Consultado en: http://tronixlabs.com/arduino/boards/due/freetronics-etherdue-arduino-due-
compatible-with-ethernet/
CARACTERISTICAS PRINCIPALES ARDUINO DUE
Microcontrolador: AT91SAM3X8E
Voltaje de funcionamiento: 3.3 V
Pines I/O digitales: 54 (de los cuales 12 proveen salida PWM)
Pines de entradas análogas: 12
Corriente DC total en todos los pines I/O: 130 mA
Corriente DC en el pin de 5 V: 800 mA
Corriente DC en el pin de 3.3 V: 800 mA
Memoria Flash: 512 KB disponibles para las aplicaciones de usuario.
SRAM: 96 KB (dos bancos: 64KB Y 32 KB)
Velocidad de reloj: 84 MHz
ARDUINO YUN
El Arduino Yun es una placa electronica basada en el ATMEGA32U4 ( ficha técnica ) y el
Atheros AR9331 . El procesador Atheros es compatible con una distribución Linux basada
en OpenWrt llamado OpenWrt -Yun. La junta ha incorporado Ethernet y WiFi apoyo, un puerto USB-A,
ranura para tarjeta micro-SD, 20 entradas digitales / pines de salida (de los cuales 7 puede utilizarse para
salidas PWM y 12 como entradas analógicas), un 16 MHz cristal oscilador, una conexión micro USB, una
cabecera ICSP, y un 3 botones de reposición.
El Yun se distingue de otras placas Arduino en que se puede comunicar con la distribución de Linux a
bordo, que ofrece un sistema de red de gran alcance con la facilidad de Arduino. Además de los
comandos de Linux como cURL, usted puede escribir sus propias conchas y python scripts para las
interacciones fuertes.
El Yun es similar a la Leonardo en que el ATMEGA32U4 se ha incorporado en la comunicación USB,
eliminando la necesidad de un procesador secundario. Esto permite que el yun aparezca a una
computadora conectada como un ratón y el teclado, además de una virtual (CDC) de puerto serie /
COM.
La apariencia de Arduino Yun es la siguiente:
Arduino Yun Frontal Arduino Yun Atrás
Las partes de Arduino Yun son las siguientes:
Las características principales de Arduino Yun Son las siguientes:
Microcontrolador AVR Arduino: ATmega32u4
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 20
Canales PWM: 7
Pines de entradas análogas: 12
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 32 KB (de los cuales 4 KB son utilizados por el bootloader
SRAM: 2.5 KB
EEPROM: 1 KB
Velocidad de reloj: 16 MHz
Procesador Linux: Atheros AR9331
Arquitectura: MIPS @400MHz
Ethernet: IEEE 802.3 10/100Mbit/s
WiFi: IEEE 802.11b/g/n
USB Tipo A: 2.0
Lector de tarjeta: sólo Micro-SD
RAM: 64 MB DDR2
Memoria Flash:16 MB
Consultado en : http://arduino.cc/en/Main/ArduinoBoardYun?from=Products.ArduinoYUN
ARDUINO ROBOT
El Arduino Robot es el primer Arduino oficial sobre ruedas. El robot tiene dos procesadores, uno en cada
uno de sus dos tableros. La Junta de motor controla los motores y la Junta de Control lee sensores y
decide cómo operar. Cada uno de los tableros es un programable completo placa Arduino utilizando el
Arduino IDE.
Ambos tableros control y motor se tableros de microcontroladores basados en el ATMEGA32U4. El
robot tiene muchas de sus pines asignadas a los sensores y actuadores de a bordo.
Programación del robot es similar al proceso con el Arduino Leonardo. Ambos procesadores han
incorporado en la comunicación USB, eliminando la necesidad de un procesador secundario. Esto
permite que el robot que aparezca a un ordenador conectado como virtual (CDC) de puerto serie / COM.
Como siempre con Arduino, todos los elementos de la plataforma - hardware, software y
documentación - es de libre acceso y de fuente abierta.
La apariencia de ARDUINO Robot es la Siguiente:
Arduino Robot Top
Arduino Bottom Robot
Las Caracteristicas Principales de cada versión de Arduino Robot Son las Siguientes:
Arduino Robot Top
Caracteristicas:
Microcontrolador: ATMEGA32U4
Voltaje de Funcionamiento: 5V
Voltaje de entrada: 5V
Pines Digitales I/O: 5
Canales PWM: 6
Canales de Entrada Analogica: 4(pines I/O digitales)
Canales Analogicos Multiplexados: 8
Corriente DC por Pin I/O: 40mA
Memoria Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque
SRAM: 2,5 KB ( ATMEGA32U4 )
EEPROM (interna): 1 KB ( ATMEGA32U4 )
EEPROM (externa): 512 Kbit ( I2C )
Velocidad del Reloj: 16MHz
Teclado: 5 Teclas
Perilla: potenciómetro adjunto al pin analógico
LCD colores: Comunicación SPI
Lector de Tarjetas: Formato FAT16
Altavoz: 8 Ohm
Brujula digital: proporciona la desviación desde el norte geográfico en grados
I2C puertos de soldadura: 3
Áreas de prototipos: 4
Las partes de ARDUINO ROBOT TOP:
ARDUINO BOTTOM ROBOT
Las características principales de Arduino Bottom Robot son las Siguientes:
Microcontrolador: ATMEGA32U4
Voltaje de funcionamiento: 5V
Voltaje de entrada: 9V para el cargador de batería
Ranura de la batería AA: 4 alcalinas o NiMH baterías recargables
Digital pines I / O: 4
Canales PWM: 1
Pines de entrada analógica: 4 (de los pines I/O digitales)
Corriente DC por pin I/O: 40 mA
Convertidor DC-DC: genera 5V para alimentar todo el robot
Memoria Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque
SRAM: 2,5 KB ( ATMEGA32U4 )
EEPROM: 1 KB ( ATMEGA32U4 )
Velocidad del Reloj: 16 MHz
Trimmer: Para calibracion de movimiento.
Línea de IR sensors: 5
I2C puertos de soldadura: 1
Áreas de prototipos: 2
Las partes de ARDUINO BOTTOM ROBOT son las siguientes:
Arduino Bottom Robot Frontal
Arduino Bottom Robot Atrás
Consultado en : http://arduino.cc/en/Main/Robot
ARDUINO ESPLORA
El Arduino Esplora es una placa electronica derivado de la Arduino Leonardo . El Esplora difiere de todas
las placas Arduino precedentes, ya que proporciona una serie de integrado, conjunto de sensores de a
bordo para la interacción lista para su uso. Está diseñado para las personas que quieren poner en
marcha con Arduino sin tener que aprender acerca de la electrónica de primera.
El Esplora tiene a bordo de luz y sonido, y varias salidas de los sensores de entrada, incluyendo un
joystick, 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 dos conectores de entrada y salida
TINKERKIT, y una toma para una pantalla LCD TFT a color.
Al igual que el tablero de Leonardo, el Esplora utiliza un ATMEGA32U4 microcontrolador AVR 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 del tablero hay un pulsador de rearme, que puede utilizar para reiniciar
el tablero. Hay cuatro LEDS de estado:
ON [verde] indica si la junta está recibiendo alimentación
L [amarilla] conectado directamente al microcontrolador, accesible a través del pasador 13
RX y TX [amarilla] indica que los datos sean transmitidos o recibidos a través de la comunicación USB
La placa contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a un
ordenador con un cable USB para empezar.
El Esplora ha incorporado en la comunicación USB; puede aparecer en un equipo conectado como un
ratón o el teclado, además de una virtual (CDC) de puerto serie / COM.
La apariencia de ARDUINO SPLORA es la siguiente:
Arduino Splora Frontal
Arduino Splora Atrás
Las partes de Arduino Splora se muestran en la siguiente Imagen:
Las Caracteristicas Principales de Arduino Splora son las Siguientes:
Microcontrolador: ATmega32u4
Voltaje de funcionamiento: 5 V
Memoria Flash: 32 KB de los cuales 4 KB son utilizados por el bootloader
SRAM: 2.5 KB
EEPROM: 1 KB
Velocidad de reloj: 16 MHz
4 Push bottons
Joystick análoga con un push botton central
Potenciómetro lineal
Micrófono
Fotorresistor
Sensor de temperatura
Acelerómetro de 3 ejes
Buzzer
Led RGB
Conector para LCD
Consultado en : http://arduino.cc/en/Main/arduinoBoardEsplora
ARDUINO MEGA ADK
El MEGA Arduino ADK es una placa electronica basada en el Atmega2560. Cuenta con una interfaz de
host USB para conectar con los teléfonos basados en Android, basado en el MAX3421E IC. Cuenta con 54
pines digitales de entrada / salida (de los cuales 15 se pueden utilizar como salidas PWM), 16 entradas
analógicas, 4 UARTs (puertas seriales), un 16 MHz del oscilador de cristal, una conexión USB, un
conector de alimentación, un header ICSP, y un botón de reinicio.
El MEGA ADK se basa en la Mega 2560 .
Similar a la Mega 2560 y Uno, cuenta con una ATmega8U2 programado como un convertidor de USB a
serie.
Revisión 2 de la junta ADK Mega tiene una resistencia tirando de la línea 8U2 HWB a tierra, por lo que es
más fácil de poner en modo DFU .
Revisión 3 de la Junta tiene las siguientes características nuevas:
pinout: SDA añadido y pines SCL que están cerca al pin AREF y otros dos nuevos pernos
colocados cerca del pin de RESET, la instrucción IOREF que permiten a los escudos para
adaptarse al voltaje suministrado desde la pizarra. En el futuro, los escudos serán compatibles
tanto con la placa que utilice el AVR, que operan con 5V y con el Arduino Debido que operan con
3.3V. El segundo es un pin no está conectado, que se reserva para usos futuros.
Circuito de reinicio fuerte.
La apariencia de ARDUINO MEGA ADK es:
Arduino Mega ADK R3 Frontal
Las características principales de este hardware son:
Microcontrolador: ATmega2560
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 54 (de los cuales 15 proveen salida PWM)
Pines de entradas análogas: 16
Corriente DC por cada pin I/O: 40 mA
Corriente DCen el pin de 3.3 V: 50 mA
Memoria Flash: 256 KB de los cuales 8 KB son utilizados por el bootloader
SRAM: 8 KB
EEPROM: 4 KB
Velocidad de reloj: 16 MHz
Consultado en: http://arduino.cc/en/Main/ArduinoBoardMegaADK?from=Main.ArduinoBoardADK
ARDUINO ETHERNET
La Arduino Ethernet es una placa electronica basada en el ATmega328. Cuenta con 14 pines digitales de
entrada / salida, 6 entradas analógicas, un 16 MHz oscilador de cristal, un RJ45 de conexión, un conector
de alimentación, un header ICSP, y un botón de reinicio.
NB: Los contactos 10, 11, 12 y 13 están reservados para la interfaz con el módulo Ethernet y no debe ser
utilizado de otra manera. Esto reduce el número de pines disponibles a 9, con 4 disponibles como salidas
PWM.
Una alimentación opcional en el módulo Ethernet se puede agregar a la tarjeta también.
La Ethernet se diferencia de otras placas, ya que no tiene un chip integrado controlador de USB a serie,
pero tiene una interfaz Wiznet Ethernet. Esta es la misma interfaz que se encuentra en el escudo
Ethernet.
Un lector de tarjetas microSD a bordo, que se puede utilizar para almacenar archivos para servir a través
de la red, es accesible a través de la Biblioteca SD. Pin 10 se reserva para la interfaz Wiznet, SS para la
tarjeta SD está en el pin 4.
La cabecera de la programación serial de 6 pines es compatible con la serie USB adaptador y también
con los cables USB FTDI o con Sparkfun y tableros Adafruit estilo FTDI básicos de USB a serial de
ruptura. Cuenta con soporte para rearme automático, permitiendo bocetos que se cargan sin necesidad
de pulsar el botón de reinicio en el tablero. Cuando se conecta a un adaptador USB a serie, el Arduino
Ethernet es alimentado desde el adaptador.
El Revisión 3 de la junta directiva introduce los 1,0 pinout estandarizados, que consisten en:
SDA añadido y pines SCL que están cerca de la pin AREF y otros dos nuevos pernos colocados
cerca del pin de RESET, esto será la oportunidad de escudo que I2C uso o componentes de
inmersión recíproca para ser compatible con todas las placas Arduino;
la instrucción IOREF que permita que los escudos para adaptarse al voltaje suministrado desde
la pizarra. Los escudos que utilizan el pin instrucción IOREF serán compatibles tanto con la placa
que utilizan el AVR, que operan con 5V y con el Arduino Debido que operan con 3.3V. Junto al
pin instrucción IOREF hay un pin no está conectado, que se reserva para usos futuros.
La apariencia de ARDUINO ETHERNET es la siguiente:
Arduino Ethernet R3 Frontal
Arduino Ethernet R3 Atrás
Las características principales de Arduino Ethernet son las siguientes:
Microcontrolador: ATmega328
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 14 (de los cuales 4 proveen salida PWM)
Pines de entradas análogas: 6
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados por el bootloader
SRAM: 2 KB (ATmega328)
EEPROM: 1 KB (ATmega328)
Velocidad de reloj: 16 MHz
Controlador embebido Ethernet W5100 TCP/IP
Tarjeta MicroSD, con adaptadores activos de voltaje
Consultado en: http://arduino.cc/en/Main/ArduinoBoardEthernet
ARDUINO MEGA 2560
El Arduino Mega 2560 es una placa electronica basada en el Atmega2560 . Cuenta con 54 pines digitales
de entrada / salida (de los cuales 15 se pueden utilizar como salidas PWM), 16 entradas analógicas,
4 UARTs (puertas seriales), un 16 MHz del oscilador de cristal, una conexión USB, un conector de
alimentación, un header ICSP, y un botón de reinicio. Contiene todo lo necesario para apoyar el
microcontrolador; basta con conectarlo a un ordenador con un cable USB o el poder con un adaptador o
la batería AC-to-DC para empezar. La Mega es compatible con la mayoría de los escudos diseñados para
el Arduino Duemilanove o Diecimila.
El Mega 2560 es una actualización de la Mega Arduino , a la que sustituye.
El Mega2560 difiere de todas las placas anteriores en que no utiliza el chip controlador de USB a serial
FTDI. En lugar de ello, cuenta con la ATmega16U2 ( ATmega8U2 en las juntas de revisión 1 y revisión 2)
programado como un convertidor de USB a serie.
Revisión 2de la junta Mega2560 tiene una resistencia tirando de la línea 8U2 HWB a tierra, por lo que es
más fácil de poner en modo DFU .
Revisión 3 de la Junta tiene las siguientes características nuevas:
pinout: SDA añadido y pines SCL que están cerca al pin AREF y otros dos nuevos pernos
colocados cerca del pin de RESET, la instrucción IOREF que permiten a los escudos para
adaptarse al voltaje suministrado desde la pizarra. En el futuro, los escudos serán compatibles
tanto con la placa que utilice el AVR, que operan con 5V y con el Arduino Debido que operan con
3.3V. El segundo es un pin no está conectado, que se reserva para usos futuros.
Circuito de rearme fuerte.
Atmega 16U2 sustituir el 8U2.
La apariencia del hardware es la siguiente:
Arduino Mega 2560 Frontal
Arduino Mega 2560 Atrás
Las partes del Hardware son las siguientes:
Sus características Principales son:
Microcontrolador: ATmega2560
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 54 (de los cuales 15 proveen salida PWM)
Pines de entradas análogas: 16
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 256 KB de los cuales 8 KB son utilizados por el bootloader
SRAM: 8 KB (ATmega328)
EEPROM: 4 KB (ATmega328)
Velocidad del reloj: 16 MHz
Consultado en: http://arduino.cc/en/Main/arduinoBoardMega2560
ARDUINO MINI La Arduino Mini es una pequeña placa de desarrollo originalmente basado en el ATmega168 , pero
ahora suministra con el 328, destinado a circular en paneras y cuando el espacio es un bien
escaso. Cuenta con 14 pines digitales de entrada / salida (de los cuales 6 pueden utilizarse para salidas
PWM), 8 entradas analógicas y un 16 MHzoscilador de cristal. Se puede programar con el adaptador de
serie USB u otro USB o RS232 a TTL adaptador serie.
El nuevo Mini (revisión 05) tiene un nuevo paquete para el ATmega328 , que permite a todos los
componentes que estar en la parte superior del tablero. También tiene un botón de reinicio a bordo. La
nueva versión cuenta con la misma configuración de pines como la revisión 04.
Advertencia : No encienda el mini Arduino con más de 9 voltios, o conecte la alimentación al revés:
probablemente sera danado.
La apariencia de Arduino Mini es la siguiente:
Arduino Mini Frontal
Arduino Mini Atrás
Las características principales son:
Microcontrolador: ATmega328
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 8
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 32 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 2 KB
EEPROM: 1 KB
Velocidad de reloj: 16 MHz
Consultado en: http://www.arduino.cc/en/Main/ArduinoBoardMini
ARDUINO NANO El Arduino Nano es una placa pequeña, completa y-tablero amistosa basada en el ATmega328 (Arduino
Nano 3.x) oATmega168 (Arduino Nano 2.x). Tiene más o menos la misma funcionalidad del Arduino
Duemilanove, pero en un paquete diferente. Le falta sólo un conector de alimentación de CC, y funciona
con un cable USB Mini-B en vez de una normal. El Nano fue diseñado y está siendo producido por
Gravitech.
La apariencia del hardware es la siguiente:
Arduino Nano Frontal
Arduino Nano Atrás
Las partes del Hardware son las siguientes:
Las características Principales son:
Microcontrolador: ATmega168
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 8
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 16 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 1 KB
EEPROM: 512 bytes
Velocidad de reloj: 16 MHz
Consultado en: http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardNano
ARDUINO PRO MINI El Arduino Pro Mini es una placa electronica basada en el ATmega168. Cuenta con 14 pines digitales de
entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 8 entradas analógicas, un
resonador de a bordo, un botón de reinicio, y agujeros para el montaje de cabezales de pin. Un cabezazo
de seis pines se puede conectar a un cable FTDI o tablero del desbloqueo Sparkfun para proporcionar
alimentación USB y la comunicación a la junta.
El Arduino Pro Mini está diseñado para la instalación semi-permanente en objetos o exposiciones. El
tablero viene sin cabeceras premontados, permitiendo el uso de varios tipos de conectores o soldadura
directa de cables. La distribución de los pines es compatible con el Arduino Mini.
Hay dos versiones del Pro Mini. Uno corre a 3.3V y 8 MHz , el otro a 5 V y 16 MHz .
El Arduino Pro Mini fue diseñado y fabricado por Sparkfun Electrónica.
La apariencia de ARDUINO PRO MINI es:
Arduino Pro Mini Frontal Arduino Pro Mini Atrás
Las características principales son:
Microcontrolador: ATmega168
Voltaje de funcionamiento: 3.3 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 8
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 16 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 1 KB
EEPROM: 512 bytes
Velocidad de reloj: 8 MHz
Consultado en : http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardProMini
ARDUINO PRO
El Arduino Pro es una placa electronica basada en el ATmega168 o ATmega328. El Pro viene en tanto
3.3V / 8 MHz y 5V / 16 MHz versiones. Cuenta con 14 pines digitales de entrada / salida (de los cuales 6
pueden utilizarse para salidas PWM), 6 entradas analógicas, un conector de alimentación de la batería,
un interruptor de encendido, un botón de reinicio, y agujeros para el montaje de un conector de
alimentación, una cabecera ICSP, y cabezales de pin. Un cabezazo de seis pines se puede conectar a un
cable FTDI o tablero del desbloqueo Sparkfun para proporcionar alimentación USB y la comunicación a
la junta.
El Arduino Pro está diseñado para la instalación semi-permanente en objetos o exposiciones. El tablero
viene sin cabeceras premontados, permitiendo el uso de varios tipos de conectores o soldadura directa
de cables. La distribución de los pines es compatible con escudos Arduino. Las versiones de 3,3 V del Pro
puede ser alimentado con una batería.
El Arduino Pro fue diseñado y fabricado por Sparkfun Electrónica.
La apariencia del Hardware es la siguiente:
Las características principales son:
Microcontrolador: ATmega168
Voltaje de funcionamiento: 3.3 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 6
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 16 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 1 KB
EEPROM:512 bytes
Velocidad de reloj: 8 MHz
Consultado en: http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardPro
ARDUINO MICRO
El Arduino Micro es una placa electronica basada en el ATMEGA32U4, desarrollado en conjunto con
Adafruit . Tiene 20 pines digitales de entrada / salida (de los cuales 7 puede utilizarse para salidas PWM
y 12 entradas como analógicas), un 16 MHz del oscilador de cristal, una conexión micro USB, un header
ICSP, y un botón de reinicio.Contiene todo lo necesario para apoyar el microcontrolador; basta con
conectarlo a un ordenador con un cable micro USB para empezar. Tiene un factor de forma que le
permite ser fácilmente colocado en un circuito.
El Micro es similar a la Arduino Leonardo en que el ATMEGA32U4 se ha incorporado en la comunicación
USB, eliminando la necesidad de un procesador secundario. Esto permite que el micro que aparezca a
una computadora conectada como un ratón y el teclado, además de una virtual (CDC) de puerto serie /
COM.
La apariencia de Hardware es la siguiente:
Arduino Micro frontal
Arduino Micro atrás
Las características principales del hardware son las siguientes:
Microcontrolador: ATmega32u4
Voltaje de funcionamiento: 5 V
Pines I/O digitales: 20
Canales PWM: 7
Pines de entradas análogas: 12
Corriente DC por cada pin I/O: 40 mA
Corriente DC en el pin de 3.3 V: 50 mA
Memoria Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader
SRAM: 2.5 KB (ATmega32u4)
EEPROM: 1 KB (ATmega32u4)
Velocidad de reloj: 16 MHz Consultado en: http://arduino.cc/en/Main/arduinoBoardMicro
ARDUINO FIO
El Arduino Fio es una placa electronica basada en el ATmega328P funciona a 3.3V y 8 MHz . Cuenta con
14 pines digitales de entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 8 entradas
analógicas, un resonador de a bordo, un botón de reinicio, y agujeros para el montaje de cabezales de
pin. Tiene conexiones para una batería de polímero de litio e incluye un circuito de carga a través de
USB. Un XBee socket está disponible en la parte inferior del tablero.
El Arduino Fio está diseñado para aplicaciones inalámbricas. El usuario puede subir sketches con un
cable FTDI o tablero del desbloqueo Sparkfun. Además, mediante el uso de un USB-Hoy en
modificado XBee adaptador tales como XBeeExplorador de USB, el usuario puede subir bocetos de
forma inalámbrica. El tablero viene sin cabeceras premontados, permitiendo el uso de varios tipos de
conectores o soldadura directa de cables.
El Arduino Fio fue diseñado por Shigeru Kobayashi y Sparkfun Electrónica, y fabricada
por Sparkfun Electrónica.
La apariencia del Hardware es la siguiente:
Arduino Fio Frontal
Las características principales son:
Microcontrolador: ATmega328P
Voltaje de funcionamiento: 3.3 V
Pines I/O digitales: 14 (de los cuales 6 proveen salida PWM)
Pines de entradas análogas: 8
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 32 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 2 KB
EEPROM: 1 KB
Velocidad de reloj: 8 MHz
Consultado en : http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardFio
ARDUINO LILY PAD USB
El LilyPad Arduino USB es una placa electronica basada en el ATMEGA32U4. 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 MHzresonador, 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 el poder 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, eliminando la necesidad de un adaptador independiente-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 una virtual (CDC) de puerto serie / COM.
La apariencia del hardware es la siguiente:
Arduino Lily Pad USB Frontal Arduino Lily Pad USB Atrás
Las características principales del hardware son las siguientes:
Microcontrolador: ATmega32u4
Voltaje de funcionamiento: 3.3 V
Pines I/O digitales: 9
Canales PWM: 4
Pines de entradas análogas: 4
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 32 KB de los cuales 4 KB son utilizados por el bootloader
SRAM: 2.5 KB
EEPROM: 1 KB
Velocidad de reloj: 8 MHz
Consultado en: http://arduino.cc/en/Main/ArduinoBoardLilyPadUSB
ARDUINO LILY PAD SIMPLE El LilyPad simple Arduino es una placa electronica diseñado para wearables y e-textiles. Puede ser cosido
a la tela y montado de manera similar fuentes de alimentación, sensores y actuadores con hilo
conductor. A diferencia de la placa principal Arduino LilyPad , el LilyPad simple tiene sólo 9 pines para
entrada / salida. Además, cuenta con un conector JST y construido en un circuito de carga para las
baterías de polímero de litio. El consejo está basado en el ATmega328 .
El LilyPad Arduino simple fue diseñado y desarrollado por Leah Buechley y Sparkfun Electrónica.
La apariencia del hardware es la siguiente:
Arduino Lily Pad simple Frontal Arduino Lily Pad simple atrás
Las características principales del hardware son las siguientes:
Microcontrolador: ATmega328
Voltaje de funcionamiento: 2.7-5.5 V
Pines I/O digitales: 9 (de los cuales 5 proveen salida PWM)
Pines de entradas análogas: 4
Corriente DC por cada pin I/O: 40 mA
Memoria Flash: 32 KB de los cuales 2 KB son utilizados por el bootloader
SRAM: 2 KB
EEPROM: 1 KB
Velocidad de reloj: 8 MHz
LENGUAJE DE PROGRAMACION ARDUINO Arduino se programa en el lenguaje de alto nivel C/C++ y generalmente tiene los siguiente componentes
para elaborar el algoritmo:
Estructuras
Variables
Operadores matemáticos, lógicos y booleanos
Estructuras de control (Condicionales y ciclos)
Funciones
ESTRUCTURA DE UN PROGRAMA DESARROLLADO PARA ARDUINO 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.
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. Así mismo se puede utilizar para establecer el estado inicial de las salidas de la
placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como
salida
digitalWrite(pin, HIGH); // pone el ‘pin’ en estado
// HIGH
}
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
eventosque se produzcan en la placa.
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
delay(1000); // ´pin´
}
funciones
Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son
ejecutadas 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. Este valor será el que devolverá la
función, por ejemplo 'int' se utilizará cuando la function 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.
tipo nombreFunción(parámetros)
{
instrucciones;
}
Comentarios Multilinea
Los bloques de comentarios, o comentarios multi-línea 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.
/* esto es un bloque de comentario no se debe olvidar
cerrar los comentarios estos deben estar equilibrados */
Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de
Arduino pueden ser utilizados con generosidad. También pueden utilizarse para "comentar" bloques de
código con el propósito de anotar informaciones para depuración y hacerlo mas comprensible para
cualquiera.
Nota: Dentro de una misma línea de un bloque de comentarios no se puede escribir otra bloque de
comentarios (usando /*..*/).
Comentarios Simples
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.
// esto es un comentario
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 debe ser declarada y opcionalmente asignada a un determinado valor. En la declaración de
la variable se indica el tipo de datos que almacenará (int, float, long)
Tipo Nombre; o tipo nombre=valor;
Ejemplo:
int inputVariable = 0;
Una variable puede ser declarada en el inicio del programa antes de setup(), localmente a una
determinada función e incluso dentro de un bloque como pueda ser un bucle. El sitio en el que la
variable es declarada determina el ámbito de la misma. Una variable global es aquella que puede ser
empleada en cualquier función del programa. Estas variables deben ser declaradas al inicio del
programa (antes de la función setup()).
int v; // 'v' es visible en todo el programa
void setup() {
// no se requiere setup
}
void loop() {
for (int i=0; i<20;) // 'i' es visible solo en el bucle
i++;
float f; // 'f' es visible únicamente en la función loop()
}
CONSTANTES
• HIGH | LOW
• INPUT | OUTPUT
• true | false
• Constantes Numéricas
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
// de 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
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 queel 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
// de 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
// de tipo flotante
Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las
comparaciones. Los calculus 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...}
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 utilize 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; // LED en el PIN 10
byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60};
// array de 8 valores
void setup()
{
pinMode(ledPin, OUTPUT); // configura la salida
}
void loop()
{
for(int i=0; i<7; i++)
{
analogWrite(ledPin, parpadeo[i]);
delay(200); // espera 200ms
}
}
OPERADORES
Empleando variables, valores constantes o componentes de un array pueden realizarse operaciones
aritméticas y se puede utilizar el operador cast para conversión de tipos. Ej. int a = (int)3.5; Además
pueden hacerse las siguientes asignaciones:
x ++. Lo mismo que x = x + 1.
x --. Lo mismo que x = x - 1, or decrements x by -1.
x += y. Lo mismo que x = x + y, or increments x by +y.
x -= y. Lo mismo que x = x - y .
x *= y. Lo mismo que x = x * y.
x /= y. Lo mismo que x = x / y.
Para su utilización en sentencias condicionales u otras funciones Arduino permite utilizar los siguientes
operadores de comparación:
x == y. x es igual a y.
x != y. x no es igual a y.
x < y, x > y, x <= y, x >= y.
Y los siguientes operadores lógicos:
Y lógico: if (x > 0 & 38;& 38; x < 5). Cierto si las dos expresiones lo son.
O lógico: if (x > 0 || y > 0). Cierto si alguna expresión lo es.
NO lógico: if (!x > 0). Cierto si la expresión es falsa.
El lenguaje de Arduino presenta las siguientes constantes predefinidas:
TRUE / FALSE.
HIGH/LOW. Estas constantes definen los niveles de los pines como HIGH o LOW y son empleados
cuando se leen o escriben en las entradas o salidas digitales. HIGH se define como el nivel lógico 1 (ON)
o 5 V. LOW es el nivel lógico 0, OFF, o 0 V.
INPUT/OUTPUT. Constantes empleadas con la función pinMode() para definir el tipo de un pin digital
usado como entrada INPUT o salida OUTPUT. Ej. pinMode(13, OUTPUT);
Sentencias condicionales
El lenguaje de arduino permite realizar sentencias condicionales if, if... else, for, while, do... while. Su
utilización es similar a las funciones correspondientes en C.
if (si condicional)
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 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
valido 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)
{
instruccionesA;
}
else
{
instruccionesB;
}
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
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;
}
else if (inputPin >= 1000)
{
instruccionesB;
{
else
{
instruccionesC;
}
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)
{
Instrucciones;
}
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:
for (int i=0; i<20; i++) // declara i y prueba si es
{ // menor que 20, incrementa i.
digitalWrite(13, HIGH); // enciende el pin 13
delay(250); // espera ¼ seg.
digitalWrite(13, LOW); // apaga el 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
}
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
{25
x = leeSensor();
delay(50);
} while (x < 100);
Entradas y salidas digitales y analógicas
Función pinMode(pin, mode)
Función usada en la function setup() para configurar un pin dado para comportarse como INPUT o
OUTPUT. Ej. pinMode(pin, OUTPUT); configura el pin número 'pin' como de salida. Los pines de Arduino
funcionan por defecto como entradas, de forma que no necesitan declararse explícitamente como
entradas empleando pinMode().
Función digitalRead(pin)
Lee el valor desde un pin digital específico. Devuelve un valor HIGH o LOW. El pin puede ser especificado
con una variable o una constante (0-13). Ej. v = digitalRead(Pin);
Funcion digitalWrite(pin, value)
Introduce un nivel alto (HIGH) o bajo (LOW) en el pin digital especificado. De nuevo, el pin puede ser
especificado con una variable o una constante 0-13. Ej. digitalWrite(pin, HIGH);
Función analogRead(pin)
Lee el valor desde el pin analógico especificado con una resolución de 10 bits. Esta función solo funciona
en los pines analógicos (0-5). El valor resultante es un entero de 0 a 1023. Los pines analógicos, a
diferencia de los digitales no necesitan declararse previamente como INPUT o OUTPUT.
Función analogWrite(pin, value)
Escribe un valor pseudo-analógico usando modulación por ancho de pulso (PWM) en un pin de salida
marcado como PWM. Esta función está activa para los pines 3, 5, 6, 9, 10, 11. Ej analogWrite(pin, v); //
escribe 'v' en el 'pin' analógico. Puede especificarse un valor de 0 - 255. Un valor 0 genera 0 V en el pin
especificado y 255 genera 5 V. Para valores de 0 a 255, el pin alterna rápidamente entre 0 V y 5 V,
cuanto mayor sea el valor, más a menudo el pin se encuentra en HIGH (5 V). Por ejemplo, un valor de 64
será 0 V tres cuartas partes del tiempo y 5 V una cuarta parte. Un valor de 128 será 0 V la mitad del
tiempo y 5 V la otra mitad. Un valor de 192 será 0 V una cuarta parte del tiempo y 5 V tres cuartas
partes.
Funciones de tiempo
delay(ms)
Realiza una pausa en el programa la cantidad de tiempo en milisegundos especificada en el parámetro
(máximo 1000, mínimo 1).
millis()
Devuelve la cantidad de milisegundos que lleva la placa Arduino ejecutando el programa actual como
un valor long unsigned. Después de de 9 horas el contador vuelve a 0.
min(x,y). max(x,y).
Devuelve el mínimo y el máximo respectivamente de entre sus parámetros.
Funciones de generación aleatoria
randomSeed(seed).
Especifica un valor o semilla como el punto de inicio para la función random(). Este parámetro debe ser
realmente aleatorio y para ello puede emplearse la función millis() o incluso analogRead() para leer
ruido eléctrico desde una entrada analógica.
random(max), random(min, max).
Esta función devuelve un valor aleatorio entre el rango especificado.
COMUNICACIÓN SERIAL
Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros dispositivos. Todas las
placas Arduino tienen al menos un puerto serie (también conocido como UART o USART): Serial. Se
comunica a través de los pines digitales 0 (RX) y 1 (TX), así como con el ordenador mediante USB. Por lo
tanto, si utilizas estas funciones, no puedes usar los pines 0 y 1 como entrada o salida digital.
Puedes utilizar el monitor del puerto serie incorporado en el entorno Arduino para comunicarte con la
placa Arduino. Haz clic en el botón del monitor de puerto serie en la barra de herramientas y selecciona
la misma velocidad en baudios utilizada en la llamada a begin().
La placa Arduino Mega tiene tres puertos adicionales de serie: Serial1 en los pines 19 (RX) y 18 (TX),
Serial2 en los pines 17 (RX) y 16 (TX), Serial3 en los pines 15 (RX) y 14 (TX). Para utilizar estos pines para
comunicarse con el ordenador personal, necesitarás un adaptador USB adicional a serie, ya que no están
conectados al adaptador USB-Serie de la placa Arduino Mega. Para usarlos para comunicarse con un
dispositivo serie externo TTL, conecta el pin TX al pin RX del dispositivo, el RX al pin TX del dispositivo, y
el GND de tu Arduino Mega a masa del dispositivo. (No conectes estos pines directamente a un puerto
serie RS232, que operan a +/- 12V y esto puede dañar la placa Arduino.)
Las funciones predeterminadas que existen para la comunicación en Serial son las siguientes:
• begin()
• end()
• available()
• read()
• flush()
• print()
• println()
• write()
BEGIN()
Descripción : Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos
en serie. Para comunicarse con el computador, utilice una de estas velocidades: 300, 1200, 2400, 4800,
9600, 14400, 19200, 28800, 38400, 57600 o 115200. Sin embargo, puedes especificar otras velocidades -
por ejemplo, para comunicarte a través de los pines 0 y 1 con un componente que requiere una
velocidad de transmisión en particular.
Sintaxis :
Serial.begin(speed)
Solamente en Arduino Mega:
Serial1.begin(speed)
Serial2.begin(speed)
Serial3.begin(speed)
Parámetros
speed: Velocidad en bits por segundo (baudios) - long
Devuelve: nada
Ejemplo:
void setup() {
Serial.begin(9600); // abre el puerto serie y establece la velocidad en 9600 bps
void loop() {}
Ejemplo para Arduino Mega:
// Arduino Mega usando sus 4 puertos serie
// (Serial, Serial1, Serial2, Serial3),
// con diferentes velocidades de datos:
void setup(){
Serial.begin(9600);
Serial1.begin(38400);
Serial2.begin(19200);
Serial3.begin(4800);
Serial.println("Hola ordenador");
Serial1.println("Hola Serial 1");
Serial2.println("Hola Serial 2");
Serial3.println("Hola Serial 3");
void loop() {}
END()
Descripción: Desactiva la comunicación serie, permitiendo a los pines RX and TX ser usados como
entradas o salidas digitales. Para reactivar la comunicación serie, llama al método Serial.begin().
Sintaxis
Serial.end()
Solamente en Arduino Mega:
Serial1.end()
Serial2.end()
Serial3.end()
Parámetros : ninguno
Devuelve : nada
AVAILABLE()
Descripción : Devuelve el número de bytes (caracteres) disponibles para ser leídos por el puerto serie. Se
refiere a datos ya recibidos y disponibles en el buffer de recepción del puerto (que tiene una capacidad
de 128 bytes).
Sintaxis
Serial.available()
Sólo para Arduino Mega:
Serial1.available()
Serial2.available()
Serial3.available()
Parametros :ninguno
Devuelve : el número de bytes disponibles para ser leídos
Ejemplo
int incomingByte = 0; // para los datos de entrada serie
void setup() {
Serial.begin(9600); // abre el puerto serie, establece la velocidad
a 9600 bps
void loop() {
// envía datos solo cuando recibe datos:
if (Serial.available() > 0) {
// lee el byte de entrada:
incomingByte = Serial.read();
// muestra lo que tiene:
Serial.print("He recibido: ");
Serial.println(incomingByte, DEC);
}
Ejemplo Arduino Mega:
void setup() {
Serial.begin(9600);
Serial1.begin(9600);
void loop() {
// lee desde el puerto 0, envía al puerto 1:
if (Serial.available()) {
int inByte = Serial.read();
Serial1.print(inByte, BYTE);
// lee del puerto 1, envía al puerto 0:
if (Serial1.available()) {
int inByte = Serial1.read();
Serial.print(inByte, BYTE);
READ()
Descripción : Lee los datos entrantes del puerto serie.
Sintaxis
Serial.read()
Solamente en Arduino Mega:
Serial1.read()
Serial2.read()
Serial3.read()
Parámetros : Ninguno
Devuelve :el primer byte disponible recibido por el puerto serie
(devuelve -1 si no hay datos disponibles) - int
Ejemplo
int incomingByte = 0; // para el byte leido
void setup() {
Serial.begin(9600); // abre el puerto serie a 9600 bps
void loop() {
// envia datos solamente cuando recibe datos
if (Serial.available() > 0) {
// lee el byte entrante:
incomingByte = Serial.read();
// dice lo que ha recibido:
Serial.print("He recibido: ");
Serial.println(incomingByte, DEC);
}
FLUSH()
Descripción : Vacía el búfer de entrada de datos en serie. Es decir, cualquier llamada a Serial.read () o
Serial.available () devolverá sólo los datos recibidos después la llamada más reciente a Serial.flush ().
Sintaxis
Serial.flush()
Solamente en Arduino Mega:
Serial1.flush()
Serial2.flush()
Serial3.flush()
Parámetros : ninguno
Retorna : ninguno
PRINT()
Descripción : Imprime los datos al puerto serie como texto ASCII. Este comando puede tomar muchas
formas. Los números son impresos mediante un juego de caracteres ASCII para cada dígito. Los valores
de tipo "float" son impresos en forma de dígitos ASCII con dos decimales por defecto. Los valores tipo
"byte" se envían como un único carácter. Los caracteres y las cadenas se envían tal cual.
Por ejemplo:
• Serial.print(78) imprime "78"
• Serial.print(1.23456) imprime "1.23"
• Serial.print(byte(78)) imprime "N" (cuyo código ASCII es 78)
• Serial.print('N') imprime "N"
• Serial.print("Hello world.") imprime "Hello world."
Un segundo parámetro opcional especifica la base (formato) a usar; los valores permitidos son BYTE, BIN
(binarios o base 2), OCT (octales o base 8), DEC (decimales o base 10), HEX (hexadecimales o base 16).
Para números de coma flotante, este parámetro especifica el numero de posiciones decimales a usar.
Por ejemplo:
• Serial.print(78, BYTE) imprime "N"
• Serial.print(78, BIN) imprime "1001110"
• Serial.print(78, OCT) imprime "116"
• Serial.print(78, DEC) imprime "78"
• Serial.print(78, HEX) imprime "4E"
• Serial.println(1.23456, 0) imprime "1"
• Serial.println(1.23456, 2) imprime "1.23"
• Serial.println(1.23456, 4) imprime "1.2346"
Sintaxis
Serial.print(val)
Serial.print(val, format)
Parámetros
val: el valor a imprimir - de cualquier tipo
format: especifica el número de la base (para números enteros) o el número de
posiciones decimales (para números de coma flotante o tipo "float")
Devuelve : Nada
Ejemplo:
/*Usa un bucle FOR para los datos e imprime un número en varios formatos.*/
int x = 0; // variable
void setup() {
Serial.begin(9600); // abre el puerto serie a 9600 bps:
void loop() {
// print labels
Serial.print("SIN FORMATO"); // imprime un texto
Serial.print("\t"); // imprime un tabulado
Serial.print("DEC");
Serial.print("\t");
Serial.print("HEX");
Serial.print("\t");
Serial.print("OCT");
Serial.print("\t");
Serial.print("BIN");
Serial.print("\t");
Serial.println("BYTE");
for(x=0; x< 64; x++){ // solo una parte de la tabla
// imprime en varios formatos:
Serial.print(x); // imprime como codificado ASCII decimal - igual que "DEC"
Serial.print("\t"); // imprime un tabulado
Serial.print(x, DEC); // imprime como codificado ASCII decimal
Serial.print("\t"); // imprime un tabulado
Serial.print(x, HEX); // imprime como codificado ASCII hexadecimal
Serial.print("\t"); // imprime un tabulado
Serial.print(x, OCT); // imprime como codificado ASCII octal
Serial.print("\t"); // imprime un tabulado
Serial.print(x, BIN); // imprime como codificado ASCII binario
Serial.print("\t"); // imprime un tabulado
Serial.println(x, BYTE); // imprime el valor en bruto del byte,
// y añade el salto de línea con "println"
delay(200); // espera 200 milisegundos
Serial.println(""); //imprime otro salto de línea
Sugerencias de programación / Problemas conocidos
El último carácter a imprimir se transmite a través del puerto serie después de que Serial.print () ha
regresado.
PRINTL()
Descripción : Imprime los datos al puerto serie como texto ASCII seguido de un retorno de carro (ASCII
13, o '\r') y un carácter de avance de línea (ASCII 10, o '\n'). Este comando tiene la misma forma que
Serial.print ().
Sintaxis
Serial.println(val)
Serial.println(val, format)
Parámetros
val: el valor a imprimir - de cualquier tipo format: especifica el número de la
base (para números enteros) o el número de posiciones decimales (para
números de coma flotante o tipo "float")
Devuelve : Nada
Ejemplo:
Analog input
Lee el pin analógico 0, e imprime su valor por el puerto serie.
int analogValue = 0; // variable para guardar el valor analogico
void setup() {
// abre el puerto serie a 9600 bps:
Serial.begin(9600);
void loop() {
// lee la entrada analogica en el pin 0:
analogValue = analogRead(0);
// imprime el valor en varios formatos:
Serial.println(analogValue); // imprime como ASCII decimal
Serial.println(analogValue, DEC); // imprime como ASCII decimal
Serial.println(analogValue, HEX); // imprime como ASCII hexadecimal
Serial.println(analogValue, OCT); // imprime como ASCII octal
Serial.println(analogValue, BIN); // imprime como ASCII binario
Serial.println(analogValue, BYTE); // imprime el valor del byte
// espera 10 milisegundos antes de la siguiente lectura.
delay(10);
WRITE()
Descripción : Escribe datos binarios en el puerto serie. Estos datos se envían como un byte o una serie
de bytes; para enviar los caracteres que representan los dígitos de un número usar función print () en su
lugar.
Sintaxis
Serial.write(val)
Serial.write(str)
Serial.write(buf, len)
Arduino Mega tambien soporta: Serial1, Serial2, Serial3 (en lugar de Serial)
Parámetros
val: un valor para enviar como un solo byte
str: una cadena 'string' para enviar como una serie de bytes
buf: un 'array' para enviar como una serie de bytes
len: longitud del buffer
contenido de lenguaje arduino consultado en:
• http://es.wikipedia.org/wiki/Arduino#Matem.C3.A1ticas
• http://oni.escuelas.edu.ar/2013/BUENOS_AIRES/1763/materiales/Libro_kit_Basico.pdf
• http://dfists.ua.es/~jpomares/arduino/page_01.htm
• http://www.ardumania.es/wp-
content/uploads/2011/10/Arduino_programing_notebook_ES.pdf
• http://www.etnassoft.com/biblioteca/manual-de-programacion-arduino/
• https://docs.google.com/file/d/0B7TtzlqCufECZTc0OTZiNWEtNTZjZi00NzM1LWJiODUtODA4NmZ
lNjNlZDE0/edit?ddrp=1&pli=1&hl=es#
• http://tecbolivia.com/index.php/mini-cursos-online-gratuitos/27-introduccion-al-lenguaje-de-
programacion-de-arduino
• http://www.jcarazo.com/tmp/Arduino_user_manual_es.pdf
• http://arduinobot.pbworks.com/f/Manual+Programacion+Arduino.pdf
• http://arduino.cc/en/pmwiki.php?n=Tutorial/HomePage
PROBLEMAS COMUNES
INSTALACION DE DRIVERS
Nos DIrigiremos a Administrador de Dispositivos para poder instalar correctamente los drivers de
nuestro hardware arduino, En la ventana del Administrador de dispositivos, en "Otros dispositivos" nos
mostrará con admiración "Arduino Uno", pulsaremos con el botón derecho del ratón y seleccionaremos
"Actualizar software de controlador":
Pulsaremos en "Buscar software de controlador en el equipo. Buscar e instalar el software de
controlador de forma manual":
Pulsaremos en el botón "Examinar" para seleccionar la carpeta donde se encuentran los drivers:
Seleccionaremos la carpeta "arduino-0022" (descomprimida anteriormente) y, dentro de esta, la
carpeta "drivers":
Pulsaremos "Siguiente":
El asistente para instalar un nuevo controlador nos mostrará un aviso de seguridad, pulsaremos "Instalar
este software de controlador de todas formas":
Si todo es correcto, el asistente nos habrá instalado el controlador para Arduino UNO y nos mostrará la
siguiente ventana:
En el Administrador de dispositivos de Microsoft Windows 7 nos mostrará el nuevo controlador
instalado, en "Puertos (COM y LPT)". Es importante que anotemos el nombre asignado al puerto COM
para Arduino, en nuestro caso COM3, pues lo necesitaremos seleccionar en el IDE de Arduino:
CONCLUSIONES En el desarrollo de este documento abarcamos gran parte de lo que es ARDUINO, no solo en lo que es el
hardware sino en el manejo del mismo desde la programación ya que esta es el alma del hardware.
Un buen conocimiento en la programación ARDUINO y tener conocimiento de las funciones
predeterminadas que incorpora para su implementación podremos darle un buen funcionamiento al
hardware y este será eficiente.
El manejo de las entradas análogas y digitales de ARDUINO son importantes para el manejo del
hardware, haciendo un buen manejo de las señales el funcionamiento de nuestro proyecto nos dara
buenos resultados.
No solo conocimos los tipos de ARDUINO sino también sus componentes ya que gran parte de estos son
derivados de otras versiones por lo que no varian en gran porcentaje en el numero de componentes en
común. Y la implementación en el desarrollo del software es muy parecido por el comportamiento del
hardware.
En este documento introductorio y tutorial de lo que es arduino abarcamos las partes mas esenciales
pero no se hizo énfasis de los componentes adicionales que pueden ser agregados a nuestros proyectos.
BIBLIOGRAFIA
Oxer, Jonathan; Blemings, Hugh (28 de diciembre de 2009). Practical Arduino: Cool
Projects for Open Source Hardware (1ª edición). Apress. p. 500. ISBN 1430224770.
Noble, Joshua (15 de julio de 2009). Programming Interactivity: A Designer's Guide to
Processing, Arduino, and openFramework (1ª edición). O'Reilly Media.
p. 768.ISBN 0596154143.
Banzi, Massimo (24 de marzo de 2009). Getting Started with Arduino (1ª edición). Make
Books. p. 128. ISBN 0596155514.
Sitio web Proyecto Arduino (en inglés)
Sitio web Proyecto Arduino (en español con menos contenidos)
Arduino Stack Exchange sitio de preguntas y respuestas
http://www.ardumania.es/wp-
content/uploads/2011/10/Arduino_programing_notebook_ES.pdf
http://www.jcarazo.com/tmp/Arduino_user_manual_es.pdf
http://arduinobot.pbworks.com/f/Manual+Programacion+Arduino.pdf