Tutorial-Material de Apoyo-Arduino

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 33 -1998 del Congreso de la República de Guatemala. See more at: http://wikiguate.com.gt/wiki/Ley_de_ http://wikiguate.co m.gt/wiki/Ley_de_Derecho_de_Au Derecho_de_Autor_y_Derechos_C tor_y_Derechos_Conexos_de_Guatemala onexos_de_Guatemala_(docu _(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/E http://mymemory.translate d.net/t/Italian/English/arduino-tutorial%3A nglish/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=Gu http://arduino.cc/en/pmwiki.php?n=Guide/Introduction ide/Introduction ....................................................................... 7 OBJETIVOS ..................................................................................................................................................... 7 INSTALACION Y CONFIGURACION ................................................................................................................. 8 1.

DESCARGA: .................................. ................. .................................. ................................... ................................... ................................... .................................... ................................ .............. 8

2.

INSTALACION INSTALACI ON ................................. ................ .................................. ................................... ................................... ................................... .................................... ............................. ........... 9

TIPOS ARDUINO ARDUINO .......................................................................................................................................... 11 

ARDUINO ARDUIN O 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 Estruc turas .................................. ................. .................................. ................................... ................................... ................................... .................................... .............................. ............ 44



Variables............ Variabl es.............................. ................................... .................................. ................................... ................................... ................................... ................................... ..................... .... 44



Operadores Operado res matemáticos, matemát icos, lógicos y booleanos booleano s ................................. ................ ................................... ................................... ........................... .......... 44



Estructuras Estruc turas de control (Condicionales (Condiciona les 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 v ariedad 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 ofr ecen 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=Gu http://arduino.cc/e n/pmwiki.php?n=Guide/Introduction ide/Introduction http://arduino.cc/en/Main/Software http://arduino.cc/en/pmwiki.ph http://arduino.cc/ en/pmwiki.php?n=Guide/Introd p?n=Guide/Introduction# uction# 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 poder desarrollar el código código que necesitaremos necesitaremos implementar 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 m anera 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-toDC 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 A continuacion continuacion se mostrara las partes de ARDUINO UNO. UNO.

Arduino uno R3 Atrás.

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 Microcontrolador: ATmega328 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 6 análogas: 6 Corriente DC por cada pin I/O: 40 I/O: 40 mA Corriente DC en el pin de 3.3 V: 50 V: 50 mA Memoria Flash: 32 Flash: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados por el bootloader SRAM: 2 SRAM: 2 KB (ATmega328) EEPROM: 1 EEPROM: 1 KB (ATmega328) Velocidad de reloj: 16 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 implicaciones para el comportamiento de la placa. Consultado en : http://arduino.cc/en/Main/arduinoBoardLeonardo

La

placa

ARDUINO

LEONARDO

Arduino Leonardo Frontal

tiene

la

siguiente

Arduino Leonardo Atrás

Arduino Leonardo Frontal sin adaptadores para pines A continuación se presentan las partes de ARDUINO LEONARDO

apariencia:

Consultado en : http://makezine.c http://makezine.com/2014/03/24/skill-builder-a om/2014/03/24/skill-builder-arduino-101-arduinod14/ rduino-101-arduinod14/

CARACTERISTICAS PRINCIPALES ARDUINO LEONARDO:           

Microcontrolador: ATmega32u4 Microcontrolador: ATmega32u4 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 20 digitales: 20 Canales PWM: 7 PWM: 7 Pines de entradas análogas: 12 análogas: 12 Corriente DC por cada pin I/O: 40 I/O: 40 mA Corriente DC en el pin de 3.3 V: 50 V: 50 mA Memoria Flash: 32 Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader SRAM: 2 SRAM: 2 KB (ATmega32u4) EEPROM: 1 EEPROM: 1 KB (ATmega32u4) Velocidad de reloj: 16 reloj: 16 MHz

ARDUINO DUE El Arduino Ar duino 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 5 V. 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 L as 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 http://tronixlabs.co m/arduino/boards/due/freetronics-etherdue-arduin /freetronics-etherdue-arduino-dueo-due-

compatible-with-ethernet/

CARACTERISTICAS PRINCIPALES ARDUINO DUE          

Microcontrolador: AT91SAM3X8E Microcontrolador: AT91SAM3X8E Voltaje de funcionamiento: 3.3 funcionamiento: 3.3 V Pines I/O digitales: 54 digitales: 54 (de los cuales 12 proveen salida PWM) Pines de entradas análogas: 12 análogas: 12 Corriente DC total en todos los pines I/O: 130 I/O: 130 mA Corriente DC en el pin de 5 V: 800 V: 800 mA Corriente DC en el pin de 3.3 V: 800 V: 800 mA Memoria Flash: 512 Flash: 512 KB disponibles para las aplicaciones de usuario. SRAM: 96 SRAM: 96 KB (dos bancos: 64KB Y 32 KB) Velocidad de reloj: 84 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, m icro-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 o frece un sistema de red de gran gr an 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

Las partes de Arduino Yun son las siguientes:

Arduino Yun Atrás

Las características principales de Arduino Yun Son las siguientes:                   

Microcontrolador AVR Arduino: ATmega32u4 Arduino: ATmega32u4 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 20 digitales: 20 Canales PWM: 7 PWM: 7 Pines de entradas análogas: 12 análogas: 12 Corriente DC por cada pin I/O: 40 I/O: 40 mA Corriente DC en el pin de 3.3 V: 50 V: 50 mA Memoria Flash: 32 Flash: 32 KB (de los cuales 4 KB son utilizados por el bootloader SRAM: 2.5 SRAM: 2.5 KB EEPROM: 1 EEPROM: 1 KB Velocidad de reloj: 16 reloj: 16 MHz Procesador Linux: Atheros Linux: Atheros AR9331 Arquitectura: MIPS Arquitectura: MIPS @400MHz Ethernet: IEEE Ethernet: IEEE 802.3 10/100Mbit/s WiFi: IEEE WiFi: IEEE 802.11b/g/n USB Tipo A: 2.0 A: 2.0 Lector de tarjeta: sólo tarjeta: sólo Micro-SD RAM: 64 RAM: 64 MB DDR2 Memoria Flash:16 Flash:16 MB

Consultado en : http://arduino. http://arduino.cc/en/Main/Ardui cc/en/Main/ArduinoBoardYun?from=Product noBoardYun?from=Products.ArduinoYUN s.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 Microcontrolador: ATMEGA32U4 Voltaje de Funcionamiento: 5V Funcionamiento: 5V Voltaje de entrada: 5V entrada: 5V Pines Digitales I/O: 5 I/O: 5 Canales PWM: 6 PWM: 6 Canales de Entrada Analogica: 4(pines Analogica: 4(pines I/O digitales) Canales Analogicos Multiplexados: 8 Multiplexados: 8 Corriente DC por Pin I/O: 40mA I/O: 40mA Memoria Flash: 32 Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque SRAM: 2,5 SRAM: 2,5 KB ( ATMEGA32U4 ) EEPROM (interna): 1 (interna): 1 KB ( ATMEGA32U4 ) EEPROM (externa): 512 (externa): 512 Kbit ( I2C ) Velocidad del Reloj: 16MHz Reloj: 16MHz Teclado: 5 Teclado: 5 Teclas Perilla: potenciómetro Perilla: potenciómetro adjunto al pin analógico LCD colores: Comunicación colores: Comunicación SPI Lector de Tarjetas: Formato Tarjetas: Formato FAT16 Altavoz: 8 Altavoz: 8 Ohm Brujula digital: proporciona digital: proporciona la desviación desde el norte geográfico en grados g rados I2C puertos de soldadura: 3 soldadura: 3 Áreas de prototipos: 4 prototipos: 4

Las partes de ARDUINO ROBOT TOP:

ARDUINO BOTTOM ROBOT Las características principales de Arduino Bottom Robot son las Siguientes:                 

Microcontrolador: ATMEGA32U4 Microcontrolador: ATMEGA32U4 Voltaje de funcionamiento: 5V funcionamiento: 5V Voltaje de entrada: 9V entrada: 9V para el cargador de batería Ranura de la batería AA: 4 AA: 4 alcalinas o NiMH baterías recargables Digital pines I / O: 4 O: 4 Canales PWM: 1 PWM: 1 Pines de entrada analógica: 4 analógica: 4 (de los pines I/O digitales) Corriente DC por pin I/O: 40 I/O: 40 mA Convertidor DC-DC: genera DC-DC: genera 5V para alimentar todo el robot Memoria Flash: 32 Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque SRAM: 2,5 SRAM: 2,5 KB ( ATMEGA32U4 ) EEPROM: 1 EEPROM: 1 KB ( ATMEGA32U4 ) Velocidad del Reloj: 16 Reloj: 16 MHz Trimmer: Para Trimmer: Para calibracion de movimiento. Línea de IR sensors: 5 sensors: 5 I2C puertos de soldadura: 1 soldadura: 1 Áreas de prototipos: 2 prototipos: 2

Las partes de ARDUINO ARDU INO 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 Microcontrolador: ATmega32u4 Voltaje de funcionamiento: 5 funcionamiento: 5 V Memoria Flash: 32 Flash: 32 KB de los cuales 4 KB son utilizados por el bootloader SRAM: 2.5 SRAM: 2.5 KB EEPROM: 1 EEPROM: 1 KB

          

Velocidad de reloj: 16 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 http://arduino.cc/en/Main/Arduin .cc/en/Main/ArduinoBoardMegaADK?from=Ma oBoardMegaADK?from=Main.ArduinoBoa in.ArduinoBoardADK rdADK

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 t ravé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 A rduino; 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 Microcontrolador: ATmega328



Voltaje de funcionamiento: 5 funcionamiento: 5 V



Pines I/O digitales: 14 digitales: 14 (de los cuales 4 proveen salida PWM)



Pines de entradas análogas: 6 análogas: 6



Corriente DC por cada pin I/O: 40 I/O: 40 mA



Corriente DC en el pin de 3.3 V: 50 V: 50 mA



Memoria Flash: 32 Flash: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados por el bootloader



SRAM: 2 SRAM: 2 KB (ATmega328)



EEPROM: 1 EEPROM: 1 KB (ATmega328)



Velocidad de reloj: 16 reloj: 16 MHz



Controlador embebido Ethernet W5100 Ethernet W5100 TCP/IP



Tarjeta MicroSD, 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 Microcontrolador: ATmega2560 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 54 digitales: 54 (de los cuales 15 proveen salida PWM) Pines de entradas análogas: 16 análogas: 16 Corriente DC por cada pin I/O: 40 I/O: 40 mA Corriente DC en el pin de 3.3 V: 50 V: 50 mA Memoria Flash: 256 Flash: 256 KB de los cuales 8 KB son utilizados por el bootloader SRAM: 8 SRAM: 8 KB (ATmega328) EEPROM: 4 KB (ATmega328) EEPROM: 4 Velocidad del reloj: 16 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 R S232 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 Microcontrolador: ATmega328 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 8 análogas: 8 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 32 Flash: 32 KB de los cuales 2 KB son utilizados por el bootloader SRAM: 2 SRAM: 2 KB EEPROM: 1 EEPROM: 1 KB Velocidad de reloj: 16 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 Microcontrolador: ATmega168 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 8 análogas: 8 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: Flash: 16 KB de los cuales 2 KB son so n utilizados por el bootloader SRAM: 1 SRAM: 1 KB EEPROM: 512 EEPROM: 512 bytes Velocidad de reloj: 16 reloj: 16 MHz

Consultado en: http://arduino http://arduino.cc/en/pmwiki.php?n .cc/en/pmwiki.php?n=Main/ArduinoBoardNa =Main/ArduinoBoardNano no

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


















Microcontrolador: ATmega168 Microcontrolador: ATmega168 Voltaje de funcionamiento: 3.3 funcionamiento: 3.3 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 8 análogas: 8 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 16 Flash: 16 KB de los cuales 2 KB son so n utilizados por el bootloader SRAM: 1 SRAM: 1 KB EEPROM: 512 EEPROM: 512 bytes Velocidad de reloj: 8 reloj: 8 MHz

Consultado en : http://arduino. http://arduino.cc/en/pmwiki.php?n= cc/en/pmwiki.php?n=Main/ArduinoBoardPro Main/ArduinoBoardProMini Mini

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:


















Microcontrolador: ATmega168 Microcontrolador: ATmega168 Voltaje de funcionamiento: 3.3 funcionamiento: 3.3 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 6 análogas: 6 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 16 Flash: 16 KB de los cuales 2 KB son so n utilizados por el bootloader SRAM: 1 SRAM: 1 KB EEPROM:512 EEPROM: 512 bytes Velocidad de reloj: 8 reloj: 8 MHz

Consultado en: http://arduino http://arduino.cc/en/pmwiki.php?n .cc/en/pmwiki.php?n=Main/ArduinoBoardP =Main/ArduinoBoardPro ro

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 Microcontrolador: ATmega32u4 Voltaje de funcionamiento: 5 funcionamiento: 5 V Pines I/O digitales: 20 digitales: 20

















Canales PWM: 7 PWM: 7 Pines de entradas análogas: 12 análogas: 12 Corriente DC por cada pin I/O: 40 I/O: 40 mA Corriente DC en el pin de 3.3 V: 50 V: 50 mA Memoria Flash: 32 Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader SRAM: 2.5 SRAM: 2.5 KB (ATmega32u4) EEPROM: 1 EEPROM: 1 KB (ATmega32u4) Velocidad de reloj: 16 reloj: 16 MHz

Consultado en: http://arduino.cc/en/Main/arduinoBoardMicro

ARDUINO FIO El Arduino Fio es una placa electronica basada 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 por Sparkfun Electrónica. La apariencia del Hardware es la siguiente:

Arduino Fio Frontal Las características principales son:

Shigeru Kobayashi y Sparkfun Electrónica, y

fabricada



















Microcontrolador: ATmega328P Microcontrolador: ATmega328P Voltaje de funcionamiento: 3.3 funcionamiento: 3.3 V Pines I/O digitales: 14 digitales: 14 (de los cuales 6 proveen salida PWM) Pines de entradas análogas: 8 análogas: 8 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 32 Flash: 32 KB de los cuales 2 KB son so n utilizados por el bootloader SRAM: 2 SRAM: 2 KB EEPROM: 1 EEPROM: 1 KB Velocidad de reloj: 8 reloj: 8 MHz

Consultado en : http://arduino. http://arduino.cc/en/pmwiki.php?n= cc/en/pmwiki.php?n=Main/ArduinoBoardFio 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 Microcontrolador: ATmega32u4 Voltaje de funcionamiento: 3.3 funcionamiento: 3.3 V Pines I/O digitales: 9 digitales: 9 Canales PWM: 4 PWM: 4 Pines de entradas análogas: 4 análogas: 4 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 32 Flash: 32 KB de los cuales 4 KB son so n utilizados por el bootloader SRAM: 2.5 KB SRAM: 2.5 EEPROM: 1 EEPROM: 1 KB Velocidad de reloj: 8 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 Microcontrolador: ATmega328 Voltaje de funcionamiento: 2.7-5.5 funcionamiento: 2.7-5.5 V Pines I/O digitales: 9 digitales: 9 (de los cuales 5 proveen salida PWM) Pines de entradas análogas: 4 análogas: 4 Corriente DC por cada pin I/O: 40 I/O: 40 mA Memoria Flash: 32 Flash: 32 KB de los cuales 2 KB son so n utilizados por el bootloader SRAM: 2 SRAM: 2 KB EEPROM: 1 EEPROM: 1 KB Velocidad de reloj: 8 reloj: 8 MHz

LENGUAJE DE PROGRAMAC PROGRAMACION ION 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. tr abaje. 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: 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 ú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: 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, 2 00, 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 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. 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. 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 condicionale c ondicionaless 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 condicion condicional) al)

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: 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: 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. +5 v. 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: Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados en algunos otros lenguajes de programación, programación, incluyendo BASIC. BASIC. Cualquiera de de los tres elementos de cabecera 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 var iable 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 digitalRe digitalRead(pin) ad(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 analogRead(pin) (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 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 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 respectivament r espectivamente e de entre sus parámetros.

Funciones de generació generación 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 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 baudios utilizada en la llamada 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 5 7600 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 : 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: 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 :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, Serial.println(incomingBy te, 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 : Parámetros : Ninguno Devuelve 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, Serial.println(incomingBy te, DEC); } FLUSH()

Descripción : 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 : Parámetros : ninguno Retorna : 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: val: el valor a imprimir - de cualquier tipo format: 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 : 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 gu ardar 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: val: un valor para enviar como un solo byte str: str: una cadena 'string' para enviar como una serie de bytes buf : un 'array' para enviar como una serie de bytes len: len: longitud del buffer contenido de lenguaje arduino consultado en: •

http://es.wikipedia.org/wiki/Arduino http://es.wikipedia .org/wiki/Arduino#Matem.C3.A1ticas #Matem.C3.A1ticas

•

http://oni.escuelas.edu.ar/2013/BUENOS_AIRE http://oni.escuela s.edu.ar/2013/BUENOS_AIRES/1763/materiales/Libro_ S/1763/materiales/Libro_kit_Basico.pdf kit_Basico.pdf

•

http://dfists.ua.es/~jpomares/arduino/page_01.htm

•

http://www.ardumania.es/wpcontent/uploads/2011/10/Arduino_programing content/uploads/2011/1 0/Arduino_programing_notebook_ES.pdf _notebook_ES.pdf

•

http://www.etnassoft.com/biblioteca/manual-dehttp://www.etnassoft.c om/biblioteca/manual-de-programacion-arduino programacion-arduino/ /

•

https://docs.google.com/file/d/0B7Ttzlq https://docs.goog le.com/file/d/0B7TtzlqCufECZTc0OTZiNWEtNTZjZi00NzM1 CufECZTc0OTZiNWEtNTZjZi00NzM1LWJiODUtODA4NmZ LWJiODUtODA4NmZ lNjNlZDE0/edit?ddrp=1&pli=1&hl=es#

•

http://tecbolivia.com/index.php/mini-cursos-o http://tecbolivia.co m/index.php/mini-cursos-online-gratuitos/2 nline-gratuitos/27-introduccion-al-lengu 7-introduccion-al-lenguaje-deaje-de programacion-de-arduino programacion-de-ardui no

•

http://www.jcarazo.com/tmp/Arduino_user_manual_es.pdf

•

http://arduinobot.pbworks.com/f/Manu http://arduinobot.p bworks.com/f/Manual+Programacion+Ardu al+Programacion+Arduino.pdf ino.pdf

•

http://arduino.cc/en/pmwiki.php?n= http://arduino.cc /en/pmwiki.php?n=Tutorial/HomePage 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 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ª openFramework (1ª edición). O'Reilly Media. Media. p. 768. 768.ISBN 0596154143.



Banzi, Massimo (24 de marzo de 2009). Getting Started with Arduino (1ª edición). Make Books.. p. 128. ISBN 0596155514. Books



Sitio web Proyecto Arduino (en inglés)



Sitio web Proyecto Arduino (en español con menos contenidos)





Arduino Stack Exchange Exchange sitio de preguntas y respuestas http://www.ardumania.es/wpcontent/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

Tutorial-Material de Apoyo-Arduino

Recommend Documents