MANUAL DE

PROGRAMACIN
ARDUINO (IDE)
Introduccin al entorno
de Arduino IDE mediante
Arduino UNO Rev 3

Recopilacin hecha por:

Ing. Luis Fernando Franco Guzmn

CONTENIDO
INTRODUCCION................................................................................................................................................. 5
Qu es ARDUINO? ....................................................................................................................................... 5
Por qu ARDUINO? ...................................................................................................................................... 6
HARDWARE ....................................................................................................................................................... 7
Plataforma Arduino ....................................................................................................................................... 7
Escudos (Shields) ........................................................................................................................................... 8
Arduino Uno.................................................................................................................................................. 8
Vista general ............................................................................................................................................. 8
Componentes de la placa Arduino Uno ...................................................................................................... 9
Especificaciones tcnicas (resumen) ........................................................................................................ 10
Alimentacin ........................................................................................................................................... 11
Memoria ................................................................................................................................................. 11
Entradas y Salidas .................................................................................................................................... 11
Comunicacin.......................................................................................................................................... 12
Programacin .......................................................................................................................................... 13
SOFTWARE ...................................................................................................................................................... 14
Arduino Software (IDE) ................................................................................................................................ 14
Conociendo el software Arduino ................................................................................................................. 14
Botones de acceso rpido ........................................................................................................................ 15
Configurar una tarjeta de la familia Arduino ................................................................................................ 16
Cargando mi primer programa hola mundo .............................................................................................. 18
PROGRAMANDO CON ARDUINO ..................................................................................................................... 20
Estructura de un sketch ............................................................................................................................... 20
setup()..................................................................................................................................................... 20
loop() ...................................................................................................................................................... 21
Funciones .................................................................................................................................................... 21
{} entre llaves .......................................................................................................................................... 21
punto y coma ; ........................................................................................................................................ 22
bloques de comentarios /*...*/ ................................................................................................................ 22
// lnea de comentarios ........................................................................................................................... 22
Variables ..................................................................................................................................................... 23

declaracin de variable ............................................................................................................................ 23

utilizacin de la variable .......................................................................................................................... 23
Tipos de datos ............................................................................................................................................. 24
byte ......................................................................................................................................................... 24
int ........................................................................................................................................................... 24
long ......................................................................................................................................................... 24
float ........................................................................................................................................................ 25
arrays ...................................................................................................................................................... 25
Aritmtica ................................................................................................................................................... 25
asignaciones compuestas ........................................................................................................................ 26
operadores de comparacin .................................................................................................................... 26
operadores lgicos .................................................................................................................................. 26
Constantes .................................................................................................................................................. 27
true/false ................................................................................................................................................ 27
high/low .................................................................................................................................................. 27
input/output ........................................................................................................................................... 27
Control de flujo ........................................................................................................................................... 28
if (si condicional) ..................................................................................................................................... 28
if else (si.. sino ..) ................................................................................................................................ 28
for ........................................................................................................................................................... 29
while ....................................................................................................................................................... 29
do while................................................................................................................................................ 30
E/S digital .................................................................................................................................................... 30
pinMode(pin, mode)................................................................................................................................ 30
digitalRead(pin) ....................................................................................................................................... 31
digitalWrite(pin, value) ............................................................................................................................ 31
E/S analgica ............................................................................................................................................... 32
analogRead(pin) ...................................................................................................................................... 32
analogWrite(pin, value) ........................................................................................................................... 32
Control del tiempo ...................................................................................................................................... 33
delay(ms) ................................................................................................................................................ 33
millis() ..................................................................................................................................................... 33
Matemticas ............................................................................................................................................... 34
min(x,y) ................................................................................................................................................... 34
max(x,y) .................................................................................................................................................. 34

Aleatorio ..................................................................................................................................................... 34
randomSeed(seed) .................................................................................................................................. 34
random(max) , random(min, max) ........................................................................................................... 34
Comunicacin Serie ..................................................................................................................................... 35
Serial.begin(rate) ..................................................................................................................................... 35
Serial.println(data) .................................................................................................................................. 35
BIBLIOGRAFA ................................................................................................................................................. 37
Apndice A ...................................................................................................................................................... 38
Esquemtico de Arduino UNO Rev 3 ............................................................................................................ 38

INTRODUCCION
Qu es ARDUINO?
Arduino es una plataforma de electrnica abierta para la creacin de prototipos basada en
software y hardware libres, flexibles y fciles de usar. Est pensado para artistas, diseadores, como
hobby y para cualquiera interesado en crear objetos o entornos interactivos.

Figura 1.1 Arduino UNO Rev 3

Arduino puede sentir el entorno mediante la recepcin de entradas desde una variedad de
sensores y puede afectar a su alrededor mediante el control de luces, motores y otros artefactos. El
microcontrolador de la placa se programa usando el Arduino Programming Language (basado en
Wiring) y el Arduino Development Environment (basado en Processing2). Los proyectos de Arduino
pueden ser autnomos o se pueden comunicar con software en ejecucin en un ordenador (por
ejemplo con Flash, Processing, MaxMSP, etc.).
Las placas se pueden ensamblar a mano o encargarlas pre-ensambladas; el software se puede
descargar gratuitamente. Los diseos de referencia del hardware (archivos CAD) estn disponibles
bajo licencia open-source, por lo que eres libre de adaptarlas a tus necesidades.

Por qu ARDUINO?
Hay muchos otros microcontroladores y plataformas microcontroladoras disponibles para
computacin fsica. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard, y muchas
otras ofertas de funcionalidad similar. Todas estas herramientas toman los desordenados detalles de
la programacin de microcontrolador y la encierran en un paquete fcil de usar. Arduino tambin
simplifica el proceso de trabajo con microcontroladores, pero ofrece algunas ventajas para
profesores, estudiantes y aficionados interesados sobre otros sistemas:
Barato: Las placas Arduino son relativamente baratas comparadas con otras plataformas de
microcontroladores. La versin menos cara del mdulo Arduino puede ser ensamblada a mano, e
incluso los mdulos de Arduino pre-ensamblados cuestan menos de 50 dlls.
Multiplataforma: El software de Arduino se ejecuta en sistemas operativos Windows,
Macintosh OSX y GNU/Linux. La mayora de los sistemas microcontroladores estn limitados a
Windows.
Entorno de programacin simple y claro: El entorno de programacin de Arduino es fcil de
usar para principiantes, pero suficientemente flexible para que usuarios avanzados puedan
aprovecharlo tambin. Para profesores, est convenientemente basado en el entorno de
programacin Processing, de manera que estudiantes aprendiendo a programar en ese entorno
estarn familiarizados con el aspecto y la imagen de Arduino.
Cdigo abierto y software extensible: El software Arduino est publicado como herramientas
de cdigo abierto, disponible para extensin por programadores experimentados. El lenguaje
puede ser expandido mediante libreras C++, y la gente que quiera entender los detalles tcnicos
pueden hacer el salto desde Arduino a la programacin en lenguaje AVR C en el cual est basado.
De forma similar, puedes aadir cdigo AVR-C directamente en tus programas Arduino si quieres.
Cdigo abierto y hardware extensible: El Arduino est basado en microcontroladores
Atmega168, Atmega328, Atmega1280, y Atmega8 de Atmel. Los planos para los mdulos estn
publicados bajo licencia Creative Commons, por lo que diseadores experimentados de circuitos
pueden hacer su propia versin del mdulo, extendindolo y mejorndolo. Incluso usuarios
relativamente inexpertos pueden construir la versin de la placa del mdulo para entender cmo
funciona y ahorrar dinero.

HARDWARE
Plataforma Arduino
La plataforma Arduino es una plataforma open-hardware basada en una sencilla placa con
entradas y salidas (E/S), analgicas y digitales. El elemento principal el microcontrolador Atmegaxx8,
un chip sencillo y de bajo coste que permite el desarrollo de mltiples diseos.

Figura 2.1 La familia Arduino

La familia Arduino tiene placas diseadas para mltiples funciones. Las hay amigables para para
prototipar en placas de pruebas (breadboards o protoboards), pequeas para integrar en proyectos
finales, flexibles y ligeras para coser a la ropa, grandes y con recursos para los proyectos ms
exigentes, con comunicaciones (Wifi, Ethernet) integradas, equipadas con sensores y motores,
preparadas para conectar con smartphones.

Escudos (Shields)
Los escudos o shields placas que pueden ser conectadas encima de la placa Arduino extendiendo
sus capacidades, pudiendo ser apilada una encima de la otra. Las diferentes shields siguen la misma
filosofa que el conjunto original: son fciles de montar, y baratas de producir.

Figura 2.2 Ejemplos de Escudos (Shields) para Arduino

Arduino Uno
Vista general
El Arduino/Genuino Uno es una placa microcontroladora basada en el ATmega328P. Tiene 14
pines de entrada/salida digital (de los cuales 6 pueden ser usados como salidas PWM), 6 entradas
8

analgicas, un oscilador de cuarzo a 16MHz, una conexin USB, un conector para alimentacin, una
cabecera ICSP, y un botn de reset. Contiene todo lo necesario para soportar el microcontrolador;
basta con conectarlo a un ordenador con un cable USB o enchfalo con un adaptador AC/DC o
batera para comenzar.

Figura 2.3 Vistas en perspectiva y posterior de la placa Arduino UNO

Componentes de la placa Arduino Uno

Mediante la siguiente imagen que muestra la vista superior de la tarjeta Arduino UNO se indican
los componentes que la integran.

Figura 2.4 Componentes que integran la tarjeta Arduino UNO

9

Componentes:
1. Conector USB para el cable Tipo AB
2. Pulsador de Reset
3. Pines de E/S digitales y PWM
4. LED verde de placa encendida
5. LED naranja conectado al pin13
6. ATmega 16U2 encargado de la comunicacin con el PC
7. LED TX (Transmisor) y RX (Receptor) de la comunicacin serial
8. Puerto ICSP para programacin serial
9. Microcontrolador ATmega 328P, cerebro del Arduino
10. Cristal de cuarzo de 16Mhz
11. Regulador de voltaje
12. Conector hembra 2.1mm con centro positivo
13. Pines de voltaje y tierra
14. Entradas anlogas

Especificaciones tcnicas (resumen)

En la tabla 2.1 se pueden observar las caractersticas de tcnicas de la placa Arduino UNO:
Tabla 2.1 Caractersticas tcnicas de la placa Arduino UNO
Caracterstica
Microcontrolador
Voltaje de operacin
Tensin
de
entrada
(recomendada)
Tensin de entrada (lmite)
Pines digitales de E/S
Pines de entrada analgicos
Corriente DC por pin E/S
Corriente DC para pin 3.3 V
Memoria Flash
SRAM
EEPROM
Frecuencia de reloj

Descripcin
ATmega328P
5V
7-12 V
6-20 V
14 (de los cuales 6 proveen
salidas PWM)
6
40 mA
50 mA
32 KB de los cuales 0.5 KB son
usados para el bootloader
2 KB
1 KB
16 MHz

10

Alimentacin
El Arduino UNO puede ser alimentado a travs de la conexin USB o con un suministro de
energa externo.
La alimentacin externa (no USB) puede venir o desde un adaptador AC/DC o desde una batera.
El adaptador puede ser conectado mediante un enchufe de 2.1 mm de centro-positivo en el conector
de alimentacin de la placa. Los cables de la batera pueden insertarse en los headers de los pines
Gnd y Vin del conector POWER.
La placa puede operar con un suministro externo de 6 a 20 voltios. Si es suministrada con menos
de 7 V, el pin de 5 V puede suministrar menos de cinco voltios y la placa podra ser inestable. Si usa
ms de 12 V, el regulador de tensin puede sobrecalentarse y daar la placa. El rango recomendado
es de 7 a 12 voltios.
Los pines de alimentacin son los siguientes:

VIN. Entrada de tensin a la placa Arduino cuando est usando una fuente de alimentacin
externa (contrario de los 5 voltios de la conexin USB u otra fuente de alimentacin regulada).
Puede suministrar tensin a travs de este pin, o suministrar tensin a travs del conector de
alimentacin, el cual esta interconectado con este pin.
5V. El suministro regulado de energa usado para alimentar al microcontrolador y otros
componentes de la placa. Este puede venir o desde VIN a travs de un regulador en la placa, o
ser suministrado por USB u otro suministro regulado de 5 V.
3V3. Un suministro de 3.3 V generado por el chip FTDI de la placa. La corriente mximaes de
50 mA.
GND. Pines de Tierra.

Memoria
El ATmega328 incorpora 32 KB de memoria FLASH para almacenar cdigo (de los cuales 0.5 KB
son empleados para el bootloader). Tiene 2 KB de SRAM y 1 KB de EEPROM (que puede ser leda y
escrita con la librera EEPROM1).

Entradas y Salidas
Cada uno de los 14 pines digitales del Arduino UNO puede ser usado como entrada o salida,
usando funciones pinMode(), digitalWrite() y digitalRead()2. Operan a 5 voltios. Cada pin puede
proporcionar o recibir un mximo de 40 mA y tiene una resistencia interna pull-up (desconectada por
defecto) de 20-50 KOhms.
11

Adems, algunos pines tienen funciones especiales:

Serial: 0 (Rx) y 1 (Tx). Usados para recibir (Rx) y transmitir (Tx) datos TTL en serie. Estos
pines estn conectados a los pines correspondientes del chip ATmega16U2 USB-a-TTL
Serie.
Interruptores externos: 2 y 3. Estos pines pueden ser configurados para disparar un
interruptor en un valor bajo, un flanco ascendente o descendente, o para cambiar un
valor.
PWM: 3, 5, 6, 9, 10 y 11. Proporcionan salida PWM de 8 bits.
SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan comunicacin SPI, con
ayuda de la librera SPI
LED: 13. Hay un LED empotrado conectado al pin digital 13. Cuando el pin est a valor
HIGH, el LED est encendido, cuando el pin est a LOW, est apagado.
IC: 4 (SDA) y 5 (SCL). Soportan comunicacin IC (TWI) usando la libreria Wire5.

El Arduino UNO cuenta adems con 6 entradas analgicas, cada una de las cuales proporciona 10
bits de resolucin (por ejemplo 1024 valores diferentes). Por defecto miden 5 voltios desde tierra,
aunque es posible cambiar el valor ms alto de su rango usando el pin ARF y la funcin
analogReference() o algn cdigo de bajo nivel. Adems, de otro par de pines con funcionalidad
especializada:

AREF. Voltaje de referencia para las entradas analgicas. Usado con analogReference().
Reset. Poner esta lnea de este pin en valor LOW para resetear el microcontrolador.
Tpicamente usada para aadir un botn de reset a Shields que bloquean a la placa
principal.

Comunicacin
El Arduino UNO cuenta con un gran nmero de facilidades para comunicarse con un ordenador,
otro Arduino, u otros microcontroladores. El ATmega328 provee comunicacin serie UART TTL
(5 V), la cual est disponible en los pines digitales 0 (Rx) y 1 (Tx). El ATmega16U2 en la placa
canaliza esta comunicacin serie al USB y los drivers FTDI (incluidos con el software Arduino)
proporcionan un puerto de comunicacin virtual al software del ordenador. El software Arduino
incluye un monitor serie que permite el envo y recepcin de datos de texto simple desde la placa
Arduino.
Una librera SoftwareSerial permite la comunicacin serie en cualquiera de los pines digitales del
Arduino UNO.
El ATmega328 tambin soporta comunicacin 12C (TWI) y SPI. El software Arduino incluyeuna
librera Wire para simplificar el uso del bus 12C. Para usar la comunicacin SPI, puede hacer uso de la
librera SPI.
12

Programacin
El Arduino UNO puede ser programado con el software Arduino. El ATmega328 del Arduino UNO
viene con un bootloader pregrabado que permite cargarle un nuevo cdigo sin usar un programador
hardware externo. Se comunica usando el protocolo original STK500.
Tambin puede saltar el bootloader y programar el ATmega328 a travs del header ICSP (InCircuit Serial Programming).

13

SOFTWARE
Arduino Software (IDE)
Arduino tambin incluye un entorno integrado de desarrollo (IDE) que permite programar
fcilmente las placas de la familia Arduino. El IDE (Integrated Development Environment) se basa en
Processing y Wiring (open source), contiene un editor de texto para escribir cdigo, un rea de
mensajes , una consola de texto , una barra de herramientas con botones de acceso rpido para
funciones comunes y una serie de mens . Se conecta al hardware Arduino para cargar programas y
comunicarse con ellos.
Esta seccin est dedicada a la familiarizacin con el entorno de programacin del software
Arduino (IDE). Para comenzar a trabajar con el software Arduino (IDE), se debe ejecutar el software
previamente instalado en el sistema operativo con el cual desea programar con la placa: Windows,
Mac OS X, GNU/Linux. Este software se puede descargar gratuitamente directamente desde el sitio
oficial de Arduino a travs el siguiente link:
https://www.arduino.cc/en/Main/Software

Figura 3.1 Imagen de arranque de Arduino (IDE)

Conociendo el software Arduino

Los programas escritos utilizando Arduino Software (IDE) se llaman Sketch. Estos Sketches se
escriben en el editor de texto y se guardan con la extensin de archivo .ino. El editor tiene funciones
para cortar/pegar y para buscar/reemplazar texto. El rea de mensajes proporciona informacin
mientras acerca del estado de las operaciones de guardado y carga a la placa, tambin muestra los
errores. La consola muestra la texto de salida del software de Arduino (IDE), incluyendo mensajes de
14

error y otro tipo de informacin. El botn de la esquina superior derecha de la ventana muestra el
puerto y la configuracin de la comunicacin serie de la placa. Los botones de la barra le permiten
verificar y cargar programa, crear, abrir y guardar Sketches, y abrir el monitor serie.
Barra de
mens

Botones de
acceso rpido

Editor de texto
para escribir el
cdigo
(Sketch)
rea de
mensajes
Consola

Figura 3.2 Vista general del software Arduino (IDE)

Botones de acceso rpido

Al abrir el programa, se muestra se visualiza la zona de programacin (Sketch) con la barra de
herramientas de edicin de programa que se visualiza a continuacin:

Figura 3.3 Barra de botones de acceso rpido de Arduino (IDE)

15

Verificar
Comprueba el cdigo de errores mediante su compilacin
Subir
Compila el cdigo y lo sube a la placa configurada.
Nuevo
Crea un nuevo Sketch
Abrir
Despliega un men con todos los Sketchs disponibles dentro de su
Sketchbook. Al hacer click se abrir dentro de la ventana actual
sobrescribiendo su contenido.
Guardar
Guarda su Sketch
Monitor Serie
Abre el monitor serie que se comunica a la placa

Configurar una tarjeta de la familia Arduino

Cuando se desea cargar un programa a una tarjeta Arduino directamente desde el software
Arduino (IDE), la primera accin que debe realizarse es la configuracin de la tarjeta con la cual se
desea trabajar, para ello iniciamos con la seleccin del puerto COM con el cual se va a comunicar el
ordenador con la tarjeta Arduino que vamos a utilizar.
Para ello, con ayuda del Administrador de dispositivos de Windows, identificamos el nmero de
puerto COM que se le asign a la placa Arduino (en este caso, se trabaja con la tarjeta Arduino Uno).

Figura 3.4 Administrador de dispositivos de Windows

16

Como se observa en la imagen, el puerto en el que se ubic la placa corresponde al COM 5. A

continuacin, seleccionamos el dispositivo serie de la placa Arduino desde el men de Herramientas
del software: Herramientas > Puerto Serie.

Figura 3.5 Seleccin del puerto serie en Arduino (IDE)

En seguida nos aseguramos que la placa (Arduino UNO) en la que vamos a cargar el programa
esta seleccionada: Herramientas > Placa.

Figura 3.6 Seleccin de la placa en Arduino (IDE)

17

Cargando mi primer programa hola mundo

Al final de este ejercicio vas a adquirir la capacidad de cargar programas a tu placa Arduino. Para
ello inicializamos el software de Arduino (IDE) y abrimos el ejemplo de Blink (parpadeo), como se
ejemplifica en la imagen: Archivo > Ejemplos > 0.1Basics > Blink.

Figura 3.7 Ruta para la seleccin del ejemplo Blink (parpadeo)

Antes de continuar con el siguiente paso asegrate de que hayas configurado previamente la
placa con la que vas a trabajar. (Seccin anterior).
Para finalizar, pulsa el botn de subir, con lo cual iniciaras la compilacin y la carga del programa
a la placa como se observa en la imagen siguiente:

Figura 3.8 Carga del programa Blink (parpadeo) a la placa

18

El programa de parpadeo (Blink) que acabas de cargar en electrnica se llama Hola mundo,
consiste en prender y apagar un LED en intervalos de un segundo. El LED que prende y apaga lo
puedes ubicar con el nmero 5 en la seccin de Componentes de la placa Arduino Uno el cual est
conectado al pin 13 de la placa segn la imagen de abajo.

Figura 3.8 Led conectado al pin 13 de la placa que realiza el parpadeo

19

PROGRAMANDO CON ARDUINO

Arduino se programa en el lenguaje de alto nivel C/C++ y generalmente un algoritmo se integra
con los siguientes elementos:

Estructuras
Funciones
Variables
Operadores matemticos, lgicos y booleanos
Estructuras de control (Condicionales y ciclos)

Estructura de un sketch
La estructura bsica del lenguaje de programacin de Arduino es bastante simple y se compone
de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen
declaraciones, sentencias o instrucciones.
void setup()
{
statements;
}
void loop()
{
statements;
}

setup()
La funcin 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
declaracin que ejecutar. As mismo se puede utilizar para establecer el estado inicial de las salidas
de la placa.
void setup()
{
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
}

// configura el 'pin' como salida

// pone el pin en estado HIGH

20

loop()
Despus de llamar a setup(), la funcin loop() hace precisamente lo que sugiere su nombre, se
ejecuta de forma cclica, lo que posibilita que el programa este respondiendo continuamente ante los
eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(1000);
}

//
//
//
//

pone en uno (on, 5v) elpin

espera un segundo (1000 ms)
pone en cero (off, 0v.) el
pin

Funciones
Una funcin es un bloque de cdigo que tiene un nombre y un conjunto de instrucciones que son
ejecutadas cuando se llama a la funcin. Podemos hacer uso de funciones integradas como void
setup() y void loop() o escribir nuevas.
Las funciones se escriben para ejecutar tareas repetitivas y reducir el desorden en un programa.
En primer lugar se declara el tipo de la funcin, que ser el valor retornado por la funcin (int,
void...). A continuacin del tipo, se declara el nombre de la funcin y, entre parntesis, los
parmetros que se pasan a la funcin.
type functionName(parameters)
{
statements;
}

La siguiente funcin int delayVal(), asigna un valor de retardo en un programa por lectura del
valor de un potencimetro.
int delayVal()
{
int v;
v = analogRead(pot);
v /= 4;
return v;
}

//crea una variable temporal 'v'

//lee el valor del potencimetro
//convierte 0-1023 a 0-255
//devuelve el valor final de v

{} entre llaves
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para
los bloques de programacin setup(), loop(), if.., etc.
21

type funcion()
{
instrucciones;
}

Una llave de apertura { siempre debe ir seguida de una llave de cierre }, si no es as el

compilador dar errores.
El entorno de programacin de Arduino incluye una herramienta de gran utilidad para
comprobar el total de llaves. Slo tienes que hacer click en el punto de insercin de una llave abierta
e inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).

punto y coma ;
Un punto y coma debe usarse al final de cada declaracin y separa los elementos del programa.
Tambin se usa para separar los elementos en un bucle for.
int x = 13; //declara la variable 'x' como el entero 13

Nota: Olvidar un punto y coma al final de una declaracin producir un error de compilacin.

bloques de comentarios /*...*/

Los bloques de comentarios, o comentarios multi-lnea, son reas de texto ignoradas por el
programa y se usan para grandes descripciones de cdigo o comentarios que ayudan a otras
personas a entender partes del programa. Empiezan con /* y terminan con */ y pueden abarcar
mltiples lneas.
/*este es un bloque de comentario encerrado
no olvides cerrar el comentario
tienen que estar balanceados!!!*/

Como los comentarios son ignorados por el programa y no ocupan espacio en memoria deben
usarse generosamente y tambin pueden usarse para comentar bloques de cdigo con propsitos de
depuracin.

// lnea de comentarios
Una lnea de comentario empieza con / / y terminan con la siguiente lnea de cdigo. Al igual que
los comentarios de bloque, los de lnea son ignoradas por el programa y no ocupan espacio en la
memoria.
//esto es un comentario

Una lnea de comentario se utiliza a menudo despus de una instruccin, para proporcionar ms
informacin acerca de lo que hace esta o para recordarla ms adelante.

22

Variables
Una variable es una forma de llamar y almacenar un valor numrico para usarse despus por el
programa. Como su nombre indica, las variables son nmeros que pueden cambiarse continuamente
al contrario que las constantes, cuyo valor nunca cambia. Una variable necesita ser declarada y,
opcionalmente, asignada al valor que necesita para ser almacenada.
int inputVariable = 0;
//declara una variable y asigna el valor a 0
inputVariable = analogRead(2); //ajusta la variable al valor del pin
//analgico 2

Una vez que una variable ha sido asignada, o reasignada, puedes testear su valor para ver si
cumple ciertas condiciones, o puedes usarlo directamente.
if(inputVariable < 100)
{
inputVariable = 100;
}
delay(inputVariable);

//comprueba si la variable es menor que 100

//si es cierto asigna el valor 100
//usa la variable como retardo

declaracin de variable
Todas las variables tienen que ser declaradas antes de que puedan ser usadas. Declarar una
variable significa definir su tipo de valor, como int, long, float, etc., definir un nombre especfico, y
opcionalmente, asignar un valor inicial. Esto slo necesita hacerse una vez en un programa pero el
valor puede cambiarse en cualquier momento usando aritmtica y varias asignaciones.
int inputVariable = 0;

Una variable puede ser declarada en un nmero de posiciones en todo el programa y donde esta
definicin tiene lugar determina que partes del programa pueden usar la variable.

utilizacin de la variable
Una variable puede ser declarada al comienzo del programa antes del void setup(), localmente
dentro de funciones, y algunas veces en un bloque de declaracin, por ejemplo bucles for. Donde la
variable es declarada determina el mbito de la variable, o la capacidad de ciertas partes de un
programa de hacer uso de ella.
Una variable global es una que puede ser vista y usada por cualquier funcin o sentencia en un
programa. Esta variable se declara al comienzo del programa, antes de la funcin setup().
Una variable local es una que se define dentro de una funcin o como parte de un bucle for. Slo
es visible y slo puede ser usada dentro de la funcin en la cual fue declarada. Adems, es posible
23

tener dos o ms variables del mismo nombre en diferentes partes del programa que contienen
diferentes valores.
El siguiente ejemplo muestra cmo declarar a unos tipos diferentes de variables y la visibilidad
de cada variable:
int value; // 'value' es visible para cualquier funcin
void setup()
{
// no es necesario configurar nada en este ejemplo
}
void loop()
{
for (int i=0; i<20;) // 'i' solo es visible
{
// dentro del bucle for
i++
}
float f; // 'f' es visible solo dentro de loop()
}

Tipos de datos
byte
Byte almacena un valor numrico de 8 bits sin puntos decimales. Tienen un rango de 0 a 255.
byte someVariable = 180; //declara 'someVariable' como un tipo byte

int
Enteros son los tipos de datos primarios para almacenamiento de nmeros sin puntos decimales
y almacenan un valor de 16 bits con un rango de -32,768 a 32,767.
int someVariable = 1500; //declara 'someVariable' como tipo int

long
Tipo de datos de tamao extendido para enteros largos, sin puntos decimales, almacenados en
un valor de 32 bits con un rango de -2,146,483,648 a 2,147,483,647.
long someVariable = 90000; //declara 'someVariable' como tipo long

24

float
Un tipo de datos para nmeros en punto flotante, o nmeros que tienen un punto decimal. Los
nmeros en punto flotante tienen mayor resolucin que los enteros y se almacenan como valor de 32
bits con un rango de -3.4028235E+38 a 3.4028235E+38.
float someVariable = 3.14; //declara 'someVariable' como tipo float

arrays
Un array es una coleccin de valores que son accedidos con un ndice numrico. Cualquier valor
en el array debe llamarse escribiendo el nombre del array y el ndice numrico del valor. Los arrays
estn indexados a cero, con el primer valor en el array comenzando con el ndice nmero 0. Un array
necesita ser declarado y opcionalmente asignarle valores antes de que puedan ser usados.
int myArray[] = {value0, value1, value2...};

Asimismo es posible declarar un array declarando el tipo del array y el tamao y luego asignarle
valores a una posicin del ndice.
int myArray[5]; //declara un array de enteros con 6 posiciones
myArray[3] = 10; //asigna a la cuarta posicin del ndice el valor 10

Para recibir un valor desde un array, asignamos una variable al array y la posicin del ndice:
x = myArray[3]; //x ahora es igual a 10

Aritmtica
Los operadores aritmticos incluyen suma, resta, multiplicacin y divisin. Retornan la suma,
diferencia, producto o cociente (respectivamente) de dos operandos.
y
x
i
r

=
=
=
=

y+3;
x-7;
j*6;
r/5;

La operacin es llevada a cabo usando del tipo de datos de los operandos, as 9/4 devuelve 2 en
lugar de 2.25. Si los operandos son de tipos diferentes, el tipo mayor es usado para el clculo.
25

Nota: Utilice el operador (typeData) para convertir un tipo de variable a otro sobre la marcha.
Por ejemplo, i = (int) 3,6 establecer i igual a 3.

asignaciones compuestas
Las asignaciones compuestas combinan una operacin aritmtica con una variable asignada.
Estas son comnmente utilizadas en los bucles tal como se describe ms adelante. Estas asignaciones
compuestas pueden ser:
x
x
x
x
x
x

++
-+=
-=
*=
/=

y
y
y
y

//
//
//
//
//
//

igual
igual
igual
igual
igual
igual

que
que
que
que
que
que

x
x
x
x
x
x

=
=
=
=
=
=

x
x
x
x
x
x

+1, o incremento de x en +1
- 1, o decremento de x en -1
+ y, o incremento de x en +y
- y, o decremento de x en -y
* y, o multiplica x por y
/ y, o divide x por y

Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo valor x y por lo tanto x
es reasignada al nuevo valor.

operadores de comparacin
Las comparaciones de una variable o constante con otra se usan a menudo en declaraciones if
para comprobar si un condicin especfica es cierta.
x
x
x
x
x
x

== y;
!= y;
< y;
> y;
<= y;
>= y;

//x
//x
//x
//x
//x
//x

es
no
es
es
es
es

igual a y
es igual a y
menor que y
mayor que y
menor o igual que y
mayor o igual que y

operadores lgicos
Los operadores lgicos son normalmente una forma de comparar dos expresiones y devuelven
TRUE o FALSE dependiendo del operador. Hay tres operadores lgicos, AND, OR y NOT, que se usan a
menudo en declaraciones if.
//AND logico:
if(x>0 && x<5) //verdadero slo si las dos expresiones son ciertas
//OR logico:
if(x>0 || y>0) //verdadero si al menos una expresin es cierta
//NOT logico:
if(!(x>0))

//verdadero slo si la expresin es falsa

26

Constantes
El lenguaje de programacin de Arduino tiene unos valores predeterminados, que son llamados
constantes. Se utilizan para hacer los programas ms fciles de leer. Las constantes se clasifican en
grupos.

true/false
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se
refieren al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia
con 1, pero TRUE tambin puede ser cualquier otro valor distinto a cero, como por ejemplo -1, 2 o 200 tambin se definen como TRUE.
if(b == TRUE)
{
ejecutar las instrucciones;
}

high/low
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la
escritura digital para los pines. ALTO se define como en la lgica de nivel 1, ON, o 5 voltios, mientras
que BAJO es lgica nivel 0, OFF, o 0 voltios.
digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v)

input/output
Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento
de los pines mediante la instruccin pinMode de tal manera que el pin puede ser una entrada INPUT
o una salida OUTPUT.
pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida

27

Control de flujo
if (si condicional)
if es una sentencia que se utiliza para probar si una determinada condicin se ha alcanzado, y
ejecutar una serie de instrucciones (operaciones) que se escriben dentro de llaves si esta se cumple.
Si es falso (la condicin no se cumple) el programa salta y no ejecuta las operaciones que estn
dentro de las llaves. El formato para if es el siguiente:
if (unaVariable ?? valor)
{
ejecutaInstrucciones;
}

Nota: Cuidado deemplear = (asinacin) en lugar de == (comparacin) dentro de la

declaracin de la sentencia if.

if else (si.. sino ..)

if else es un estructura que se ejecuta en respuesta a la idea si esto no se cumple haz esto
otro.
if (inputPin == HIGH)
{
instruccionesA;
}
else
{
instruccionesB;
}

else puede ir precedido de otra condicin de manera que se pueden establecer varias
estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean
mutuamente excluyentes pudindose ejecutar a la vez.
if (inputPin < 500)
{
instruccionesA;
}
else if (inputPin >= 1000)
{
instruccionesB;
{
else
{
instruccionesC;
}

28

for
La sentencia for se usa para repetir un bloque de declaraciones encerradas en llaves un nmero
especfico de veces. Un contador de incremento se usa a menudo para incrementar y terminar el
bucle. Hay tres partes separadas por punto y coma (;), en la cabecera del bucle.
for(inicializacion; condicion; expresion)
{
doSomething;
}

La inicializacin de una variable local, o contador de incremento, sucede primero y una sola una
vez. Cada vez que pasa el bucle, la condicin siguiente es comprobada. Si la condicin devuelve TRUE,
las declaraciones y expresiones que siguen se ejecutan y la condicin se comprueba de nuevo.
Cuando la condicin se vuelve FALSE, el bucle termina. Ejemplo
for(int i=0; i<20; i++)
{
digitalWrite(13, HIGH);
delay(250);
digitalWrite(13, LOW);
delay(250);
}

//declara i, comprueba si es menor

//que 20, incrementa i en 1
//activa el pin 13
//pausa por un 1/4 de segundo
//desactiva el pin 13
//pausa por un 1/4 de segundo

while
El bucle while es un bucle de ejecucin continua que se repetir hasta que expresin colocada
entre parntesis en la cabecera se vuelva falsa.
La situacin podr cambiar a expensas de una expresin dentro el cdigo del bucle o tambin
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(someVariable < 200)
{
doSomething;
someVariable++;
}

//comprueba si es menor que 200

//ejecuta las sentencias encerradas
//incrementa la variable en 1

29

do while
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la
condicin 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 ledo 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);

E/S digital
pinMode(pin, mode)
Esta instruccin es utilizada en la parte de configuracin setup () y sirve para configurar el modo
de trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura pin como salida

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

// configura el pin como entrada

// activa las resistencias internas

Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores. En
el ejemplo anterior no se trata de convertir un pin en salida, es simplemente un mtodo para activar
las resistencias interiores.

30

Los pines configurados como OUTPUT (salida) se dice que estn en un estado de baja impedancia
estado y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta
corriente es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie),
pero no es lo suficiente grande como para alimentar cargas de mayor consumo como rels,
solenoides, o motores.
Un cortocircuito en los pines del Arduino provocar una corriente elevada que puede daar o
destruir el chip Atmega. A menudo es una buena idea conectar en la OUTPUT (salida) una resistencia
externa de 470 o de 1000 .

digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo). El pin
se puede especificar ya sea como una variable o una constante (0-13).
valor = digitalRead(Pin);

// hace que valor sea igual al

//estado ledo en Pin

digitalWrite(pin, value)
Enva al pin definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la
salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).
digitalWrite(pin, HIGH);

// deposita en el 'pin' un valor

// HIGH (alto o 1)

El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el
pinde salida LED:
int led = 13;
int boton = 7;
int valor = 0;

// asigna a LED el valor 13

// asigna a botn el valor 7
// define el valor y le asigna el valor 0

void setup()
{
pinMode(led, OUTPUT);
pinMode(boton, INPUT);
}

// configura el led (pin13)

//como salida
// configura botn (pin7)
//como entrada

void loop()
{
valor = digitalRead(boton); //lee el estado de la
//entrada botn
digitalWrite(led, valor);
//enva a la salida led
}
//el valor ledo

31

E/S analgica
analogRead(pin)
Lee el valor desde un pin analgico especificado con una resolucin de 10 bits. Esta funcin slo
trabaja en los pines analgicos (0 - 5). Los valores enteros devueltos estn en el rango de 0 a 1023.
value = analogRead(pin); //ajusta 'value' igual a 'pin'

Nota: Los pines analgicos al contrario que los digitales, no necesitan ser declarados al principio
como INPUT u OUTPUT.

analogWrite(pin, value)
Escribe un valor pseudo analgico usando modulacin por ancho de pulso (PWM en ingls) a un
pin de salida marcado como PWM. En los Arduinos ms nuevos con el chip ATmega328, esta funcin
trabaja en los pines 3, 5, 6, 9, 10 y 11. Los Arduinos ms antiguos con un ATmega8 slo soportan los
pines 9, 10 y 11. El valor puede ser especificado como una variable o constante con un valor de 0 a
255.
analogWrite(pin, value); //escribe 'value' al 'pin' analgico

El valor de salida vara de 0 a 5 V segn el valor de entrada (de 0 a 255) en funcin del tiempo de
pulso. Si t es el tiempo de pulso, la tabla 4.1 muestra la equivalencia entre el valor y la salida en
funcin del tiempo.
Tabla 4.1: Relacin valor-salida con analogWrite()
Valor
0
64
128
192
255

Nivel de salida
0 V (t)
0 V ( t) y 5 V ( t)
0 V ( t) y 5 V ( t)
0 V ( t) y 5 V ( t)
5 V (t)

Debido a que esta es una funcin de hardware, en el pin de salida analgica (PWN) se generar
una onda constante despus de ejecutada la instruccin analogWrite hasta que se llegue a ejecutar
otra instruccin analogWrite (o una llamada a digitalRead o digitalWrite en el mismo pin).

32

El siguiente ejemplo lee un valor analgico de un pin de entrada analgica, convierte el valor
dividindolo por 4, y enva el nuevo valor convertido a una salida del tipo PWM o salida analgica:
int led = 10;
int analog = 0;
int valor;

// define el pin 10 como led

// define el pin 0 como analog
// define la variable valor

void setup(){}

// no es necesario configurar
// entradas y salidas

void loop()
{
valor = analogRead(analog);
valor /= 4;
analogWrite(led, value);

// lee el pin 0 y lo asocia

//a la variable valor
//divide valor entre 4 y lo
//reasigna a valor
// escribe en el pin10 valor

Control del tiempo

delay(ms)
Detiene la ejecucin del programa la cantidad de tiempo en ms que se indica en la propia
instruccin. De tal manera que 1000 equivale a 1seg.
delay(1000); // espera 1 segundo

millis()
Devuelve el nmero de milisegundos desde que la placa Arduino empez a ejecutar el programa
actual como un valor long sin signo.
value = millis(); //ajusta 'value' igual a millis()

Nota: Este nmero se desbordar (resetear de nuevo a cero), despus de aproximadamente 9

horas.

33

Matemticas
min(x,y)
Calcula el mnimo de dos nmeros de cualquier tipo de datos y devuelve el nmero ms
pequeo.
value = min(value, 100);

/*asigna a 'value' al ms pequeo

de value o 100, asegurndose
que nunca superar 100*/

max(x,y)
Calcula el mximo de dos nmeros de cualquier tipo de datos y devuelve el nmero ms grande.
value = max(value, 100);

/*asigna a 'value' al ms grande

de value o 100, asegurndose
que sea al menos 100*/

Aleatorio
randomSeed(seed)
Asigna un valor, o semilla (seed en ingls), como el punto de partida para la funcin random().
randomSeed(value); //asigna 'value' como la semilla aleatoria

Como el Arduino es incapaz de crear un nmero verdaderamente aleatorio, randomSeed te

permite colocar una variable, constante, u otra funcin dentro de la funcin random, lo cual ayuda a
generar ms nmeros <random> aleatorios. Existen una variedad de diferentes semillas, o funciones,
que pueden ser usadas en esta funcin incluyendo millis() o incluso analogRead() para leer ruido
elctrico a travs de un pin analgico.

random(max) , random(min, max)

La funcin random te permite devolver nmeros pseudo-aleatorios en un rango especificado por
los valores min y max.
value = random(100, 200);

//asigna a 'value' un nmero aleatorio

//entre 100 y 200

34

Nota: Usar esta funcin despus emplear la funcin randomSeed().

int randNumber;
//variable para almacenar el valor aleatorio
int led = 10;
//LED con una resistencia de 220 ohm en el pin 10
void setup(){}
//setup no es necesario
void loop()
{
randomSeed(millis());
//asigna millis() como semilla
randNumber = random(255);
//numero aleatorio de 0 a 255
analogWrite(led, randNumber); //salida de la seal PWM
delay(500);
}

Comunicacin Serie
Serial.begin(rate)
Abre el puerto serie y asigna la tasa de baudios para la transmisin de datos serie. La tpica tasa
de baudios para comunicarse con el ordenador es 9600 aunque otras velocidades estn soportadas.
void setup()
{
Serial.begin(9600);

//abre el puerto serie ajusta

//la tasa de datos a 9600 bps

Nota: Cuando se usa la comunicacin serie, los pines digitales 0 (Rx) y 1 (Tx) no pueden ser
usados al mismo tiempo

Serial.println(data)
Imprime datos al puerto serie, seguido de un retorno de carro y avance de lnea automticos.
Este comando toma la misma forma que Serial.print(), pero es ms fcil para leer datos en el Serial
Monitor1.
Serial.println(analogValue); //envia el valor de 'analogValue'

Nota: Para obtener ms informacin sobre las distintas posibilidades de Serial.println() y

Serial.print() puede consultarse el sitio web de Arduino.
El siguiente ejemplo toma de una lectura analgica pin0 y enva estos datos al ordenador cada 1
segundo.
void setup()

35

{
Serial.begin(9600);
//ajusta el puerto serie a 9600 bps
}
void loop()
{
Serial.println(analogRead(0)); //envia valor analogico
delay(1000);
//pausa por 1 segundo
}

36

BIBLIOGRAFA
[1] EVANS, Brian W., (2011) Arduino Programming Notebook.
[2] ENRQUEZ HERRADIR, Rafael, (2009), Gua de Usuario de Arduino
[3] TIENDA DE ROBTICA,
[4] ARDUINO - Wikipedia, the free encyclopedia, (ltima modificacin, Septiembre 2015). Disponible
en: http://en.wikipedia.org/wiki/Arduino
[5] ARDUINO - Homepage, (ltima modificacin, Julio 2008). Disponible en: http://www.
arduino.cc
[6] WIRING, (ltima modificacin, Junio 2008). Disponible en: http://www.wiring.org.co

37

Apndice A
Esquemtico de Arduino UNO Rev 3

38