Sei sulla pagina 1di 39

MANUAL DE

PROGRAMACIÓN
ARDUINO (IDE)

Introducción al entorno
de Arduino IDE mediante
Arduino UNO Rev 3

Recopilación hecha por:


Ing. Luis Fernando Franco Guzmán
1
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 técnicas (resumen) ........................................................................................................ 10
Alimentación ........................................................................................................................................... 11
Memoria ................................................................................................................................................. 11
Entradas y Salidas .................................................................................................................................... 11
Comunicación.......................................................................................................................................... 12
Programación .......................................................................................................................................... 13
SOFTWARE ...................................................................................................................................................... 14
Arduino Software (IDE) ................................................................................................................................ 14
Conociendo el software Arduino ................................................................................................................. 14
Botones de acceso rápido ........................................................................................................................ 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
// línea de comentarios ........................................................................................................................... 22
Variables ..................................................................................................................................................... 23

2
declaración de variable ............................................................................................................................ 23
utilización de la variable .......................................................................................................................... 23
Tipos de datos ............................................................................................................................................. 24
byte ......................................................................................................................................................... 24
int ........................................................................................................................................................... 24
long ......................................................................................................................................................... 24
float ........................................................................................................................................................ 25
arrays ...................................................................................................................................................... 25
Aritmética ................................................................................................................................................... 25
asignaciones compuestas ........................................................................................................................ 26
operadores de comparación .................................................................................................................... 26
operadores lógicos .................................................................................................................................. 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 analógica ............................................................................................................................................... 32
analogRead(pin) ...................................................................................................................................... 32
analogWrite(pin, value) ........................................................................................................................... 32
Control del tiempo ...................................................................................................................................... 33
delay(ms) ................................................................................................................................................ 33
millis() ..................................................................................................................................................... 33
Matemáticas ............................................................................................................................................... 34
min(x,y) ................................................................................................................................................... 34
max(x,y) .................................................................................................................................................. 34

3
Aleatorio ..................................................................................................................................................... 34
randomSeed(seed) .................................................................................................................................. 34
random(max) , random(min, max) ........................................................................................................... 34
Comunicación Serie ..................................................................................................................................... 35
Serial.begin(rate) ..................................................................................................................................... 35
Serial.println(data) .................................................................................................................................. 35
BIBLIOGRAFÍA ................................................................................................................................................. 37
Apéndice A ...................................................................................................................................................... 38
Esquemático de Arduino UNO Rev 3 ............................................................................................................ 38

4
INTRODUCCION

¿Qué es ARDUINO?

Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en


software y hardware libres, flexibles y fáciles de usar. Está pensado para artistas, diseñadores, 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 recepción 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 autónomos o se pueden comunicar con software en ejecución 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 diseños de referencia del hardware (archivos CAD) están disponibles
bajo licencia open-source, por lo que eres libre de adaptarlas a tus necesidades.

5
¿Por qué ARDUINO?

Hay muchos otros microcontroladores y plataformas microcontroladoras disponibles para


computación física. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard, y muchas
otras ofertas de funcionalidad similar. Todas estas herramientas toman los desordenados detalles de
la programación de microcontrolador y la encierran en un paquete fácil de usar. Arduino también
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 versión menos cara del módulo Arduino puede ser ensamblada a mano, e
incluso los módulos 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 mayoría de los sistemas microcontroladores están limitados a
Windows.

 Entorno de programación simple y claro: El entorno de programación de Arduino es fácil de


usar para principiantes, pero suficientemente flexible para que usuarios avanzados puedan
aprovecharlo también. Para profesores, está convenientemente basado en el entorno de
programación Processing, de manera que estudiantes aprendiendo a programar en ese entorno
estarán familiarizados con el aspecto y la imagen de Arduino.

 Código abierto y software extensible: El software Arduino está publicado como herramientas
de código abierto, disponible para extensión por programadores experimentados. El lenguaje
puede ser expandido mediante librerías C++, y la gente que quiera entender los detalles técnicos
pueden hacer el salto desde Arduino a la programación en lenguaje AVR C en el cual está basado.
De forma similar, puedes añadir código AVR-C directamente en tus programas Arduino si quieres.

 Código abierto y hardware extensible: El Arduino está basado en microcontroladores


Atmega168, Atmega328, Atmega1280, y Atmega8 de Atmel. Los planos para los módulos están
publicados bajo licencia Creative Commons, por lo que diseñadores experimentados de circuitos
pueden hacer su propia versión del módulo, extendiéndolo y mejorándolo. Incluso usuarios
relativamente inexpertos pueden construir la versión de la placa del módulo para entender cómo
funciona y ahorrar dinero.

6
HARDWARE
Plataforma Arduino

La plataforma Arduino es una plataforma open-hardware basada en una sencilla placa con
entradas y salidas (E/S), analógicas y digitales. El elemento principal el microcontrolador Atmegaxx8,
un chip sencillo y de bajo coste que permite el desarrollo de múltiples diseños.

Figura 2.1 La familia Arduino

La familia Arduino tiene placas diseñadas para múltiples funciones. Las hay amigables para para
prototipar en placas de pruebas (breadboards o protoboards), pequeñas para integrar en proyectos
finales, flexibles y ligeras para coser a la ropa, grandes y con recursos para los proyectos más
exigentes, con comunicaciones (Wifi, Ethernet…) integradas, equipadas con sensores y motores,
preparadas para conectar con smartphones.

7
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
filosofía que el conjunto original: son fáciles 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
analógicas, un oscilador de cuarzo a 16MHz, una conexión USB, un conector para alimentación, una
cabecera ICSP, y un botón de reset. Contiene todo lo necesario para soportar el microcontrolador;
basta con conectarlo a un ordenador con un cable USB o enchúfalo con un adaptador AC/DC o
batería 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 comunicación con el PC
7. LED TX (Transmisor) y RX (Receptor) de la comunicación serial
8. Puerto ICSP para programación serial
9. Microcontrolador ATmega 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 análogas

Especificaciones técnicas (resumen)

En la tabla 2.1 se pueden observar las características de técnicas de la placa Arduino UNO:

Tabla 2.1 Características técnicas de la placa Arduino UNO

Característica Descripción
Microcontrolador ATmega328P
Voltaje de operación 5V
Tensión de entrada 7-12 V
(recomendada)
Tensión de entrada (límite) 6-20 V
Pines digitales de E/S 14 (de los cuales 6 proveen
salidas PWM)
Pines de entrada analógicos 6
Corriente DC por pin E/S 40 mA
Corriente DC para pin 3.3 V 50 mA
Memoria Flash 32 KB de los cuales 0.5 KB son
usados para el bootloader
SRAM 2 KB
EEPROM 1 KB
Frecuencia de reloj 16 MHz

10
Alimentación

El Arduino UNO puede ser alimentado a través de la conexión USB o con un suministro de
energía externo.

La alimentación externa (no USB) puede venir o desde un adaptador AC/DC o desde una batería.
El adaptador puede ser conectado mediante un enchufe de 2.1 mm de centro-positivo en el conector
de alimentación de la placa. Los cables de la batería 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 podría ser inestable. Si usa
más de 12 V, el regulador de tensión puede sobrecalentarse y dañar la placa. El rango recomendado
es de 7 a 12 voltios.

Los pines de alimentación son los siguientes:

 VIN. Entrada de tensión a la placa Arduino cuando está usando una fuente de alimentación
externa (contrario de los 5 voltios de la conexión USB u otra fuente de alimentación regulada).
Puede suministrar tensión a través de este pin, o suministrar tensión a través del conector de
alimentación, el cual esta interconectado con este pin.
 5V. El suministro regulado de energía usado para alimentar al microcontrolador y otros
componentes de la placa. Este puede venir o desde VIN a través 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 máximaes de
50 mA.
 GND. Pines de Tierra.

Memoria

El ATmega328 incorpora 32 KB de memoria FLASH para almacenar código (de los cuales 0.5 KB
son empleados para el “bootloader”). Tiene 2 KB de SRAM y 1 KB de EEPROM (que puede ser leída y
escrita con la librería 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 máximo de 40 mA y tiene una resistencia interna pull-up (desconectada por
defecto) de 20-50 KOhms.

11
Además, algunos pines tienen funciones especiales:

 Serial: 0 (Rx) y 1 (Tx). Usados para recibir (Rx) y transmitir (Tx) datos TTL en serie. Estos
pines están 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 comunicación SPI, con
ayuda de la librería 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.
 I²C: 4 (SDA) y 5 (SCL). Soportan comunicación I²C (TWI) usando la libreria Wire5.

El Arduino UNO cuenta además con 6 entradas analógicas, cada una de las cuales proporciona 10
bits de resolución (por ejemplo 1024 valores diferentes). Por defecto miden 5 voltios desde tierra,
aunque es posible cambiar el valor más alto de su rango usando el pin ARF y la función
analogReference() o algún código de bajo nivel. Además, de otro par de pines con funcionalidad
especializada:

 AREF. Voltaje de referencia para las entradas analógicas. Usado con analogReference().
 Reset. Poner esta línea de este pin en valor LOW para resetear el microcontrolador.
Típicamente usada para añadir un botón de reset a Shields que bloquean a la placa
principal.

Comunicación

El Arduino UNO cuenta con un gran número de facilidades para comunicarse con un ordenador,
otro Arduino, u otros microcontroladores. El ATmega328 provee comunicación 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 comunicación serie al USB y los drivers FTDI (incluidos con el software Arduino)
proporcionan un puerto de comunicación virtual al software del ordenador. El software Arduino
incluye un monitor serie que permite el envío y recepción de datos de texto simple desde la placa
Arduino.

Una librería SoftwareSerial permite la comunicación serie en cualquiera de los pines digitales del
Arduino UNO.

El ATmega328 también soporta comunicación 12C (TWI) y SPI. El software Arduino incluyeuna
librería Wire para simplificar el uso del bus 12C. Para usar la comunicación SPI, puede hacer uso de la
librería SPI.

12
Programación

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 código sin usar un programador
hardware externo. Se comunica usando el protocolo original STK500.

También puede saltar el bootloader y programar el ATmega328 a través del header ICSP (In-
Circuit Serial Programming).

13
SOFTWARE
Arduino Software (IDE)

Arduino también incluye un entorno integrado de desarrollo (IDE) que permite programar
fácilmente 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 código, un área de
mensajes , una consola de texto , una barra de herramientas con botones de acceso rápido para
funciones comunes y una serie de menús . Se conecta al hardware Arduino para cargar programas y
comunicarse con ellos.

Esta sección está dedicada a la familiarización con el entorno de programación 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 través 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 extensión de archivo .ino. El editor tiene funciones
para cortar/pegar y para buscar/reemplazar texto. El área de mensajes proporciona información
mientras acerca del estado de las operaciones de guardado y carga a la placa, también muestra los
errores. La consola muestra la texto de salida del software de Arduino (IDE), incluyendo mensajes de
14
error y otro tipo de información. El botón de la esquina superior derecha de la ventana muestra el
puerto y la configuración de la comunicación 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
menús Botones de
acceso rápido

Editor de texto
para escribir el
código
(Sketch)
Área de
mensajes
Consola

Figura 3.2 Vista general del software Arduino (IDE)

Botones de acceso rápido

Al abrir el programa, se muestra se visualiza la zona de programación (Sketch) con la barra de


herramientas de edición de programa que se visualiza a continuación:

Figura 3.3 Barra de botones de acceso rápido de Arduino (IDE)

15
Verificar
Comprueba el código de errores mediante su compilación

Subir
Compila el código 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 acción que debe realizarse es la configuración de la tarjeta con la cual se
desea trabajar, para ello iniciamos con la selección 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 número 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
continuación, seleccionamos el dispositivo serie de la placa Arduino desde el menú de Herramientas
del software: Herramientas > Puerto Serie.

Figura 3.5 Selección 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 Selección 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 selección del ejemplo Blink (parpadeo)

Antes de continuar con el siguiente paso asegúrate de que hayas configurado previamente la
placa con la que vas a trabajar. (Sección anterior).

Para finalizar, pulsa el botón de subir, con lo cual iniciaras la compilación 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 electrónica 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 número 5 en la sección de “Componentes de la placa Arduino Uno” el cual está
conectado al pin 13 de la placa según 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 matemáticos, lógicos y booleanos
 Estructuras de control (Condicionales y ciclos)

Estructura de un sketch

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, sentencias o instrucciones.

void setup()
{
statements;
}
void loop()
{
statements;
}

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
}

20
loop()

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se
ejecuta de forma cíclica, lo que posibilita que el programa este respondiendo continuamente ante los
eventos que se produzcan en la 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. 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 función, que será el valor retornado por la función (int,
void...). A continuación del tipo, se declara el nombre de la función y, entre paréntesis, los
parámetros que se pasan a la función.

type functionName(parameters)
{
statements;
}

La siguiente función int delayVal(), asigna un valor de retardo en un programa por lectura del
valor de un potenciómetro.

int delayVal()
{
int v; //crea una variable temporal 'v'
v = analogRead(pot); //lee el valor del potenciómetro
v /= 4; //convierte 0-1023 a 0-255
return v; //devuelve el valor final 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 programación 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 programación de Arduino incluye una herramienta de gran utilidad para


comprobar el total de llaves. Sólo tienes que hacer click en el punto de inserción 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 declaración y separa los elementos del programa.
También 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 declaración producirá un error de compilación.

bloques de comentarios /*...*/

Los bloques de comentarios, o comentarios multi-línea, son áreas de texto ignoradas por el
programa y se usan para grandes descripciones de código o comentarios que ayudan a otras
personas a entender partes del programa. Empiezan con /* y terminan con */ y pueden abarcar
múltiples líneas.

/*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 también pueden usarse para comentar bloques de código con propósitos de
depuración.

// línea de comentarios

Una línea de comentario empieza con / / y terminan con la siguiente línea de código. Al igual que
los comentarios de bloque, los de línea son ignoradas por el programa y no ocupan espacio en la
memoria.

//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.

22
Variables

Una variable es una forma de llamar y almacenar un valor numérico para usarse después por el
programa. Como su nombre indica, las variables son números 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
//analógico 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) //comprueba si la variable es menor que 100


{
inputVariable = 100; //si es cierto asigna el valor 100
}
delay(inputVariable); //usa la variable como retardo

declaración 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 específico, y
opcionalmente, asignar un valor inicial. Esto sólo necesita hacerse una vez en un programa pero el
valor puede cambiarse en cualquier momento usando aritmética y varias asignaciones.

int inputVariable = 0;

Una variable puede ser declarada en un número de posiciones en todo el programa y donde esta
definición tiene lugar determina que partes del programa pueden usar la variable.

utilización 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 declaración, 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 función o sentencia en un
programa. Esta variable se declara al comienzo del programa, antes de la función setup().

Una variable local es una que se define dentro de una función o como parte de un bucle for. Sólo
es visible y sólo puede ser usada dentro de la función en la cual fue declarada. Además, es posible

23
tener dos o más variables del mismo nombre en diferentes partes del programa que contienen
diferentes valores.

El siguiente ejemplo muestra cómo declarar a unos tipos diferentes de variables y la visibilidad
de cada variable:

int value; // 'value' es visible para cualquier función

void setup()
{
// no es necesario configurar 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 numérico 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 números 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 tamaño 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 números en punto flotante, o números que tienen un punto decimal. Los
números en punto flotante tienen mayor resolución 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 colección de valores que son accedidos con un índice numérico. Cualquier valor
en el array debe llamarse escribiendo el nombre del array y el índice numérico del valor. Los arrays
están indexados a cero, con el primer valor en el array comenzando con el índice número 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 tamaño y luego asignarle
valores a una posición del índice.

int myArray[5]; //declara un array de enteros con 6 posiciones


myArray[3] = 10; //asigna a la cuarta posición del índice el valor 10

Para recibir un valor desde un array, asignamos una variable al array y la posición del índice:

x = myArray[3]; //x ahora es igual a 10

Aritmética

Los operadores aritméticos incluyen suma, resta, multiplicación y división. Retornan la suma,
diferencia, producto o cociente (respectivamente) de dos operandos.

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

La operación 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 cálculo.

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 operación aritmética con una variable asignada.
Estas son comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones
compuestas pueden ser:

x ++ // igual que x = x +1, o incremento de x en +1


x -- // igual que x = x - 1, o decremento de x en -1
x += y // igual que x = x + y, o incremento de x en +y
x -= y // igual que x = x - y, o decremento de x en -y
x *= y // igual que x = x * y, o multiplica x por y
x /= y // igual que x = x / 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 comparación

Las comparaciones de una variable o constante con otra se usan a menudo en declaraciones if
para comprobar si un condición específica es cierta.
x == y; //x es igual a y
x != y; //x no es igual a y
x < y; //x es menor que y
x > y; //x es mayor que y
x <= y; //x es menor o igual que y
x >= y; //x es mayor o igual que y

operadores lógicos

Los operadores lógicos son normalmente una forma de comparar dos expresiones y devuelven
TRUE o FALSE dependiendo del operador. Hay tres operadores lógicos, AND, OR y NOT, que se usan a
menudo en declaraciones if.

//AND logico:
if(x>0 && x<5) //verdadero sólo si las dos expresiones son ciertas

//OR logico:
if(x>0 || y>0) //verdadero si al menos una expresión es cierta

//NOT logico:
if(!(x>0)) //verdadero sólo si la expresión es falsa

26
Constantes

El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados
constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en
grupos.

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 también puede ser cualquier otro valor distinto a cero, como por ejemplo -1, 2 o -
200 también 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 lógica de nivel 1, ON, o 5 voltios, mientras
que BAJO es lógica nivel 0, OFF, o 0 voltios.

digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v)

input/output

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento
de los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT
o una salida OUTPUT.

pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida

27
Control de flujo

if (si condicional)

if es una sentencia que se utiliza para probar si una determinada condición se ha alcanzado, y
ejecutar una serie de instrucciones (operaciones) que se escriben dentro de llaves si esta se cumple.
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;
}

Nota: Cuidado deemplear “ = ” (asinación) en lugar de “ == “ (comparación) dentro de la


declaración 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 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.

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 número
específico 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 inicialización de una variable local, o contador de incremento, sucede primero y una sola una
vez. Cada vez que pasa el bucle, la condición siguiente es comprobada. Si la condición devuelve TRUE,
las declaraciones y expresiones que siguen se ejecutan y la condición se comprueba de nuevo.
Cuando la condición se vuelve FALSE, el bucle termina. Ejemplo
for(int i=0; i<20; i++) //declara i, comprueba si es menor
{ //que 20, incrementa i en 1
digitalWrite(13, HIGH); //activa el pin 13
delay(250); //pausa por un 1/4 de segundo
digitalWrite(13, LOW); //desactiva el pin 13
delay(250); //pausa por un 1/4 de segundo
}

while

El bucle while es un bucle de ejecución continua que se repetirá hasta que expresión colocada
entre paréntesis en la cabecera se vuelva falsa.

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(someVariable < 200) //comprueba si es menor que 200


{
doSomething; //ejecuta las sentencias encerradas
someVariable++; //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
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);

E/S digital

pinMode(pin, mode)

Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo
de trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).

pinMode(pin, OUTPUT); // configura ‘pin’ como salida

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

pinMode(pin, INPUT); // configura el ‘pin’ como entrada


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

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

30
Los pines configurados como OUTPUT (salida) se dice que están en un estado de baja impedancia
estado y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta
corriente es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie),
pero no es lo suficiente grande como para alimentar cargas de mayor consumo como relés,
solenoides, o motores.

Un cortocircuito en los pines del Arduino provocará una corriente elevada que puede dañar 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 leído en ‘Pin’

digitalWrite(pin, value)

Envía al ‘pin’ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la
salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).

digitalWrite(pin, HIGH); // deposita en el 'pin' un valor


// HIGH (alto o 1)

El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el
´pin´de salida LED:
int led = 13; // asigna a LED el valor 13
int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el valor 0

void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13)
//como salida
pinMode(boton, INPUT); // configura botón (pin7)
} //como entrada

void loop()
{
valor = digitalRead(boton); //lee el estado de la
//entrada botón
digitalWrite(led, valor); //envía a la salida ´led´
} //el valor leído

31
E/S analógica

analogRead(pin)

Lee el valor desde un pin analógico especificado con una resolución de 10 bits. Esta función sólo
trabaja en los pines analógicos (0 - 5). Los valores enteros devueltos están en el rango de 0 a 1023.
value = analogRead(pin); //ajusta 'value' igual a 'pin'

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

analogWrite(pin, value)

Escribe un valor pseudo analógico usando modulación por ancho de pulso (PWM en inglés) a un
pin de salida marcado como PWM. En los Arduinos más nuevos con el chip ATmega328, esta función
trabaja en los pines 3, 5, 6, 9, 10 y 11. Los Arduinos más antiguos con un ATmega8 sólo 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' analógico

El valor de salida varía de 0 a 5 V según el valor de entrada (de 0 a 255) en función 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
función del tiempo.

Tabla 4.1: Relación valor-salida con analogWrite()

Valor Nivel de salida


0 0 V (t)
64 0 V ( ¾ t) y 5 V ( ¼ t)
128 0 V ( ½ t) y 5 V ( ½ t)
192 0 V ( ¼ t) y 5 V ( ¾ t)
255 5 V (t)

Debido a que esta es una función de hardware, en el pin de salida analógica (PWN) se generará
una onda constante después de ejecutada la instrucción analogWrite hasta que se llegue a ejecutar
otra instrucción analogWrite (o una llamada a digitalRead o digitalWrite en el mismo pin).

32
El siguiente ejemplo lee un valor analógico de un pin de entrada analógica, convierte el valor
dividiéndolo por 4, y envía el nuevo valor convertido a una salida del tipo PWM o salida analógica:

int led = 10; // define el pin 10 como ´led´


int analog = 0; // define el pin 0 como ´analog´
int valor; // define la variable ´valor´

void setup(){} // no es necesario configurar


// entradas y salidas
void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo asocia
//a la variable valor
valor /= 4; //divide valor entre 4 y lo
//reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor
}

Control del tiempo

delay(ms)

Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia


instrucción. De tal manera que 1000 equivale a 1seg.

delay(1000); // espera 1 segundo

millis()

Devuelve el número de milisegundos 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 número se desbordará (resetear de nuevo a cero), después de aproximadamente 9


horas.

33
Matemáticas

min(x,y)

Calcula el mínimo de dos números de cualquier tipo de datos y devuelve el número más
pequeño.
value = min(value, 100); /*asigna a 'value' al más pequeño
de ‘value’ o 100, asegurándose
que nunca superar 100*/

max(x,y)

Calcula el máximo de dos números de cualquier tipo de datos y devuelve el número más grande.
value = max(value, 100); /*asigna a 'value' al más grande
de ‘value’ o 100, asegurándose
que sea al menos 100*/

Aleatorio

randomSeed(seed)

Asigna un valor, o semilla (seed en inglés), como el punto de partida para la función random().

randomSeed(value); //asigna 'value' como la semilla aleatoria

Como el Arduino es incapaz de crear un número verdaderamente aleatorio, randomSeed te


permite colocar una variable, constante, u otra función dentro de la función random, lo cual ayuda a
generar más números <random> aleatorios. Existen una variedad de diferentes semillas, o funciones,
que pueden ser usadas en esta función incluyendo millis() o incluso analogRead() para leer ruido
eléctrico a través de un pin analógico.

random(max) , random(min, max)

La función random te permite devolver números pseudo-aleatorios en un rango especificado por


los valores min y max.

value = random(100, 200); //asigna a 'value' un número aleatorio


//entre 100 y 200

34
Nota: Usar esta función después emplear la función 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 señal PWM
delay(500);
}

Comunicación Serie

Serial.begin(rate)

Abre el puerto serie y asigna la tasa de baudios para la transmisión de datos serie. La típica tasa
de baudios para comunicarse con el ordenador es 9600 aunque otras velocidades están soportadas.

void setup()
{
Serial.begin(9600); //abre el puerto serie ajusta
//la tasa de datos a 9600 bps
}

Nota: Cuando se usa la comunicación 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 línea automáticos.
Este comando toma la misma forma que Serial.print(), pero es más fácil para leer datos en el Serial
Monitor1.
Serial.println(analogValue); //envia el valor de 'analogValue'

Nota: Para obtener más información sobre las distintas posibilidades de Serial.println() y
Serial.print() puede consultarse el sitio web de Arduino.

El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos al ordenador cada 1
segundo.

void setup()
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
BIBLIOGRAFÍA

[1] EVANS, Brian W., (2011) Arduino Programming Notebook.


[2] ENRÍQUEZ HERRADIR, Rafael, (2009), Guía de Usuario de Arduino
[3] TIENDA DE ROBÓTICA,
[4] ARDUINO - Wikipedia, the free encyclopedia, (última modificación, Septiembre 2015). Disponible
en: http://en.wikipedia.org/wiki/Arduino
[5] ARDUINO - Homepage, (última modificación, Julio 2008). Disponible en: http://www.
arduino.cc
[6] WIRING, (última modificación, Junio 2008). Disponible en: http://www.wiring.org.co

37
Apéndice A
Esquemático de Arduino UNO Rev 3

38