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 del Congreso de la República de Guatemala.

- See more at:

http://wikiguate.com.gt/wiki/Ley_de_Derecho_de_Autor_y_Derechos_Conexos_de_Guatemala_(docu

mento)#sthash.P2VIjAIv.dpuf

Este documento ha sido una recopilacion de varias Fuentes sobre ARDUINO, y toda la informacion aqui

presentada son propias del autor. Como también de las fuentes en donde fueron tomadas, en las que se

hizo referencia durante el desarrollo de este documento.

PREFACIO Esta guía de usuario intenta ser una forma de acercarse al diseño y desarrollo de proyectos basados en

Arduino para aquellas personas que nunca han trabajado con él pero que poseen un buen nivel en

programación y electrónica. Por esta razón y para hacerlo fácil, se ha excluido mucha información

existente en Internet y otros manuales para centrarse en los aspectos más básicos de las características

y la programación de Arduino.

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un

entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a

software del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). Las placas

se pueden montar a mano o adquirirse. El entorno de desarrollo integrado libre se puede descargar

gratuitamente.

Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, puede utilizarse

libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.

Este document ha sido desarrollado con el fin de ayudar aquellas personas que estan introduciendo sus

conocimientos en la implementacion de arduino.

http://arduino.cc/

http://es.wikipedia.org/wiki/Arduino

http://mymemory.translated.net/t/Italian/English/arduino-tutorial%3A

http://wikiguate.com.gt/wiki/Ley_de_Derecho_de_Autor_y_Derechos_Conexos_de_Guatemala_(documento)#sthash.P2VIjAIv.dpuf

http://wikiguate.com.gt/wiki/Ley_de_Derecho_de_Autor_y_Derechos_Conexos_de_Guatemala_(documento)#sthash.P2VIjAIv.dpuf

http://arduino.cc/

http://es.wikipedia.org/wiki/Arduino

http://mymemory.translated.net/t/Italian/English/arduino-tutorial%3A

INDICE Portada .......................................................................................................................................................... 1

Ley de Derecho de Autor y Derechos Conexos de Guatemala (documento) ............................................... 2

PREFACIO ...................................................................................................................................................... 2

INDICE ........................................................................................................................................................... 3

INTRODUCCION ............................................................................................................................................. 6

¿Qué es Arduino? ...................................................................................................................................... 6

¿Por qué Arduino? .................................................................................................................................... 6

http://arduino.cc/en/pmwiki.php?n=Guide/Introduction ....................................................................... 7

OBJETIVOS ..................................................................................................................................................... 7

INSTALACION Y CONFIGURACION ................................................................................................................. 8

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

2. INSTALACION .................................................................................................................................... 9

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

ARDUINO UNO: ............................................................................................................................... 11

ARDUINO LEONARDO: ............................................................................................................................ 13

ARDUINO DUE ......................................................................................................................................... 16

ARDUINO YUN ......................................................................................................................................... 19

ARDUINO ROBOT .................................................................................................................................... 21

ARDUINO BOTTOM ROBOT ..................................................................................................................... 24

ARDUINO ESPLORA ................................................................................................................................. 26

ARDUINO MEGA ADK .............................................................................................................................. 28

ARDUINO ETHERNET ............................................................................................................................... 29

ARDUINO MEGA 2560 ............................................................................................................................. 32

ARDUINO MINI ........................................................................................................................................ 35

ARDUINO NANO ...................................................................................................................................... 36

ARDUINO PRO MINI ................................................................................................................................ 37

ARDUINO PRO ......................................................................................................................................... 38

ARDUINO MICRO .................................................................................................................................... 40

ARDUINO FIO .......................................................................................................................................... 41

ARDUINO LILY PAD USB .......................................................................................................................... 42

ARDUINO LILY PAD SIMPLE ..................................................................................................................... 43

LENGUAJE DE PROGRAMACION ARDUINO ................................................................................................. 44

Estructuras ...................................................................................................................................... 44

Variables.......................................................................................................................................... 44

Operadores matemáticos, lógicos y booleanos .............................................................................. 44

Estructuras de control (Condicionales y ciclos) .............................................................................. 44

Funciones ................................................................................................................................ 44

ESTRUCTURA DE UN PROGRAMA DESARROLLADO PARA ARDUINO .......................................................... 45

setup() ..................................................................................................................................................... 45

loop() ....................................................................................................................................................... 46

funciones ................................................................................................................................................. 46

Comentarios Multilinea .......................................................................................................................... 47

Comentarios Simples .............................................................................................................................. 47

Variables ................................................................................................................................................. 47

CONSTANTES ........................................................................................................................................... 48

Tipos De Datos ........................................................................................................................................ 48

byte ..................................................................................................................................................... 48

int ........................................................................................................................................................ 48

long ..................................................................................................................................................... 49

float ..................................................................................................................................................... 49

arrays................................................................................................................................................... 49

OPERADORES .......................................................................................................................................... 51

Sentencias condicionales ........................................................................................................................ 52

if (si condicional) ................................................................................................................................. 52

if… else (si….. sino ..) ........................................................................................................................... 52

for ........................................................................................................................................................ 53

while .................................................................................................................................................... 54

do… while ............................................................................................................................................ 55

Entradas y salidas digitales y analógicas ................................................................................................. 56

Función pinMode(pin, mode) ............................................................................................................. 56

Función digitalRead(pin) ..................................................................................................................... 56

Funcion digitalWrite(pin, value) ......................................................................................................... 56

Función analogRead(pin) .................................................................................................................... 56

Función analogWrite(pin, value) ......................................................................................................... 56

Funciones de tiempo ........................................................................................................................... 56

delay(ms) ......................................................................................................................................... 56

millis() .............................................................................................................................................. 56

min(x,y). max(x,y). ........................................................................................................................... 56

Funciones de generación aleatoria ..................................................................................................... 57

randomSeed(seed). ......................................................................................................................... 57

random(max), random(min, max). ................................................................................................. 57

COMUNICACIÓN SERIAL.......................................................................................................................... 57

BEGIN() ................................................................................................................................................ 58

END() ................................................................................................................................................... 59

AVAILABLE() ........................................................................................................................................ 59

READ() ................................................................................................................................................. 60

FLUSH() ................................................................................................................................................ 61

PRINT() ................................................................................................................................................ 61

PRINTL() ............................................................................................................................................... 63

WRITE() ............................................................................................................................................... 64

PROBLEMAS COMUNES .............................................................................................................................. 65

INSTALACION DE DRIVERS ...................................................................................................................... 65

CONCLUSIONES ........................................................................................................................................... 70

BIBLIOGRAFIA .............................................................................................................................................. 70

INTRODUCCION

¿Qué es Arduino?

Arduino es una herramienta para la toma de computadoras que pueden detectar y controlar más del

mundo físico que el equipo de escritorio. Es una plataforma de computación física de código abierto

basado en una placa electronica simple, y un entorno de desarrollo para escribir software para la placa.

Arduino se puede utilizar para desarrollar objetos interactivos, teniendo las entradas de una variedad de

interruptores o sensores, y el control de una variedad de luces, motores y otras salidas físicas. Proyectos

de Arduino pueden ser autónomos, o pueden comunicarse con el software que se ejecuta en el

ordenador (por ejemplo, Flash, Processing,MaxMSP.) Las tablas se pueden montar a mano o comprados

preensamblado; el IDE de código abierto se puede descargar de forma gratuita.

El lenguaje de programación Arduino es una implementación de cableado, una plataforma similar

computación física, que se basa en el entorno de programación multimedia de procesamiento.

¿Por qué Arduino?

Hay muchos otros microcontroladores y plataformas de microcontroladores disponibles para la

computación física.Parallax Basic Stamp, de Netmedia BX-24, Phidgets, Handyboard del MIT, y muchos

otros ofrecen una funcionalidad similar. Todas estas herramientas toman los detalles sucios de

programación de microcontroladores y se envuelve en un paquete fácil de usar. Arduino también

simplifica el proceso de trabajar con los microcontroladores, pero ofrece algunas ventajas para los

profesores, estudiantes y aficionados interesados sobre otros sistemas:

Asequible - placas Arduino son relativamente baratos en comparación con otras plataformas de

microcontroladores. La versión menos costosa del módulo Arduino puede ser montada a mano, e

incluso los módulos de Arduino premontados cuestan menos de $ 50

Multiplataforma - El software de Arduino funciona en sistemas operativos Windows, Macintosh OSX y

Linux. La mayoría de los sistemas de microcontroladores están limitados a Windows.

Entorno de programación simple, clara - El entorno de programación de Arduino es suficiente para los

usuarios avanzados que aprovechan así de fácil uso para los principiantes, pero flexible. Para los

profesores, se basa convenientemente en el entorno de programación Processing, por lo que los

estudiantes aprenden a programar en ese entorno estarán familiarizados con la apariencia de Arduino

El código abierto y extensible en software El software de Arduino se publica como herramientas de

código abierto, disponible para la extensión por programadores experimentados. El lenguaje puede

ampliarse a través de librerías C ++, y la gente con ganas de entender los detalles técnicos pueden dar el

salto de Arduino para el lenguaje de programación AVR C en la que se basa. Del mismo modo, puede

agregar código AVR-C directamente en sus programas de Arduino si quieres.

El código abierto y el hardware extensible - El Arduino se basa en de

Atmel ATMEGA8 y ATmega168 microcontroladores. Los planes para los módulos están publicados bajo

una licencia de Creative Commons, por lo que los diseñadores de circuitos con experiencia pueden hacer

su propia versión del módulo, ampliándolo y mejorándolo. Incluso los usuarios con poca experiencia

pueden construir la versión tablero del módulo con el fin de entender cómo funciona y ahorrar dinero.

http://arduino.cc/en/pmwiki.php?n=Guide/Introduction

http://arduino.cc/en/Main/Software

http://arduino.cc/en/pmwiki.php?n=Guide/Introduction#

http://arduino.cc/en/Reference/HomePage

OBJETIVOS Conocer el funcionamiento de las cosas es algo que nos hemos planteado desde el inicio de los tiempos;

hoy en día nos enfrentamos a una realidad donde abundan la automatización, la domótica

(automatización de las casas y edificios), la interacción de las personas con las máquinas, la electrónica,

la mecánica y la programación.

Conocer el funcionamiento de las cosas es algo que nos hemos planteado desde el inicio de los tiempos;

hoy en día nos enfrentamos a una realidad donde abundan la automatización, la domótica

automatización de las casas y edificios), la interacción de las personas con las máquinas, la electrónica,

la mecánica y la programación.

El propósito de esta guía es abordar el concepto de computación física que es la capacidad de

interacción y comunicación de una máquina con los humanos, usando sensores y actuadores. Las

decisiones de esto las va a tomar un microcontrolador que se encuentra ubicado en la placa Arduino. La

tarjeta Arduino es el corazón de la presente guía.

Conocer la plataforma Arduino como una herramienta para la experimentación de domótica mediante

el diseño de dispositivos digitales interactivos. Aprender los conceptos básicos de programación y

electrónica necesarios para el desarrollo de aplicaciones y dispositivos interactivos simples.


http://arduino.cc/en/Main/Software


http://arduino.cc/en/Reference/HomePage

INSTALACION Y CONFIGURACION 1. DESCARGA:

Inicialmente necesitaremos visitor la pagina official de ARDUINO para proceder a descargar el

IDE oficial para poder desarrollar el código que necesitaremos implementar para el uso de

nuestro hardware. La pagina oficial del sitio es www.arduino.cc o podremos encontrar la pagina

mediante un buscador web.

En la pagina oficial podremos encontrar información sobre ARDUINO, y nos ubucaremos en la

pestana de descarga de la aplicación para poder obtener el IDE oficial. En esta pestana

encontraremos las versiones disponibles para el IDE de ARDUINO. Será en base a nuestra

conveniencia el que queramos descargar, preferiblemente es descargar una versión estable del

IDE.

http://www.arduino.cc/

En esta caso procederemos a descargar la versión ARDUINO IDE 1.0.5, que es una versión

estable de este IDE.

2. INSTALACION

Esta plataforma esta disponible tanto para Windows,Linux como para MacOS. Por lo que este

software esta creado para varios sistemas, de esta manera no tendremos ningún problema en el

poder implementar nuestro código para nuestra hardware ARDUINO.

Descargamos el instalador para Windows que es en este caso. Y procedemos a instalar el IDE.

Aceptamos los términos y políticas. Luego empezamos la instalación del software.

Seleccionamos e instalamos todos los componentes necesarios para para que el software y la

conexión con nuestro hardware ARDUINO funcionen correctamente.

Seleccionamos la ubicación donde será instalado el software y esperamos a que termine el

progreso de instalación.

Cuando el proceso de instalación haya concluido podremos cerrar la ventana.

Ahora ya podremos ejecutar el software mediante el acceso directo creado automáticamente en

el escritorio o buscando el software en el bloque de programas instalados.

Y la ventana principal del software es la siguiente, en esta ventana ya podremos crear o editar

proyectos de ARDUINO, y poder hacer pruebas.

Mas adelante veremos el uso y estructura del lenguaje ARDUINO , como también la manera de

implementarlo en nuestro hardware.

TIPOS ARDUINO

ARDUINO UNO:

El Arduino Uno es una placa electronica basada en el ATmega328 .Cuenta con 14 pines digitales

de entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 6 entradas analógicas,

un 16 MHz resonador cerámico, una conexión USB, un conector de alimentación, un header

ICSP, y un botón de reinicio. Contiene todo lo necesario para apoyar el microcontrolador; basta

con conectarlo a un ordenador con un cable USB o el poder con un adaptador o la batería AC-to-

DC para empezar.

El Uno se diferencia de todas las demás placas en que no utiliza el chip controlador de USB a

serial FTDI. En lugar de ello, cuenta con la Atmega16U2 ( Atmega8U2 hasta la versión R2)

programado como un convertidor de USB a serie.

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

La placa arduino tiene la siguiente apariencia:

http://arduino.cc/en/Main/arduinoBoardUno

Arduino uno R3 Frontal Arduino uno R3 Atrás.

A continuacion se mostrara las partes de ARDUINO UNO.

Empezando según las agujas del reloj:

Terminal de referencia analógica (naranja)

Tierra digital (verde claro)

Terminales digitales 2-13 (verde)

Terminales digitales 0-1/ E/S serie - TX/RX (verde oscuro) - Estos pines no se pueden utilizar

como e/s digitales (digitalRead() y digitalWrite()) si estás utilizando comunicación serie (por

ejemplo Serial.begin).

Botón de reinicio - S1 (azul oscuro)

Programador serie en circuito "In-circuit Serial Programmer" o "ICSP" (azul celeste).

Terminales de entrada analógica 0-5 (azul claro)

Terminales de alimentación y tierra (alimentación: naranja, tierras: naranja claro)

Entrada de alimentación externa (9-12VDC) - X1 (rosa)

Selector de alimentación externa o por USB (coloca un jumper en los dos pines mas cercanos de

la alimentación que quieras) - SV1 (púrpura). En las versiones nuevas de Arduino la selección de

alimentacion es automática por lo que puede que no tengas este selector.

USB (utilizado para subir programas a la placa y para comunicaciones serie entre la placa y el

ordenador; puede utilizarse como alimentación de la placa) (amarillo)

Consultado en: http://www.menosmedia.org/spip.php?article43

CARACTERISTICAS PRINCIPALES ARDUINO UNO

Microcontrolador: ATmega328

Voltaje de funcionamiento: 5 V

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

Pines de entradas análogas: 6

Corriente DC por cada pin I/O: 40 mA

Corriente DC en el pin de 3.3 V: 50 mA

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

SRAM: 2 KB (ATmega328)

EEPROM: 1 KB (ATmega328)

Velocidad de reloj: 16 MHz

ARDUINO LEONARDO:

El Arduino Leonardo es una placa electronica basada en el ATMEGA32U4. Tiene 20 pines digitales de

entrada / salida (de los cuales 7 puede utilizarse para salidas PWM y 12 entradas como analógicas), un

16 MHz oscilador de cristal, una conexión micro USB, un conector de alimentación, un header ICSP, y un

botón de reinicio. Contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a

un ordenador con un cable USB o el poder con un adaptador o la batería AC-to-DC para empezar.

El Leonardo difiere de todas las placas anteriores en que el ATMEGA32U4 ha incorporado en la

comunicación USB, eliminando la necesidad de un procesador secundario. Esto permite que el Leonardo

aparezca a una computadora conectada como un ratón y el teclado, además de una virtual (CDC) de

puerto serie / COM. También tiene otras implicaciones para el comportamiento de la placa.

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

http://www.menosmedia.org/spip.php?article43

http://arduino.cc/en/Main/arduinoBoardLeonardo

La placa ARDUINO LEONARDO tiene la siguiente apariencia:

Arduino Leonardo Frontal Arduino Leonardo Atrás

Arduino Leonardo Frontal sin adaptadores para pines

A continuación se presentan las partes de ARDUINO LEONARDO

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

CARACTERISTICAS PRINCIPALES ARDUINO LEONARDO:

Microcontrolador: ATmega32u4


Pines I/O digitales: 20

Canales PWM: 7




Memoria Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader

SRAM: 2 KB (ATmega32u4)

EEPROM: 1 KB (ATmega32u4)


http://makezine.com/2014/03/24/skill-builder-arduino-101-arduinod14/

ARDUINO DUE

El Arduino Due es una placa electronica basada en el Atmel SAM3X8E ARM Cortex-M3 CPU. Es la

primera placa Arduino basado en un microcontrolador núcleo ARM de 32 bits. Cuenta con 54 pines

digitales de entrada / salida (de los cuales 12 pueden utilizarse para salidas PWM), 12 entradas

analógicas, 4 UARTs (puertas seriales), un 84 MHz de reloj, una conexión capaz USB OTG, 2 DAC (de

digital a analógico) , 2 TWI, un conector de alimentación, una cabecera de SPI, un encabezado JTAG, un

botón de reinicio y un botón de borrado.

Advertencia : A diferencia de otras placas Arduino, la placa Arduino Debido funciona a 3.3V. El voltaje

máximo que los pines de E / S pueden tolerar es 3.3V. Proporcionar voltajes más altos, como 5V a un pin

de I / O podría dañar la placa .

La placa contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a un

ordenador con un cable micro-USB o el poder con un adaptador o la batería AC-to-DC para empezar. El

Due es compatible con todos los escudos de Arduino que trabajan a 3.3V y cumplan con el 1,0 Arduino

pinout.

El Due sigue el pinout 1.0:

TWI: SDA y SCL pasadores que están cerca al pin AREF.

El pasador de instrucción IOREF que permite un blindaje conectado con la configuración adecuada para

adaptarse a la tensión proporcionada por la junta. Esto permite la compatibilidad escudo con un tablero

de 3.3V como las tarjetas basadas en AVR Due y que operan a 5V.

Un pin sin conectar, reservado para un uso futuro.

Beneficios del nucleo ARM

Arduino Due tiene un núcleo ARM de 32 bits que puede superar las juntas típicas de microcontroladores

de 8 bits. Las diferencias más significativas son:

Un núcleo de 32 bits, que permite operaciones en 4 bytes de datos de ancho dentro de un único

reloj de la CPU.

Reloj del CPU en 84Mhz.

96 Kbytes de SRAM.

512 Kbytes de memoria flash para el código.

un controlador de DMA, que puede aliviar la CPU de hacer tareas 16ntensives de memoria.

La apariencia de Arduino Due es la siguiente:

Arduino Due Frontal

Arduino Due Atrás

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

A continuación se presentan las partes de ARDUINO DUE

http://arduino.cc/en/Main/arduinoBoardDue

Consultado en: http://tronixlabs.com/arduino/boards/due/freetronics-etherdue-arduino-due-

compatible-with-ethernet/

CARACTERISTICAS PRINCIPALES ARDUINO DUE

Microcontrolador: AT91SAM3X8E

Voltaje de funcionamiento: 3.3 V



Corriente DC total en todos los pines I/O: 130 mA

Corriente DC en el pin de 5 V: 800 mA


Memoria Flash: 512 KB disponibles para las aplicaciones de usuario.

SRAM: 96 KB (dos bancos: 64KB Y 32 KB)


http://tronixlabs.com/arduino/boards/due/freetronics-etherdue-arduino-due-compatible-with-ethernet/

http://tronixlabs.com/arduino/boards/due/freetronics-etherdue-arduino-due-compatible-with-ethernet/

ARDUINO YUN

El Arduino Yun es una placa electronica basada en el ATMEGA32U4 ( ficha técnica ) y el

Atheros AR9331 . El procesador Atheros es compatible con una distribución Linux basada

en OpenWrt llamado OpenWrt -Yun. La junta ha incorporado Ethernet y WiFi apoyo, un puerto USB-A,

ranura para tarjeta micro-SD, 20 entradas digitales / pines de salida (de los cuales 7 puede utilizarse para

salidas PWM y 12 como entradas analógicas), un 16 MHz cristal oscilador, una conexión micro USB, una

cabecera ICSP, y un 3 botones de reposición.

El Yun se distingue de otras placas Arduino en que se puede comunicar con la distribución de Linux a

bordo, que ofrece un sistema de red de gran alcance con la facilidad de Arduino. Además de los

comandos de Linux como cURL, usted puede escribir sus propias conchas y python scripts para las

interacciones fuertes.

El Yun es similar a la Leonardo en que el ATMEGA32U4 se ha incorporado en la comunicación USB,

eliminando la necesidad de un procesador secundario. Esto permite que el yun aparezca a una

computadora conectada como un ratón y el teclado, además de una virtual (CDC) de puerto serie /

COM.

http://www.atmel.com/dyn/resources/prod_documents/7766S.pdf

La apariencia de Arduino Yun es la siguiente:

Arduino Yun Frontal Arduino Yun Atrás

Las partes de Arduino Yun son las siguientes:

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

Microcontrolador AVR Arduino: ATmega32u4



Canales PWM: 7




Memoria Flash: 32 KB (de los cuales 4 KB son utilizados por el bootloader

SRAM: 2.5 KB

EEPROM: 1 KB


Procesador Linux: Atheros AR9331

Arquitectura: MIPS @400MHz

Ethernet: IEEE 802.3 10/100Mbit/s

WiFi: IEEE 802.11b/g/n

USB Tipo A: 2.0

Lector de tarjeta: sólo Micro-SD

RAM: 64 MB DDR2

Memoria Flash:16 MB

Consultado en : http://arduino.cc/en/Main/ArduinoBoardYun?from=Products.ArduinoYUN

ARDUINO ROBOT

El Arduino Robot es el primer Arduino oficial sobre ruedas. El robot tiene dos procesadores, uno en cada

uno de sus dos tableros. La Junta de motor controla los motores y la Junta de Control lee sensores y

decide cómo operar. Cada uno de los tableros es un programable completo placa Arduino utilizando el

Arduino IDE.

Ambos tableros control y motor se tableros de microcontroladores basados en el ATMEGA32U4. El

robot tiene muchas de sus pines asignadas a los sensores y actuadores de a bordo.

Programación del robot es similar al proceso con el Arduino Leonardo. Ambos procesadores han

incorporado en la comunicación USB, eliminando la necesidad de un procesador secundario. Esto

permite que el robot que aparezca a un ordenador conectado como virtual (CDC) de puerto serie / COM.

Como siempre con Arduino, todos los elementos de la plataforma - hardware, software y

documentación - es de libre acceso y de fuente abierta.

http://arduino.cc/en/Main/ArduinoBoardYun?from=Products.ArduinoYUN

La apariencia de ARDUINO Robot es la Siguiente:

Arduino Robot Top

Arduino Bottom Robot

Las Caracteristicas Principales de cada versión de Arduino Robot Son las Siguientes:

Arduino Robot Top

Caracteristicas:

Microcontrolador: ATMEGA32U4

Voltaje de Funcionamiento: 5V

Voltaje de entrada: 5V

Pines Digitales I/O: 5

Canales PWM: 6

Canales de Entrada Analogica: 4(pines I/O digitales)

Canales Analogicos Multiplexados: 8

Corriente DC por Pin I/O: 40mA

Memoria Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque

SRAM: 2,5 KB ( ATMEGA32U4 )

EEPROM (interna): 1 KB ( ATMEGA32U4 )

EEPROM (externa): 512 Kbit ( I2C )

Velocidad del Reloj: 16MHz

Teclado: 5 Teclas

Perilla: potenciómetro adjunto al pin analógico

LCD colores: Comunicación SPI

Lector de Tarjetas: Formato FAT16

Altavoz: 8 Ohm

Brujula digital: proporciona la desviación desde el norte geográfico en grados

I2C puertos de soldadura: 3

Áreas de prototipos: 4

Las partes de ARDUINO ROBOT TOP:

ARDUINO BOTTOM ROBOT

Las características principales de Arduino Bottom Robot son las Siguientes:

Microcontrolador: ATMEGA32U4

Voltaje de funcionamiento: 5V

Voltaje de entrada: 9V para el cargador de batería

Ranura de la batería AA: 4 alcalinas o NiMH baterías recargables

Digital pines I / O: 4

Canales PWM: 1

Pines de entrada analógica: 4 (de los pines I/O digitales)

Corriente DC por pin I/O: 40 mA

Convertidor DC-DC: genera 5V para alimentar todo el robot

Memoria Flash: 32 KB ( ATMEGA32U4 ) de los cuales 4 KB utilizado por gestor de arranque

SRAM: 2,5 KB ( ATMEGA32U4 )

EEPROM: 1 KB ( ATMEGA32U4 )

Velocidad del Reloj: 16 MHz

Trimmer: Para calibracion de movimiento.

Línea de IR sensors: 5

I2C puertos de soldadura: 1

Áreas de prototipos: 2

Las partes de ARDUINO BOTTOM ROBOT son las siguientes:

Arduino Bottom Robot Frontal

Arduino Bottom Robot Atrás

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

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:



Memoria Flash: 32 KB de los cuales 4 KB son utilizados por el bootloader

SRAM: 2.5 KB

EEPROM: 1 KB


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:

http://arduino.cc/en/Main/arduinoBoardEsplora

Arduino Mega ADK R3 Frontal

Las características principales de este hardware son:






Corriente DCen el pin de 3.3 V: 50 mA


SRAM: 8 KB

EEPROM: 4 KB


Consultado en: http://arduino.cc/en/Main/ArduinoBoardMegaADK?from=Main.ArduinoBoardADK

ARDUINO ETHERNET

La Arduino Ethernet es una placa electronica basada en el ATmega328. Cuenta con 14 pines digitales de

entrada / salida, 6 entradas analógicas, un 16 MHz oscilador de cristal, un RJ45 de conexión, un conector

de alimentación, un header ICSP, y un botón de reinicio.

http://arduino.cc/en/Main/ArduinoBoardMegaADK?from=Main.ArduinoBoardADK

NB: Los contactos 10, 11, 12 y 13 están reservados para la interfaz con el módulo Ethernet y no debe ser

utilizado de otra manera. Esto reduce el número de pines disponibles a 9, con 4 disponibles como salidas

PWM.

Una alimentación opcional en el módulo Ethernet se puede agregar a la tarjeta también.

La Ethernet se diferencia de otras placas, ya que no tiene un chip integrado controlador de USB a serie,

pero tiene una interfaz Wiznet Ethernet. Esta es la misma interfaz que se encuentra en el escudo

Ethernet.

Un lector de tarjetas microSD a bordo, que se puede utilizar para almacenar archivos para servir a través

de la red, es accesible a través de la Biblioteca SD. Pin 10 se reserva para la interfaz Wiznet, SS para la

tarjeta SD está en el pin 4.

La cabecera de la programación serial de 6 pines es compatible con la serie USB adaptador y también

con los cables USB FTDI o con Sparkfun y tableros Adafruit estilo FTDI básicos de USB a serial de

ruptura. Cuenta con soporte para rearme automático, permitiendo bocetos que se cargan sin necesidad

de pulsar el botón de reinicio en el tablero. Cuando se conecta a un adaptador USB a serie, el Arduino

Ethernet es alimentado desde el adaptador.

El Revisión 3 de la junta directiva introduce los 1,0 pinout estandarizados, que consisten en:

SDA añadido y pines SCL que están cerca de la pin AREF y otros dos nuevos pernos colocados

cerca del pin de RESET, esto será la oportunidad de escudo que I2C uso o componentes de

inmersión recíproca para ser compatible con todas las placas Arduino;

la instrucción IOREF que permita que los escudos para adaptarse al voltaje suministrado desde

la pizarra. Los escudos que utilizan el pin instrucción IOREF serán compatibles tanto con la placa

que utilizan el AVR, que operan con 5V y con el Arduino Debido que operan con 3.3V. Junto al

pin instrucción IOREF hay un pin no está conectado, que se reserva para usos futuros.

La apariencia de ARDUINO ETHERNET es la siguiente:

http://arduino.cc/en/Main/USBSerial

Arduino Ethernet R3 Frontal

Arduino Ethernet R3 Atrás

Las características principales de Arduino Ethernet son las siguientes:







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




Controlador embebido Ethernet W5100 TCP/IP

Tarjeta MicroSD, con adaptadores activos de voltaje

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

ARDUINO MEGA 2560

El Arduino Mega 2560 es una placa electronica basada en el Atmega2560 . Cuenta con 54 pines digitales

de entrada / salida (de los cuales 15 se pueden utilizar como salidas PWM), 16 entradas analógicas,

4 UARTs (puertas seriales), un 16 MHz del oscilador de cristal, una conexión USB, un conector de

alimentación, un header ICSP, y un botón de reinicio. Contiene todo lo necesario para apoyar el

microcontrolador; basta con conectarlo a un ordenador con un cable USB o el poder con un adaptador o

la batería AC-to-DC para empezar. La Mega es compatible con la mayoría de los escudos diseñados para

el Arduino Duemilanove o Diecimila.

El Mega 2560 es una actualización de la Mega Arduino , a la que sustituye.

El Mega2560 difiere de todas las placas anteriores en que no utiliza el chip controlador de USB a serial

FTDI. En lugar de ello, cuenta con la ATmega16U2 ( ATmega8U2 en las juntas de revisión 1 y revisión 2)

programado como un convertidor de USB a serie.

Revisión 2de la junta Mega2560 tiene una resistencia tirando de la línea 8U2 HWB a tierra, por lo que es

más fácil de poner en modo DFU .

Revisión 3 de la Junta tiene las siguientes características nuevas:

pinout: SDA añadido y pines SCL que están cerca al pin AREF y otros dos nuevos pernos

colocados cerca del pin de RESET, la instrucción IOREF que permiten a los escudos para

adaptarse al voltaje suministrado desde la pizarra. En el futuro, los escudos serán compatibles

tanto con la placa que utilice el AVR, que operan con 5V y con el Arduino Debido que operan con

3.3V. El segundo es un pin no está conectado, que se reserva para usos futuros.

http://arduino.cc/en/Main/ArduinoBoardEthernet

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:










Velocidad del reloj: 16 MHz

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

http://arduino.cc/en/Main/arduinoBoardMega2560

ARDUINO MINI La Arduino Mini es una pequeña placa de desarrollo originalmente basado en el ATmega168 , pero

ahora suministra con el 328, destinado a circular en paneras y cuando el espacio es un bien

escaso. Cuenta con 14 pines digitales de entrada / salida (de los cuales 6 pueden utilizarse para salidas

PWM), 8 entradas analógicas y un 16 MHzoscilador de cristal. Se puede programar con el adaptador de

serie USB u otro USB o RS232 a TTL adaptador serie.

El nuevo Mini (revisión 05) tiene un nuevo paquete para el ATmega328 , que permite a todos los

componentes que estar en la parte superior del tablero. También tiene un botón de reinicio a bordo. La

nueva versión cuenta con la misma configuración de pines como la revisión 04.

Advertencia : No encienda el mini Arduino con más de 9 voltios, o conecte la alimentación al revés:

probablemente sera danado.

La apariencia de Arduino Mini es la siguiente:

Arduino Mini Frontal

Arduino Mini Atrás

Las características principales son:







SRAM: 2 KB

EEPROM: 1 KB


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.


Arduino Nano Frontal

Arduino Nano Atrás

http://www.arduino.cc/en/Main/ArduinoBoardMini

Las partes del Hardware son las siguientes:

Las características Principales son:







SRAM: 1 KB

EEPROM: 512 bytes


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

ARDUINO PRO MINI El Arduino Pro Mini es una placa electronica basada en el ATmega168. Cuenta con 14 pines digitales de

entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 8 entradas analógicas, un

resonador de a bordo, un botón de reinicio, y agujeros para el montaje de cabezales de pin. Un cabezazo

de seis pines se puede conectar a un cable FTDI o tablero del desbloqueo Sparkfun para proporcionar

alimentación USB y la comunicación a la junta.

El Arduino Pro Mini está diseñado para la instalación semi-permanente en objetos o exposiciones. El

tablero viene sin cabeceras premontados, permitiendo el uso de varios tipos de conectores o soldadura

directa de cables. La distribución de los pines es compatible con el Arduino Mini.

Hay dos versiones del Pro Mini. Uno corre a 3.3V y 8 MHz , el otro a 5 V y 16 MHz .

El Arduino Pro Mini fue diseñado y fabricado por Sparkfun Electrónica.

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

La apariencia de ARDUINO PRO MINI es:

Arduino Pro Mini Frontal Arduino Pro Mini Atrás








SRAM: 1 KB

EEPROM: 512 bytes


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

ARDUINO PRO

El Arduino Pro es una placa electronica basada en el ATmega168 o ATmega328. El Pro viene en tanto

3.3V / 8 MHz y 5V / 16 MHz versiones. Cuenta con 14 pines digitales de entrada / salida (de los cuales 6

pueden utilizarse para salidas PWM), 6 entradas analógicas, un conector de alimentación de la batería,

un interruptor de encendido, un botón de reinicio, y agujeros para el montaje de un conector de

alimentación, una cabecera ICSP, y cabezales de pin. Un cabezazo de seis pines se puede conectar a un

cable FTDI o tablero del desbloqueo Sparkfun para proporcionar alimentación USB y la comunicación a

la junta.

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

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:








SRAM: 1 KB

EEPROM:512 bytes


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

ARDUINO MICRO

El Arduino Micro es una placa electronica basada en el ATMEGA32U4, desarrollado en conjunto con

Adafruit . Tiene 20 pines digitales de entrada / salida (de los cuales 7 puede utilizarse para salidas PWM

y 12 entradas como analógicas), un 16 MHz del oscilador de cristal, una conexión micro USB, un header

ICSP, y un botón de reinicio.Contiene todo lo necesario para apoyar el microcontrolador; basta con

conectarlo a un ordenador con un cable micro USB para empezar. Tiene un factor de forma que le

permite ser fácilmente colocado en un circuito.

El Micro es similar a la Arduino Leonardo en que el ATMEGA32U4 se ha incorporado en la comunicación

USB, eliminando la necesidad de un procesador secundario. Esto permite que el micro que aparezca a

una computadora conectada como un ratón y el teclado, además de una virtual (CDC) de puerto serie /

COM.

La apariencia de Hardware es la siguiente:

Arduino Micro frontal

Arduino Micro atrás

Las características principales del hardware son las siguientes:




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

Canales PWM: 7




Memoria Flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el bootloader

SRAM: 2.5 KB (ATmega32u4)

EEPROM: 1 KB (ATmega32u4)

Velocidad de reloj: 16 MHz Consultado en: http://arduino.cc/en/Main/arduinoBoardMicro

ARDUINO FIO

El Arduino Fio es una placa electronica basada en el ATmega328P funciona a 3.3V y 8 MHz . Cuenta con

14 pines digitales de entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 8 entradas

analógicas, un resonador de a bordo, un botón de reinicio, y agujeros para el montaje de cabezales de

pin. Tiene conexiones para una batería de polímero de litio e incluye un circuito de carga a través de

USB. Un XBee socket está disponible en la parte inferior del tablero.

El Arduino Fio está diseñado para aplicaciones inalámbricas. El usuario puede subir sketches con un

cable FTDI o tablero del desbloqueo Sparkfun. Además, mediante el uso de un USB-Hoy en

modificado XBee adaptador tales como XBeeExplorador de USB, el usuario puede subir bocetos de

forma inalámbrica. El tablero viene sin cabeceras premontados, permitiendo el uso de varios tipos de

conectores o soldadura directa de cables.

El Arduino Fio fue diseñado por Shigeru Kobayashi y Sparkfun Electrónica, y fabricada

por Sparkfun Electrónica.

La apariencia del Hardware es la siguiente:

Arduino Fio Frontal


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

Microcontrolador: ATmega328P






SRAM: 2 KB

EEPROM: 1 KB


Consultado en : http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardFio

ARDUINO LILY PAD USB

El LilyPad Arduino USB es una placa electronica basada en el ATMEGA32U4. Cuenta con 9 pines digitales

de entrada / salida (de los cuales 4 pueden utilizarse para salidas PWM y 4 entradas analógicas), como

un niño de 8 MHzresonador, una conexión micro USB, un conector JST de 3.7V LiPo batería y un botón

de reinicio. Contiene todo lo necesario para apoyar el microcontrolador; basta con conectarlo a un

ordenador con un cable USB o el poder con una batería para empezar.

El LilyPad Arduino USB difiere de anteriores LilyPad tableros en que el ATMEGA32U4 ha incorporado en

la comunicación USB, eliminando la necesidad de un adaptador independiente-USB a serie. Esto permite

que la LilyPad Arduino USB aparezca a una computadora conectada como un ratón y el teclado, además

de una virtual (CDC) de puerto serie / COM.


http://arduino.cc/en/pmwiki.php?n=Main/ArduinoBoardFio

Arduino Lily Pad USB Frontal Arduino Lily Pad USB Atrás





Canales PWM: 4




SRAM: 2.5 KB

EEPROM: 1 KB


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.

http://arduino.cc/en/Main/ArduinoBoardLilyPadUSB


Arduino Lily Pad simple Frontal Arduino Lily Pad simple atrás



Voltaje de funcionamiento: 2.7-5.5 V





SRAM: 2 KB

EEPROM: 1 KB


LENGUAJE DE PROGRAMACION ARDUINO Arduino se programa en el lenguaje de alto nivel C/C++ y generalmente tiene los siguiente componentes

para elaborar el algoritmo:

Estructuras

Variables

Operadores matemáticos, lógicos y booleanos

Estructuras de control (Condicionales y ciclos)

Funciones

ESTRUCTURA DE UN PROGRAMA DESARROLLADO PARA ARDUINO La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al

menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen

declaraciones, estamentos o instrucciones.

void setup()

{

estamentos;

}

void loop()

{

estamentos;

}

En donde setup() es la parte encargada de recoger la configuración y loop() es la que contienen el

programa que se ejecutará cíclicamente (de ahí el termino loop –bucle-). Ambas funciones son

necesarias para que el programa trabaje.

La función de configuración debe contener la declaración de las variables. Es la primera función a

ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para configurar o inicializar pinMode (modo

de trabajo de las E/S), configuración de la comunicación en serie y otras.

La función bucle (loop) siguiente contiene el código que se ejecutara continuamente (lectura de

entradas, activación de salidas, etc) Esta función es el núcleo de todos los programas de Arduino y la que

realiza la mayor parte del trabajo.

setup()

La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los

modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya

declaración que ejecutar. Así mismo se puede utilizar para establecer el estado inicial de las salidas de la

placa.

void setup()

{

pinMode(pin, OUTPUT); // configura el 'pin' como

salida

digitalWrite(pin, HIGH); // pone el ‘pin’ en estado

// HIGH

}

loop()

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se ejecuta

de forma cíclica, lo que posibilita que el programa este respondiendo continuamente ante los

eventosque se produzcan en la placa.

void loop()

{

digitalWrite(pin, HIGH); // pone en uno (on, 5v) el´pin´

delay(1000); // espera un segundo (1000 ms)

digitalWrite(pin, LOW); // pone en cero (off, 0v.) el

delay(1000); // ´pin´

}

funciones

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son

ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado. Las

funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un

programa. Las funciones se declaran asociadas a un tipo de valor. Este valor será el que devolverá la

función, por ejemplo 'int' se utilizará cuando la function devuelva un dato numérico de tipo entero. Si la

función no devuelve ningún valor entonces se colocará delante la palabra “void”, que significa “función

vacía”. Después de declarar el tipo de dato que devuelve la función se debe escribir el nombre de la

función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben pasar a la función

para que se ejecute.

tipo nombreFunción(parámetros)

{

instrucciones;

}

Comentarios Multilinea

Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el programa

que se utilizan para las descripciones del código o comentarios que ayudan a comprender el programa.

Comienzan con / * y terminan con * / y pueden abarcar varias líneas.

/* esto es un bloque de comentario no se debe olvidar

cerrar los comentarios estos deben estar equilibrados */

Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de

Arduino pueden ser utilizados con generosidad. También pueden utilizarse para "comentar" bloques de

código con el propósito de anotar informaciones para depuración y hacerlo mas comprensible para

cualquiera.

Nota: Dentro de una misma línea de un bloque de comentarios no se puede escribir otra bloque de

comentarios (usando /*..*/).

Comentarios Simples

Una línea de comentario empieza con / / y terminan con la siguiente línea de código. Al igual que los

comentarios de bloque, los de línea son ignoradas por el programa y no ocupan espacio en la memoria.

// esto es un comentario

Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más

información acerca de lo que hace esta o para recordarla más adelante.

Variables

Una variable debe ser declarada y opcionalmente asignada a un determinado valor. En la declaración de

la variable se indica el tipo de datos que almacenará (int, float, long)

Tipo Nombre; o tipo nombre=valor;

Ejemplo:

int inputVariable = 0;

Una variable puede ser declarada en el inicio del programa antes de setup(), localmente a una

determinada función e incluso dentro de un bloque como pueda ser un bucle. El sitio en el que la

variable es declarada determina el ámbito de la misma. Una variable global es aquella que puede ser

empleada en cualquier función del programa. Estas variables deben ser declaradas al inicio del

programa (antes de la función setup()).

int v; // 'v' es visible en todo el programa

void setup() {

// no se requiere setup

}

void loop() {

for (int i=0; i<20;) // 'i' es visible solo en el bucle

i++;

float f; // 'f' es visible únicamente en la función loop()

}

CONSTANTES

• HIGH | LOW

• INPUT | OUTPUT

• true | false

• Constantes Numéricas

Tipos De Datos

byte

Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255.

byte unaVariable = 180; // declara 'unaVariable' como

// de tipo byte

int

Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales

comprendidos en el rango 32,767 to -32,768.

int unaVariable = 1500; // declara 'unaVariable' como

// una variable de tipo entero

Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como

consecuencia de una operación.

Por ejemplo, si x = 32767 y una posterior declaración agrega 1 a x, x = x+ 1 entonces el valor se x pasará

a ser -32.768. (algo así como queel valor da la vuelta).

long

El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin

decimales que se encuentran dentro del rango -2147483648 a 2147483647.

long unaVariable = 90000; // declara 'unaVariable' como

// de tipo long

float

El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los números

de punto flotante tienen una mayor resolución que los de 32 bits con un rango comprendido

3.4028235E +38 a +38-3.4028235E.

float unaVariable = 3.14; // declara 'unaVariable' como

// de tipo flotante

Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las

comparaciones. Los calculus matemáticos de punto flotante son también mucho más lentos que los del

tipo de números enteros, por lo que debe evitarse su uso si es posible.

arrays

Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser

recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el

que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0. Un array

tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado.

int miArray[] = {valor0, valor1, valor2...}

Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño y

posteriormente, asignar valores a una posición especifica:

int miArray[5]; // declara un array de enteros de 6

// posiciones

miArray[3] = 10; // asigna l valor 10 a la posición 4

Para leer de un array basta con escribir el nombre y la posición a leer:

x = miArray[3]; // x ahora es igual a 10 que está en

// la posición 3 del array

Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que la variable de incremento

del contador del bucle se utilize como índice o puntero del array. El siguiente ejemplo usa una matriz

para el parpadeo de un LED.

Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la posición

de índice 0 en la serie que hemos escrito dentro del array parpadeo[], en este caso 180, que se envía a

la salida analógica tipo PWM configurada en el PIN10, se hace una pausa de 200 ms y a continuación se

pasa al siguiente valor que asigna el índice “i”.

int ledPin = 10; // LED en el PIN 10

byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60};

// array de 8 valores

void setup()

{

pinMode(ledPin, OUTPUT); // configura la salida

}

void loop()

{

for(int i=0; i<7; i++)

{

analogWrite(ledPin, parpadeo[i]);

delay(200); // espera 200ms

}

}

OPERADORES

Empleando variables, valores constantes o componentes de un array pueden realizarse operaciones

aritméticas y se puede utilizar el operador cast para conversión de tipos. Ej. int a = (int)3.5; Además

pueden hacerse las siguientes asignaciones:

x ++. Lo mismo que x = x + 1.

x --. Lo mismo que x = x - 1, or decrements x by -1.

x += y. Lo mismo que x = x + y, or increments x by +y.

x -= y. Lo mismo que x = x - y .

x *= y. Lo mismo que x = x * y.

x /= y. Lo mismo que x = x / y.

Para su utilización en sentencias condicionales u otras funciones Arduino permite utilizar los siguientes

operadores de comparación:

x == y. x es igual a y.

x != y. x no es igual a y.

x < y, x > y, x <= y, x >= y.

Y los siguientes operadores lógicos:

Y lógico: if (x > 0 & 38;& 38; x < 5). Cierto si las dos expresiones lo son.

O lógico: if (x > 0 || y > 0). Cierto si alguna expresión lo es.

NO lógico: if (!x > 0). Cierto si la expresión es falsa.

El lenguaje de Arduino presenta las siguientes constantes predefinidas:

TRUE / FALSE.

HIGH/LOW. Estas constantes definen los niveles de los pines como HIGH o LOW y son empleados

cuando se leen o escriben en las entradas o salidas digitales. HIGH se define como el nivel lógico 1 (ON)

o 5 V. LOW es el nivel lógico 0, OFF, o 0 V.

INPUT/OUTPUT. Constantes empleadas con la función pinMode() para definir el tipo de un pin digital

usado como entrada INPUT o salida OUTPUT. Ej. pinMode(13, OUTPUT);

Sentencias condicionales

El lenguaje de arduino permite realizar sentencias condicionales if, if... else, for, while, do... while. Su

utilización es similar a las funciones correspondientes en C.

if (si condicional)

if es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por

ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de

declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se

cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves, El formato para if

es el siguiente:

if (unaVariable ?? valor)

{

ejecutaInstrucciones;

}

En el ejemplo anterior se compara una variable con un valor, el cual puede ser una variable o constante.

Si la comparación, o la condición entre paréntesis se cumple (es cierta), las declaraciones dentro de los

corchetes se ejecutan. Si no es así, el programa salta sobre ellas y sigue.

Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10), podría parecer que es

valido pero sin embargo no lo es ya que esa expresión asigna el valor 10 a la variable x, por eso dentro

de la estructura if se utilizaría X==10 que en este caso lo que hace el programa es comprobar si el valor

de x es 10.. Ambas cosas son distintas por lo tanto dentro de las estructuras if, cuando se pregunte por

un valor se debe poner el signo doble de igual “==”.

if… else (si….. sino ..)

if… else viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto

otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o hacer

otra cosa si la entrada es baja, usted escribiría que de esta manera:

if (inputPin == HIGH)

{

instruccionesA;

}

else

{

instruccionesB;

}

Else puede ir precedido de otra condición de manera que se pueden establecer varias estructuras

condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente

excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos

condicionales. Recuerde sin embargo qué sólo un conjunto de declaraciones se llevará a cabo

dependiendo de la condición probada:

if (inputPin < 500)

{

instruccionesA;

}

else if (inputPin >= 1000)

{

instruccionesB;

{

else

{

instruccionesC;

}

Nota: Un estamento de tipo if prueba simplemente si la condición dentro del paréntesis es verdadera o

falsa. Esta declaración puede ser cualquier declaración válida. En el anterior ejemplo, si cambiamos y

ponemos (inputPin == HIGH). En este caso, el estamento if sólo chequearía si la entrada especificado

esta en nivel alto (HIGH), o +5v.

for

La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número

determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la

condición. La declaración for tiene tres partes separadas por (;), vemos el ejemplo de su sintaxis:

for (inicialización; condición; expresión)

{

Instrucciones;

}

La inicialización de una variable local se produce una sola vez y la condición se testea cada vez que se

termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las

instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.

El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es inferior a 20 y si es

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

for (int i=0; i<20; i++) // declara i y prueba si es

{ // menor que 20, incrementa i.

digitalWrite(13, HIGH); // enciende el pin 13

delay(250); // espera ¼ seg.

digitalWrite(13, LOW); // apaga el pin 13

delay(250); // espera ¼ de seg.

}

Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados en algunos otros

lenguajes de programación, incluyendo BASIC. Cualquiera de los tres elementos de cabecera puede

omitirse, aunque el punto y coma es obligatorio. También las declaraciones de inicialización, condición y

expresión puede ser cualquier estamento válido en lenguaje C sin relación con las variables declaradas.

Estos tipos de estados son raros pero permiten disponer soluciones a algunos problemas de

programación raras.

while

Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada

entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle.

La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también por el

cambio de un valor en una entrada de un sensor.

while (unaVariable ?? valor)

{

ejecutarSentencias;

}

El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es verdad, ejecuta las

declaraciones dentro de los corchetes y continuará ejecutando el bucle hasta que 'unaVariable' no sea

inferior a 200.

While (unaVariable < 200) // testea si es menor que 200

{

instrucciones; // ejecuta las instrucciones

// entre llaves

unaVariable++; // incrementa la variable en 1

}

do… while

El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición

se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.

do

{

Instrucciones;

} while (unaVariable ?? valor);

El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milisegundos, y luego

continua mientras que el valor de la 'x' sea inferior a 100:

do

{25

x = leeSensor();

delay(50);

} while (x < 100);

Entradas y salidas digitales y analógicas

Función pinMode(pin, mode)

Función usada en la function setup() para configurar un pin dado para comportarse como INPUT o

OUTPUT. Ej. pinMode(pin, OUTPUT); configura el pin número 'pin' como de salida. Los pines de Arduino

funcionan por defecto como entradas, de forma que no necesitan declararse explícitamente como

entradas empleando pinMode().

Función digitalRead(pin)

Lee el valor desde un pin digital específico. Devuelve un valor HIGH o LOW. El pin puede ser especificado

con una variable o una constante (0-13). Ej. v = digitalRead(Pin);

Funcion digitalWrite(pin, value)

Introduce un nivel alto (HIGH) o bajo (LOW) en el pin digital especificado. De nuevo, el pin puede ser

especificado con una variable o una constante 0-13. Ej. digitalWrite(pin, HIGH);

Función analogRead(pin)

Lee el valor desde el pin analógico especificado con una resolución de 10 bits. Esta función solo funciona

en los pines analógicos (0-5). El valor resultante es un entero de 0 a 1023. Los pines analógicos, a

diferencia de los digitales no necesitan declararse previamente como INPUT o OUTPUT.

Función analogWrite(pin, value)

Escribe un valor pseudo-analógico usando modulación por ancho de pulso (PWM) en un pin de salida

marcado como PWM. Esta función está activa para los pines 3, 5, 6, 9, 10, 11. Ej analogWrite(pin, v); //

escribe 'v' en el 'pin' analógico. Puede especificarse un valor de 0 - 255. Un valor 0 genera 0 V en el pin

especificado y 255 genera 5 V. Para valores de 0 a 255, el pin alterna rápidamente entre 0 V y 5 V,

cuanto mayor sea el valor, más a menudo el pin se encuentra en HIGH (5 V). Por ejemplo, un valor de 64

será 0 V tres cuartas partes del tiempo y 5 V una cuarta parte. Un valor de 128 será 0 V la mitad del

tiempo y 5 V la otra mitad. Un valor de 192 será 0 V una cuarta parte del tiempo y 5 V tres cuartas

partes.

Funciones de tiempo

delay(ms)

Realiza una pausa en el programa la cantidad de tiempo en milisegundos especificada en el parámetro

(máximo 1000, mínimo 1).

millis()

Devuelve la cantidad de milisegundos que lleva la placa Arduino ejecutando el programa actual como

un valor long unsigned. Después de de 9 horas el contador vuelve a 0.

min(x,y). max(x,y).

Devuelve el mínimo y el máximo respectivamente de entre sus parámetros.

Funciones de generación aleatoria

randomSeed(seed).

Especifica un valor o semilla como el punto de inicio para la función random(). Este parámetro debe ser

realmente aleatorio y para ello puede emplearse la función millis() o incluso analogRead() para leer

ruido eléctrico desde una entrada analógica.

random(max), random(min, max).

Esta función devuelve un valor aleatorio entre el rango especificado.

COMUNICACIÓN SERIAL

Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros dispositivos. Todas las

placas Arduino tienen al menos un puerto serie (también conocido como UART o USART): Serial. Se

comunica a través de los pines digitales 0 (RX) y 1 (TX), así como con el ordenador mediante USB. Por lo

tanto, si utilizas estas funciones, no puedes usar los pines 0 y 1 como entrada o salida digital.

Puedes utilizar el monitor del puerto serie incorporado en el entorno Arduino para comunicarte con la

placa Arduino. Haz clic en el botón del monitor de puerto serie en la barra de herramientas y selecciona

la misma velocidad en baudios utilizada en la llamada a begin().

La placa Arduino Mega tiene tres puertos adicionales de serie: Serial1 en los pines 19 (RX) y 18 (TX),

Serial2 en los pines 17 (RX) y 16 (TX), Serial3 en los pines 15 (RX) y 14 (TX). Para utilizar estos pines para

comunicarse con el ordenador personal, necesitarás un adaptador USB adicional a serie, ya que no están

conectados al adaptador USB-Serie de la placa Arduino Mega. Para usarlos para comunicarse con un

dispositivo serie externo TTL, conecta el pin TX al pin RX del dispositivo, el RX al pin TX del dispositivo, y

el GND de tu Arduino Mega a masa del dispositivo. (No conectes estos pines directamente a un puerto

serie RS232, que operan a +/- 12V y esto puede dañar la placa Arduino.)

Las funciones predeterminadas que existen para la comunicación en Serial son las siguientes:

• begin()

• end()

• available()

• read()

• flush()

• print()

• println()

• write()

BEGIN()

Descripción : Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos

en serie. Para comunicarse con el computador, utilice una de estas velocidades: 300, 1200, 2400, 4800,

9600, 14400, 19200, 28800, 38400, 57600 o 115200. Sin embargo, puedes especificar otras velocidades -

por ejemplo, para comunicarte a través de los pines 0 y 1 con un componente que requiere una

velocidad de transmisión en particular.

Sintaxis :

Serial.begin(speed)

Solamente en Arduino Mega:

Serial1.begin(speed)



Parámetros

speed: Velocidad en bits por segundo (baudios) - long

Devuelve: nada

Ejemplo:

void setup() {

Serial.begin(9600); // abre el puerto serie y establece la velocidad en 9600 bps

void loop() {}

Ejemplo para Arduino Mega:

// Arduino Mega usando sus 4 puertos serie

// (Serial, Serial1, Serial2, Serial3),

// con diferentes velocidades de datos:

void setup(){

Serial.begin(9600);

Serial1.begin(38400);



Serial.println("Hola ordenador");

Serial1.println("Hola Serial 1");



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()


Serial1.end()

Serial2.end()

Serial3.end()

Parámetros : ninguno

Devuelve : nada

AVAILABLE()

Descripción : Devuelve el número de bytes (caracteres) disponibles para ser leídos por el puerto serie. Se

refiere a datos ya recibidos y disponibles en el buffer de recepción del puerto (que tiene una capacidad

de 128 bytes).

Sintaxis

Serial.available()

Sólo para Arduino Mega:

Serial1.available()

Serial2.available()

Serial3.available()

Parametros :ninguno

Devuelve : el número de bytes disponibles para ser leídos

Ejemplo

int incomingByte = 0; // para los datos de entrada serie

void setup() {

Serial.begin(9600); // abre el puerto serie, establece la velocidad

a 9600 bps

void loop() {

// envía datos solo cuando recibe datos:

if (Serial.available() > 0) {

// lee el byte de entrada:

incomingByte = Serial.read();

// muestra lo que tiene:

Serial.print("He recibido: ");

Serial.println(incomingByte, DEC);

}

Ejemplo Arduino Mega:

void setup() {

Serial.begin(9600);


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()


Serial1.read()

Serial2.read()

Serial3.read()

Parámetros : Ninguno

Devuelve :el primer byte disponible recibido por el puerto serie

(devuelve -1 si no hay datos disponibles) - int

Ejemplo

int incomingByte = 0; // para el byte leido

void setup() {

Serial.begin(9600); // abre el puerto serie a 9600 bps

void loop() {

// envia datos solamente cuando recibe datos

if (Serial.available() > 0) {

// lee el byte entrante:

incomingByte = Serial.read();

// dice lo que ha recibido:

Serial.print("He recibido: ");

Serial.println(incomingByte, DEC);

}

FLUSH()

Descripción : Vacía el búfer de entrada de datos en serie. Es decir, cualquier llamada a Serial.read () o

Serial.available () devolverá sólo los datos recibidos después la llamada más reciente a Serial.flush ().

Sintaxis

Serial.flush()


Serial1.flush()

Serial2.flush()

Serial3.flush()

Parámetros : ninguno

Retorna : ninguno

PRINT()

Descripción : Imprime los datos al puerto serie como texto ASCII. Este comando puede tomar muchas

formas. Los números son impresos mediante un juego de caracteres ASCII para cada dígito. Los valores

de tipo "float" son impresos en forma de dígitos ASCII con dos decimales por defecto. Los valores tipo

"byte" se envían como un único carácter. Los caracteres y las cadenas se envían tal cual.

Por ejemplo:

• Serial.print(78) imprime "78"

• Serial.print(1.23456) imprime "1.23"

• Serial.print(byte(78)) imprime "N" (cuyo código ASCII es 78)

• Serial.print('N') imprime "N"

• Serial.print("Hello world.") imprime "Hello world."

Un segundo parámetro opcional especifica la base (formato) a usar; los valores permitidos son BYTE, BIN

(binarios o base 2), OCT (octales o base 8), DEC (decimales o base 10), HEX (hexadecimales o base 16).

Para números de coma flotante, este parámetro especifica el numero de posiciones decimales a usar.

Por ejemplo:

• Serial.print(78, BYTE) imprime "N"

• Serial.print(78, BIN) imprime "1001110"

• Serial.print(78, OCT) imprime "116"

• Serial.print(78, DEC) imprime "78"

• Serial.print(78, HEX) imprime "4E"

• Serial.println(1.23456, 0) imprime "1"

• Serial.println(1.23456, 2) imprime "1.23"

• Serial.println(1.23456, 4) imprime "1.2346"

Sintaxis

Serial.print(val)

Serial.print(val, format)

Parámetros

val: el valor a imprimir - de cualquier tipo

format: especifica el número de la base (para números enteros) o el número de

posiciones decimales (para números de coma flotante o tipo "float")

Devuelve : Nada

Ejemplo:

/*Usa un bucle FOR para los datos e imprime un número en varios formatos.*/

int x = 0; // variable

void setup() {

Serial.begin(9600); // abre el puerto serie a 9600 bps:

void loop() {

// print labels

Serial.print("SIN FORMATO"); // imprime un texto

Serial.print("\t"); // imprime un tabulado

Serial.print("DEC");

Serial.print("\t");

Serial.print("HEX");

Serial.print("\t");

Serial.print("OCT");

Serial.print("\t");

Serial.print("BIN");

Serial.print("\t");

Serial.println("BYTE");

for(x=0; x< 64; x++){ // solo una parte de la tabla

// imprime en varios formatos:

Serial.print(x); // imprime como codificado ASCII decimal - igual que "DEC"


Serial.print(x, DEC); // imprime como codificado ASCII decimal


Serial.print(x, HEX); // imprime como codificado ASCII hexadecimal


Serial.print(x, OCT); // imprime como codificado ASCII octal


Serial.print(x, BIN); // imprime como codificado ASCII binario


Serial.println(x, BYTE); // imprime el valor en bruto del byte,

// y añade el salto de línea con "println"

delay(200); // espera 200 milisegundos

Serial.println(""); //imprime otro salto de línea

Sugerencias de programación / Problemas conocidos

El último carácter a imprimir se transmite a través del puerto serie después de que Serial.print () ha

regresado.

PRINTL()

Descripción : Imprime los datos al puerto serie como texto ASCII seguido de un retorno de carro (ASCII

13, o '\r') y un carácter de avance de línea (ASCII 10, o '\n'). Este comando tiene la misma forma que

Serial.print ().

Sintaxis

Serial.println(val)

Serial.println(val, format)

Parámetros

val: el valor a imprimir - de cualquier tipo format: especifica el número de la

base (para números enteros) o el número de posiciones decimales (para

números de coma flotante o tipo "float")

Devuelve : Nada

Ejemplo:

Analog input

Lee el pin analógico 0, e imprime su valor por el puerto serie.

int analogValue = 0; // variable para guardar el valor analogico

void setup() {

// abre el puerto serie a 9600 bps:

Serial.begin(9600);

void loop() {

// lee la entrada analogica en el pin 0:

analogValue = analogRead(0);

// imprime el valor en varios formatos:

Serial.println(analogValue); // imprime como ASCII decimal

Serial.println(analogValue, DEC); // imprime como ASCII decimal

Serial.println(analogValue, HEX); // imprime como ASCII hexadecimal

Serial.println(analogValue, OCT); // imprime como ASCII octal

Serial.println(analogValue, BIN); // imprime como ASCII binario

Serial.println(analogValue, BYTE); // imprime el valor del byte

// espera 10 milisegundos antes de la siguiente lectura.

delay(10);

WRITE()

Descripción : Escribe datos binarios en el puerto serie. Estos datos se envían como un byte o una serie

de bytes; para enviar los caracteres que representan los dígitos de un número usar función print () en su

lugar.

Sintaxis

Serial.write(val)

Serial.write(str)

Serial.write(buf, len)

Arduino Mega tambien soporta: Serial1, Serial2, Serial3 (en lugar de Serial)

Parámetros

val: un valor para enviar como un solo byte

str: una cadena 'string' para enviar como una serie de bytes

buf: un 'array' para enviar como una serie de bytes

len: longitud del buffer

contenido de lenguaje arduino consultado en:

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

• http://oni.escuelas.edu.ar/2013/BUENOS_AIRES/1763/materiales/Libro_kit_Basico.pdf

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

• http://www.ardumania.es/wp-

content/uploads/2011/10/Arduino_programing_notebook_ES.pdf

• http://www.etnassoft.com/biblioteca/manual-de-programacion-arduino/

• https://docs.google.com/file/d/0B7TtzlqCufECZTc0OTZiNWEtNTZjZi00NzM1LWJiODUtODA4NmZ

lNjNlZDE0/edit?ddrp=1&pli=1&hl=es#

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

http://oni.escuelas.edu.ar/2013/BUENOS_AIRES/1763/materiales/Libro_kit_Basico.pdf

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

http://www.ardumania.es/wp-content/uploads/2011/10/Arduino_programing_notebook_ES.pdf


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

https://docs.google.com/file/d/0B7TtzlqCufECZTc0OTZiNWEtNTZjZi00NzM1LWJiODUtODA4NmZlNjNlZDE0/edit?ddrp=1&pli=1&hl=es

https://docs.google.com/file/d/0B7TtzlqCufECZTc0OTZiNWEtNTZjZi00NzM1LWJiODUtODA4NmZlNjNlZDE0/edit?ddrp=1&pli=1&hl=es

• http://tecbolivia.com/index.php/mini-cursos-online-gratuitos/27-introduccion-al-lenguaje-de-

programacion-de-arduino

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

• http://arduinobot.pbworks.com/f/Manual+Programacion+Arduino.pdf

• http://arduino.cc/en/pmwiki.php?n=Tutorial/HomePage

PROBLEMAS COMUNES

INSTALACION DE DRIVERS

Nos DIrigiremos a Administrador de Dispositivos para poder instalar correctamente los drivers de

nuestro hardware arduino, En la ventana del Administrador de dispositivos, en "Otros dispositivos" nos

mostrará con admiración "Arduino Uno", pulsaremos con el botón derecho del ratón y seleccionaremos

"Actualizar software de controlador":

http://tecbolivia.com/index.php/mini-cursos-online-gratuitos/27-introduccion-al-lenguaje-de-programacion-de-arduino

http://tecbolivia.com/index.php/mini-cursos-online-gratuitos/27-introduccion-al-lenguaje-de-programacion-de-arduino

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

http://arduinobot.pbworks.com/f/Manual+Programacion+Arduino.pdf

http://arduino.cc/en/pmwiki.php?n=Tutorial/HomePage

Pulsaremos en "Buscar software de controlador en el equipo. Buscar e instalar el software de

controlador de forma manual":

Pulsaremos en el botón "Examinar" para seleccionar la carpeta donde se encuentran los drivers:

Seleccionaremos la carpeta "arduino-0022" (descomprimida anteriormente) y, dentro de esta, la

carpeta "drivers":

Pulsaremos "Siguiente":

El asistente para instalar un nuevo controlador nos mostrará un aviso de seguridad, pulsaremos "Instalar

este software de controlador de todas formas":

Si todo es correcto, el asistente nos habrá instalado el controlador para Arduino UNO y nos mostrará la

siguiente ventana:

En el Administrador de dispositivos de Microsoft Windows 7 nos mostrará el nuevo controlador

instalado, en "Puertos (COM y LPT)". Es importante que anotemos el nombre asignado al puerto COM

para Arduino, en nuestro caso COM3, pues lo necesitaremos seleccionar en el IDE de Arduino:

CONCLUSIONES En el desarrollo de este documento abarcamos gran parte de lo que es ARDUINO, no solo en lo que es el

hardware sino en el manejo del mismo desde la programación ya que esta es el alma del hardware.

Un buen conocimiento en la programación ARDUINO y tener conocimiento de las funciones

predeterminadas que incorpora para su implementación podremos darle un buen funcionamiento al

hardware y este será eficiente.

El manejo de las entradas análogas y digitales de ARDUINO son importantes para el manejo del

hardware, haciendo un buen manejo de las señales el funcionamiento de nuestro proyecto nos dara

buenos resultados.

No solo conocimos los tipos de ARDUINO sino también sus componentes ya que gran parte de estos son

derivados de otras versiones por lo que no varian en gran porcentaje en el numero de componentes en

común. Y la implementación en el desarrollo del software es muy parecido por el comportamiento del

hardware.

En este documento introductorio y tutorial de lo que es arduino abarcamos las partes mas esenciales

pero no se hizo énfasis de los componentes adicionales que pueden ser agregados a nuestros proyectos.

BIBLIOGRAFIA

Oxer, Jonathan; Blemings, Hugh (28 de diciembre de 2009). Practical Arduino: Cool

Projects for Open Source Hardware (1ª edición). Apress. p. 500. ISBN 1430224770.

Noble, Joshua (15 de julio de 2009). Programming Interactivity: A Designer's Guide to

Processing, Arduino, and openFramework (1ª edición). O'Reilly Media.

p. 768.ISBN 0596154143.

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

Books. p. 128. ISBN 0596155514.

Sitio web Proyecto Arduino (en inglés)

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

Arduino Stack Exchange sitio de preguntas y respuestas

http://www.ardumania.es/wp-

content/uploads/2011/10/Arduino_programing_notebook_ES.pdf



http://www.apress.com/book/view/9781430224778

http://www.apress.com/book/view/9781430224778

http://es.wikipedia.org/w/index.php?title=Apress&action=edit&redlink=1

http://es.wikipedia.org/wiki/ISBN

http://es.wikipedia.org/wiki/Especial:FuentesDeLibros/1430224770

http://oreilly.com/catalog/9780596800581/

http://oreilly.com/catalog/9780596800581/

http://es.wikipedia.org/wiki/O%27Reilly_Media



http://www.makershed.com/ProductDetails.asp?ProductCode=9780596155513

http://es.wikipedia.org/w/index.php?title=Make_Books&action=edit&redlink=1

http://es.wikipedia.org/w/index.php?title=Make_Books&action=edit&redlink=1



http://www.arduino.cc/

http://www.arduino.cc/es

http://arduino.stackexchange.com/





Tutorial-Material de Apoyo-Arduino

Documents

Transcript of Tutorial-Material de Apoyo-Arduino