ndice.

Fundamentos
Esta pgina alberga explicaciones de algunos de los elementos del hardware y
software de Arduino y los los conceptos que hay tras ellos.
Conceptos Bsicos

Programas (Sketch): Los diferentes elementos de un programa y cmo

funcionan.

Microcontroladores

Pines Digitales: Como trabajan los pines y que significa configuralos como de
entrada o de salida.
Pines de Entrada Analgicos: Detalles respecto a la conversin analgico a
digital y otros usos de los pines.
PWM: Como la funcin analogWrite() simula una salida analgica usando
modulacin por ancho de pulso.
Memoria: Los distintos tipos de memoria disponibles en la placa Arduino.

Tcnica de Programacin

Variables Cmo se definen y se usan las variables.

Funciones: Como se definen y se usan las funciones.
Libreras: Como se escribe tu propia librera.

Circuitos

Arduino en una placa entrenadora (Breadboard): Usando el microcontrolador de

un Arduino en una placa entrenadora.

Qu es Arduino ?
Arduino es una herramienta para hacer que los ordenadores puedan sentir y
controlar el mundo fsico a travs de tu ordenador personal. Es una plataforma de
desarrollo de computacin fsica (physical computing) de cdigo abierto, basada en una
placa con un sencillo microcontrolador y un entorno de desarrollo para crear software
(programas) para la placa.
Puedes usar Arduino para crear objetos interactivos, leyendo datos de una gran
variedad de interruptores y sensores y controlar multitud de tipos de luces, motores y
otros actuadores fsicos. Los proyecto de Arduino pueden ser autnomos o comunicarse
con un programa (software) que se ejecute en tu ordenador (ej. Flash, Processing,
MaxMSP). La placa puedes montarla tu mismo o comprarla ya lista para usar, y el
software de desarrollo es abierto y lo puedes descargar gratis.
El lenguaje de programacin de Arduino es una implementacin de Wiring, una
plataforma de computacin fsica parecida, que a su vez se basa en Processing, un
entorno de programacin multimedia.

Por qu Arduino?
Hay muchos otros microcontroladores y plataformas con microcontroladores
disponibles para la computacin fsica. Parallax Basic Stamp, BX-24 de Netmedia,
Phidgets, Handyboard del MIT, y muchos otros ofrecen funcionalidades similares.
Todas estas herramientas organizan el complicado trabajo de programar un
microcontrolador en paquetes fciles de usar. Arduino, adems de simplificar el proceso
de trabajar con microcontroladores, ofrece algunas ventajas respecto a otros sistemas a
profesores, estudiantes y amateurs:

Asequible - Las placas Arduino son ms asequibles comparadas con otras

plataformas de microcontroladores. La versin ms cara de un modulo de
Arduino puede ser montada a mano, e incluso ya montada cuesta bastante menos
de 60
Multi-Plataforma - El software de Arduino funciona en los sistemas operativos
Windows, Macintosh OSX y Linux. La mayora de los entornos para
microcontroladores estn limitados a Windows.
Entorno de programacin simple y directo - El entorno de programacin de
Arduino es fcil de usar para principiantes y lo suficientemente flexible para los
usuarios avanzados. Pensando en los profesores, Arduino est basado en el
entorno de programacin de Procesing con lo que el estudiante que aprenda a
programar en este entorno se sentir familiarizado con el entorno de desarrollo
Arduino.
Software ampliable y de cdigo abierto- El software Arduino esta publicado
bajo una licencia libre y preparado para ser ampliado por programadores
experimentados. El lenguaje puede ampliarse a travs de libreras de C++, y si se
est interesado en profundizar en los detalles tcnicos, se puede dar el salto a la
programacin en el lenguaje AVR C en el que est basado. De igual modo se
puede aadir directamente cdigo en AVR C en tus programas si as lo deseas.

Hardware ampliable y de Cdigo abierto - Arduino est basado en los

microcontroladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los planos
de los mdulos estn publicados bajo licencia Creative Commons, por lo que
diseadores de circuitos con experiencia pueden hacer su propia versin del
mdulo, amplindolo u optimizndolo. Incluso usuarios relativamente
inexpertos pueden construir la versin para placa de desarrollo para entender
cmo funciona y ahorrar algo de dinero.

Cmo uso Arduino?

Los textos de la gua "Como empezar con Arduino" estn licenciados bajo
Creative Commons Attribution-ShareAlike 3.0 License. El cdigo fuente de los
ejemplos en la gua estn liberados como dominio pblico.

Primer Sketch.
En la gua de inicio (Windows, Mac OS X, Linux), subiste un sketch que hace
parpadear un LED. En este tutorial, aprenderas como funciona cada parte de ese sketch.
Sketch
Un sketch es el nombre que usa Arduino para un programa. Es la unidad de
codigo que se sube y ejecuta en la placa Arduino.
Comentarios
Las primeras lineas del sketch Blink son un comentario:
/*
* Blink
*
* The basic Arduino example. Turns on an LED on for one second,
* then off for one second, and so on... We use pin 13 because,
* depending on your Arduino board, it has either a built-in LED
* or a built-in resistor so that you need only an LED.
*
* http://www.arduino.cc/en/Tutorial/Blink
*/

Todo lo que se encuentra entre /* y */ es ignorado por Arduino cuando ejecuta el

sketch (el * al comienzo de cada linea esta ahi solo para que el comentario se vea bien,
no es requerido). Esta ah para la gente que lee el cdigo: para explicar lo que hace el
programa, como funciona, o por que esta escrito de tal manera. Es muy buena practica
poner comentarios en tus sketches, y mantener estos actualizados cuando modiques el
cdigo. Esto ayuda a otras personas a aprender de tu codigo y modificar el mismo.
Existe otro estilo para comentarios cortos, de una sola linea. Estos comienzan
con // y continuan hasta el final de la linea. Por ejemplo en la linea:
int ledPin = 13;

// LED connected to digital pin 13

el mensaje "LED connected to digital pin 13" es un comentario.

Variables.
Una variable es un lugar donde se almacena un dato. Posee un nombre, un tipo y
un valor. Por ejemplo, la linea del sketch Blink anterior declara una variable con el
nombre ledPin, de tipo int, y con el valor inicial 13. Esta siendo utilizada para indicar
que pin de Arduino se conecta al LED. Cada vez que el nombre ledPin aparece en el
codigo, su valor sera utilizado. En este caso, la persona que escribio el codigo podria no
haberse molestado en definir la variable ledPin y utilizar simplemente 13 en todas las
partes en que debiese especificar el numero del pin. La ventaja de utilizar una variable
es que se hace mucho ms fcil mover el LED a un pin diferente: solo necesitas editar la
linea en que se asigna el valor inicial a la variable.
Con frecuencia, el valor de una variable cambiara a medida que se ejecuta el
sketch. Por ejemplo, podras almacenar en una variable el valor ledo desde un input.
Hay ms informacin en el tutorial de variables.

Funciones.
Una funcin (tambin conocida como procedimiento o sub-rutina) es un pedazo
de cdigo que puede ser utilizado desde cualquier otro punto del sketch. Por ejemplo,
aqu esta la definicin de la funcin setup() en el ejemplo Blink:
void setup()
{
pinMode(ledPin, OUTPUT);
}

// sets the digital pin as output

La primera linea nos entrega informacin sobre la funcin, como su nombre,

"setup". El texto que hay antes y despues del nombre especifica el tipo de devolucin y
los parametros de la funcin: estos seran explicados ms adelante. El codigo entre { y }
es conocido como cuerpo de la funcin: lo que la funcin realiza.
Puedes llamar a una funcin que ha sido previamente definida (ya sea en tu
sketch o como parte del lenguaje Arduino). Por ejemplo, la linea pinMode(ledPin,
OUTPUT); llama la funcin pinMode(), pasandole sus dos parametros: ledPin y
OUTPUT. Estos parametros son utilizados por la funcin pinMode para decidir que pin
y modo utilizar.
pinMode(), digitalWrite(), y delay()
La funcin pinMode() configura un pin como entrada o salida. Para utilizarla, le
pasas el numero del pin que vas a configurar y la constante INPUT o OUTPUT. Cuando
est configurada como input, un pin puede detectar el estado de un sensor, como un
pulzador; esto se discute en un tutorial ms adelante?. Como salida, este puede manejar
un actuador, como un LED.
La funcin digitalWrite() enva un valor a un pin. Por ejemplo, la linea:

digitalWrite(ledPin, HIGH);

modifica ledPin (pin 13) como HIGH, o 5 volts. Enviando LOW a un pin lo conecta a
tierra, o 0 volts.
delay() hace a Arduino esperar por el numero especificado de milisegundos antes de
continuar con la siguiente linea. Hay 1000 milisegundos en un segundo, por lo que la
linea:
delay(1000);

crea un retraso de un segundo.

setup() y loop()
Existen dos funciones especiales que son parte de cada sketch de Arduino:
setup() y loop(). setup() es llamado una vez, cuando comienza el sketch. Es un buen
lugar para realizar tareas de configuracin, como definir los pins o inicializar
bibliotecas. La funcin loop() se llama una y otra vez y es el corazn de la mayoria de
los sketches. Necesitas incluir ambas funciones en tu sketch, aun cuando no las
necesites para nada.
Ejercicios.
1. Modifica el cdigo para que el LED este encendido por 100 milisegundos y
apagado por 1000.
2. Modifica el cdigo para que el LED se encienda cuando el sketch comienze y se
mantenga encendido.
Revisa tambin

setup()
loop()
pinMode()
digitalWrite()
delay()

Pines Digitales.
Los pines del Arduino pueden configurarse como entradas o salidas. Este
documento explica el funcionamiento de los pines en esos modos. Si bien el ttulo de
este documento se refiere a los pines digitales, es importante sealar que la gran
mayora de los pines analgicos de Arduino (Atmega), pueden configurarse y utilizarse,
exactamente de la misma manera que los pines digitales.
Propiedades de los Pines Configurados como Entrada (INPUT)
Los pines de Arduino (Atmega) por defecto son de entrada, por lo que no es
necesario configuraros explcitamente como entradas con pinMode(). Se dice que los
pines configurados como entradas estn en estado de alta impedancia. Una forma de
explicar esto es que los terminales de entrada hacen demandas extremadamente
pequeas en el circuito que estn muestreando, se dice que equivale a una resistencia en
serie de 100 megaohmio frente al pin. Esto significa que se necesita muy poca corriente
para pasar el pin de entrada de un estado a otro, y puede hacer posible el uso de los
pines para tareas como la utilizacin de un sensor capacitivo al tacto, la lectura de un
LED como un fotodiodo, o la lectura de un sensor analgico con un esquema como el
RCTime.
Esto tambin significa sin embargo, que los terminales de entrada sin conectar
nada a ellos, o con los cables conectados a ellos sin estar conectados a otros circuitos,
reflejarn cambios aparentemente aleatorios en el estado de pin, recogiendo el ruido
elctrico del entorno, o el acoplamiento capacitivo del estado de un pin prximo.
Resistencias Pullup
A menudo es til para colocar un pin de entrada en un estado conocido si no hay
un estado de entrada. Puede hacerse aadiendo una resistencia pull-up (a +5 V), o una
resistencia pull-down (resistencia a tierra) en la entrada, 10K suele ser un valor muy
comn.
Tambin hay resistencias pullup de 20K conveniente integradas en el chip
Atmega a las que se puede acceder desde el software. Estos resistencias pull-up
incorporadas son accedidas de la siguiente manera.
pinMode(pin, INPUT);
digitalWrite(pin, HIGH);

// pone el pin como entrada

// activa la resistencia pullup

Ten en cuenta que las resistencias pull-up proporcionan suficiente corriente para
dar una luz tenue con un LED conectado a un pin que se ha configurado como entrada.
Si el LED de un proyecto parece estar funcionando pero muy tenuemente, es posible
que sea esto lo que est pasando, y el programador ha olvidado usar pinMode() para
ajustar los pines como salidas.
Tambin debes tener en cuenta que las resistencias pull-up son controladas por
los mismos registros (posiciones de memoria interna del chip) que controlan si un pin
est alto (HIGH) o bajo (LOW). Por consiguiente, un pin que se configura para tener las
7

resistencias pullup activadas cuando esta configurado como entrada, debe tener el pin a
alto (HIGH) si el pin es cambiado como salida (OUTPUT) con pinMode(). Esto
funciona en la otra direccin tambin, y un pin de salida que queda en un estado alto
tendr las resistencias pull-up activas, si cambia a entrada (INPUT) con pinMode().
NOTA: El pin Digital 13 es ms difcil de usar que otros pines digitales porque tiene un
LED y una resistencia asociada soldados a la placa en la mayora de las placas. Si activa
la resistencia pull-up 20k del interior, se pondra en alrededor de 1,7 V en lugar de los
5V que se esperan debido a que el LED integrado y la resistencia en serie bajan el nivel
del voltaje, lo que se traduce en que siempre retornar bajo (LOW). Si ests obligado a
usar el pin 13 como entrada digital, utiliza una resistencia pulldown externa.
Propedades de los Pines Configurados com salida (OUTPUT )
Los pines configurados como salida (OUTPUT) con pinMode() se dice que estn
en un estado de baja impedancia. Esto significa que puede proporcionar una cantidad
sustancial de corriente a otros circuitos. Los pines del Atmega pueden proporcionar
corriente positiva o proporcionar corriente negativa de hasta 40 mA (miliamperios) a
otros dispositivos o circuitos. Esta es suficiente corriente para la brillante luz de un LED
(no te olvides de la resistencia en serie), o para utilizar muchos sensores por ejemplo,
pero no es corriente suficiente para utilizar la mayora de rels, solenoides o motores.
Los cortocircuitos en los pines de Arduino, o intentos de extraer mucha corriente
de ellos, pueden daar o destruir los transistores de salida en el pin, o daar
completamente el chip Atmega. A menudo, esto se traducir en un pin del
microcontrolador "muerto", pero el resto del chip seguir funcionando adecuadamente.
Por esta razn es buena idea conectar los pines de salida a otros dispositivos con
resistencias de 470 o 1k, limitando la corriente mxima que desde los pines es
requerida para una aplicacin particular.
Volver a Fundamentos
Ver Tambin

pinMode()
digitalWrite()
digitalRead()

Pins de Entrada Analgica.

Una descripcin de las entradas analgicas del chip de Arduino (Atmega8,
Atmega168, Atmega328, or Atmega1280).
Conversor A/D
El controlador Atmega que usa Arduino lleva incluido un conversor analgicodigital (A/D) de 6 canales. Tiene una resolucin de 10 bits, retornando enteros desde 0 a
1023. Mientras que el uso principal de estos pines por los usuarios de Arduino es para la
lectura de sensores analgicos, estos pines tienen tambien toda la funcionalidad de los
pines de entrada-salida de propsito general (GPIO) (al igual que los pines 0 - 13).
Consecuentemente, si un usuario necesita ms pines de propsito general de entradasalida, y no se est usando ningn pin analgico, estos pines pueden usarse como GPIO.
Mapeo de Pins
Los pines de Arduino correspondientes a los pines analgicos son desde el 14 al
19. Observa que esto son pines de Arduino y no corresponden con los nmeros de los
pines fsicos del chip Atmega. Los pines analgicos, pueden usarse de manera idntica
que los digitales, as que por ejemplo, podras ver un cdigo como este para configurar
un pin analgico,y establecerlo a HIGH:
pinMode(14, OUTPUT);
digitalWrite(14, HIGH);
Resistencias Pullup
Los pines analgicos tambin tienen resistencias pullup, las cuales funcionan
igual que en los pines digitales. Se activan cuando usamos instrucciones como la
siguiente
digitalWrite(14, HIGH); // activa la resistencia pullup en el pin analgico 0
Mientras el pin es una entrada (input).
Ten en cuenta que si, por descuido, activamos una resistencia pullup, mientras
usamos algunos sensores, los valores obtenidos por analogRead() se vern afectados. La
mayora de los usuarios usarn las resistencias pullup cuando usen un pin analgico
como digital.
Detalles y Observaciones
El comando analogRead no funcionar adecuadamente si el pin analgico se
estableci como salida,as que si es tu caso, vuelve a aestablecerlo como entrada antes
de usar analogRead. De igual manera si el pin , siendo de salida,se estableci a HIGH,
la resistencia pullup permanecera activa, aunque volvamos a establecerla como entrada.

La hoja de datos de ATmega nos previene acerca de la conmutacin (de

analgico a digital) de los pines analgicos en las proximidades de una lectura
(analogRead) en otros pines analgicos. Esto puede producir ruidos y fluctuaciones en
el sistema analgico. Puede ser til, despus de manipular pines analgicos (en modo
digital), aadir una pequea parada (delay) antes de usar analogRead() en otros pines
analgicos.

10

PWM.
El ejemplo "Fading" demuestra el uso de una salida analgica (PWM) para
atenuar y aumentar la luminosidad de un LED. Lo tienes disponible en la opcin "File>Sketchbook->Examples->Analog" del men del software de Arduino.
La Modulacin por Ancho de Pulso (PWM = Pulse Width Modulation) es una
tecnica para simular una salida analgica con una salida digital. El control digital se usa
para crear una onda cuadrada, una seal que conmuta constantemente entre encendido y
apagado. Este patron de encendido-apagado puede simular voltajes entre 0 (siempre
apagado) y 5 voltios (siempre encendido) simplemente variando la proporcin de
tiempo entre encendido y apagado. A la duracin del tiempo de encendido (ON) se le
llama Ancho de Pulso (pulse width). Para variar el valor analgico cambiamos, o
modulamos, ese ancho de pulso. Si repetimos este patrn de encendido-apagado lo
suficientemente rapido por ejemplo con un LED el resultado es como si la seal variara
entre 0 y 5 voltios controlando el brillo del LED.
En el grafico de abajo las lineas verdes representan un periodo regular. Esta
duracin o periodo es la inversa de la frecuencia del PWM. En otras palabras, con la
Arduino la frecuencia PWM es bastante proxima a 500Hz lo que equivale a periodos de
2 milisegundos cada uno. La llamada a la funcin analogWrite() debe ser en la escala
desde 0 a 255, siendo 255 el 100% de ciclo (siempre encendido), el valor 127 ser el
50% del ciclo (la mitad del tiempo encendido), etc.

11

Una vez cargado y ejecutado el ejemplo mueve la arduino de un lado a otro, lo

que ves es esencialmente un mapeado del tiempo a lo largo del espacio. A nuestros ojos
el movimiento difumina cada parpadeo del LED en una linea. A medida que la
luminosidad del LED se incrementa o atenua esas pequeas lineas crecen o se reducen.
Ahora estas viendo el ancho de pulso (pulse width).
Written by Timothy Hirzel

12

Memoria.
Existen 3 fuentes de memoria en el microcontrolador utilizado por la placa Arduino
(ATmega168):

Memoria Flash (espacio del programa), donde Arduino almacena el sketch.

SRAM (static random access memory, memoria estatica de acceso aleatorio)
donde los sketches almacena y manipulan variables al ejecutarse.
EEPROM es un espacio de memoria que puede ser utilizada por los
programadores para almacenar informacin de largo plazo.

La memoria Flash y EEPROM son no-volatiles (la informacin se mantiene en ellas

luego de cortar la alimentacin). SRAM es volatl y se perdera al reiniciar la unidad.
El chip ATmega168 cuenta con las siguientes cantidades de memoria:
Flash 16k bytes (de los que 2k son utilizados por el bootloader)
SRAM 1024 bytes
EEPROM 512 bytes

Ten en cuenta que no hay mucha SRAM disponible. Es fcil utilizarla toda al
tener muchas cadenas (strings) en tu programa. Por ejemplo, una declaracin como:
char message[] = "Ah, qu hermoso..., qu hermoso."

pone 32 bytes en la SRAM (cada caracter utiliza un byte). Esto pude no parecer mucho,
pero no toma mucho ms llegar hasta 1024, especialmente si tienes largas cantidades de
texto que enviar a una pantalla, o una tabla de datos muy grande, por ejemplo.
Si se te acaba la SRAM, tu programa fallara de manera improvista; parecera subir a
la placa de manera correcta, pero no se ejecutara, o se ejecutara de manera extraa. Para
comprobar si esto es lo que sucede, puedes intentar comentado o acortando las cadenas
de texto u otras estructuras de datos en tu sketch (sin alterar el cdigo). Si entonces este
funciona correctamente, es probable que el problema haya sido la SRAM llena. Hay
unas pocas cosas que puedes hacer para solucionar este problema:

Si tu sketch se comunica con una aplicacin corriendo en un ordenador, puedes

intentar trasladar datos o calculos al ordenador, reduciendo la carga en el
Arduino.
Si tienes tablas de referencia o otros arreglos de gran tamao, utiliza el tipo de
datos mas pequeo que puedas para almacenar estos datos; por ejemplo, un int
utliza 2 bytes, mientras que un byte utiliza solo uno (pero puede almacenar un
rango menor de datos).
Si no necesitas modificar las cadenas o datos mientras el sketch se ejecuta,
puedes almacenarlos en la memoria Flah (de programa) en vez de la SRAM;
para esto, utiliza el keyword PROGMEM

13

If you don't need to modify the strings or data while your sketch is running, you
can store them in flash (program) memory instead of SRAM; to do this, use the
PROGMEM keyword.

Para utilizar la EEPROM, consulta la biblioteca EEPROM.

14

Variables.
Una variable es una ubicacin para almacenar una porcin de informacin.
Tiene un nombre, un valor y un tipo. Por ejemplo, esta sentencia (llamado una
declaracin):
int pin = 13;
crea una variable cuyo nombre es pin, whose value is 13, y su tipo es int. Mas tarde en
el programa, puedes hacer referencia a esta variable por su nombre, momento en el que
puedes acceder a su valor y utilizarlo. Por ejemplo, en esta sentencia:
pinMode(pin, OUTPUT);
es el valor de pin (13) el que ser pasado a la funcinpinMode(). En este caso, realmente
no necesitas usar una variable, esta sentencia funcionara igual de bien:
pinMode(13, OUTPUT);
La ventaja de una variable en este caso es que solo necesitas especificar el
nmero del pin una nica vez, pero puedes usarlo montones de veces. As, si mas tarde
decides cambiar el pin 13 por el 12, solo tienes que cambiarlo en un punto del cdigo.
Adems puedes usar un nombre descriptivo que tenga que ver con el uso que vas a dar a
la variable (ej. un programa para controlar un LED RGB (Rojo, Verde y Azul) podra
tener variables llamada PinRojo, PinVerde y PinAzul).
Una variable tiene otras ventajas sobre un valor como un nmero. La ms
importante, puedes cambiar el valor de una variable mediante un asignador
(representado por el signo igual). Por ejemplo:
pin = 12;
cambiar el valor de la variable a 12. Observa que no se especifica el tipo de la variable:
este no cambia con la asignacin. Es decir, el nombre de la variable est
permanentemente asociado a un tipo; slo esto cambia valor. [1] Ten en cuenta que
tienes que declarar una variable antes de asignarle un valor. Si se incluye la instruccin
anterior en un programa sin la previa declaracin anterior, obtendras un mensaje del
estilo: "error: pin was not declared in this scope" ("Error: pin no ha sido declarado en
este mbito").
Cuando se asigna una variable a otra, ests haciendo una copia de su valor y
almacenando dicha copia en la ubicacin de memoria asociada a la otra variable.
Cambiando una no tiene efecto en la otra. Por ejemplo, despus de:
int pin = 13;
int pin2 = pin;
pin = 12;
slo pin tiene el valor 12; pin2 tiene todava 12.
15

Y ahora qu, puede que te preguntes que significa la palabra "scope" (alcance)
en ese mensaje de error anterior? Se refiere a la parte de tu programa en el que se puede
usar la variable. Esto se determina por el lugar donde se declara. Por ejemplo, si quieres
poder utilizar una variable en cualquier parte de tu programa, puedes declararla en la
parte superior de tu cdigo. Esto se llama variable global, aqu tienes un ejemplo:
int pin = 13;
void setup()
{
pinMode(pin, OUTPUT);
}
void loop()
{
digitalWrite(pin, HIGH);
}
Como puedes ver, pin se usa tanto en la funcin setup() como en loop(). Ambas
funciones hacen referencia a la misma variable, por lo que un cambio en una afectar al
valor que tendr en la otra, como en:
int pin = 13;
void setup()
{
pin = 12;
pinMode(pin, OUTPUT);
}
void loop()
{
digitalWrite(pin, HIGH);
}
Aqu, a la funcin digitalWrite() llamada desde loop() se le pasa el valor 12, ya que es el
valor que se le asigna a la variable en la funcin setup().
Si tienes que utilizar una variable en una sola funcin, puedes declararla en la misma, en
cuyo caso el mbito (scope) de utilizacin se limita a esa funcin. Por ejemplo:
void setup()
{
int pin = 13;
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
}
En este caso, la variable pin slo podr ser usada dentro de la funcin setup(). Si tratas
de hacer algo como esto:
16

void loop()
{
digitalWrite(pin, LOW); // incorrecto: pin no tiene mbito aqu.
}
obtendrs el mismo mensaje que antes: "error: 'pin' was not declared in this scope"
("error: 'pin' no se declar en este mbito"). Es decir, a pesar de que has declarado pin
en algn sitio en tu programa, est tratando de utilizarlo en alguna parte fuera de su
mbito de aplicacin.
Te puedes preguntar por qu no hacemos todas las variables globales? Despus
de todo, si no s dnde puedo necesitar una variable, por qu limitar su alcance a una
sola funcin? La respuesta puede que sea ms fcil de averiguar lo que te parece. Si una
variable es global, su valor podra cambiarse en cualquier parte del cdigo, lo que
significa que necesita entender la totalidad del programa para saber qu va a pasar con
la variable. Por ejemplo, si la variable tiene un valor que no esperabas, puede ser mucho
ms fcil de averiguar de donde viene el valor si la variable tiene un alcance limitado.
[block scope] [size of variables]
[1] En algunos lenguages de programacin, como Python, los tipos se asocian con
valores, no a los nombres de variables, y se pueden asignar valores de cualquier tipo a
una variable. Esto se conoce como tipos dinmicos (dynamic typing).

17

Funciones.
Segmentar el cdigo en funciones permite al programador crear piezas
modulares de cdigo que realizan una tarea definida y vuelven a la zona del programa
en la que fueron llamadas. El caso tpico para crear un funcin es cuando uno necesita
realizar la misma accin mltiples veces dentro de un mismo programa.
Para programadores acostumbrados a utilizar BASIC las funciones en Arduino permiten
(y extienden) la utilidad de usar subrutinas (GOSUB en BASIC).
La estandarizacin de fragmentos de cdigo en funciones tiene diversas ventajas:

Las funciones ayudan al programador a ser organizado. Adems ayudan a

conceptualizar el programa.
Las funciones codifican una accin en un lugar, as que slo deben ser depuradas
de errores una vez.
Reducen las posibilidades de error en modificaciones, si el cdigo debe ser
cambiado.
Las funciones hacen el sketch mas pequeo y mas compacto por que las
secciones de cdigo se reutilizan varias veces.
Hacen mas fcil la reutilizacin de cdigo en otros programas por hacerlo mas
modular y, como efecto paralelo, usando funciones se obtiene un cdigo mas
legible.

Hay dos funciones necesarias en un sketch de Arduino: setup() y loop(). El resto de

funciones debe ser definido fuera de las llaves de estas dos funciones. Como ejemplo
vamos a crear una funcin muy simple que multiplica dos nmeros.
Ejemplo

Al "invocar" a nuestra pequea funcin le pasamos parametros del tipo de dato que ella
espera.
void loop{
18

int i = 2;
int j = 3;
int k;
k = myMultiplyFunction(i, j); // k ahora contiene 6
}

Nuestra funcin necesita ser declarada fuera de cualquier otra funcin, por ello
"myMultiplyFunction()" puede ir antes o despues de la funcin "loop()".
El sketch completo podra ser algo como esto:
void setup(){
Serial.begin(9600);
}
void loop{
int i = 2;
int j = 3;
int k;
k = myMultiplyFunction(i, j); // k ahora contiene 6
Serial.println(k);
delay(500);
}
int myMultiplyFunction(int x, int y){
int result;
result = x * y;
return result;
}
Otro ejemplo:
Esta funcin leer un sensor cinco veces con analogRead() y calcular la media
de las cinco lecturas. Escala los datos a 8 bits (0-255), los invierte y devuelve el
resultado invertido.
int ReadSens_and_Condition(){
int i;
int sval;
for (i = 0; i < 5; i++){
sval = sval + analogRead(0);
}

// sensor en pin analgico 0

sval = sval / 5; // media

sval = sval / 4; // escala a 8 bits (0 - 255)
sval = 255 - sval; // invierte el resultado
19

return sval;

// devuelve el resultado

}
Para llamar a nuestra funcin solo tenemos que asignarla a una variable.
int sens;
sens = ReadSens_and_Condition();

Pgina principal Referencia

Correcciones, sugerencias, y nueva documentacin debern ser publicadas en el Foro
(castellano) o en el Foro (ingls).
El texto de la referencia de Arduino est publicado bajo la licencia Creative Commons
Reconocimiento-Compartir bajo la misma licencia 3.0. Los ejemplos de cdigo de la
referencia estn liberados al dominio pblico.

20

Escribir una librera para Arduino.

Este documento explica cmo crear una librera para Arduino. Se inicia con un
programa de cdigo Morse y explica cmo convertir sus funciones en una librera. Esto
permite que otras personas usen el cdigo que has escrito y puedan actualizarlo
facilmente a medida que mejora la librera.
Comenzamos con un programa de cdigo Morse:
int pin = 13;
void setup() {
pinMode(pin, OUTPUT);
}
void loop() {
punto(); punto(); punto();
raya(); raya(); raya();
punto(); punto(); punto();
delay(3000);
}
void punto() {
digitalWrite(pin, HIGH);
delay(250);
digitalWrite(pin, LOW);
delay(250);
}
void raya() {
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(250);
}
Si ejecuta este programa, se representar el cdigo de SOS (llamada de auxilio) en el
pin 13.
El programa tiene unas pocas partes que tendremos que poner en nuestra librera.
En primer lugar, tenemos las funciones punto() y raya() que hacen el parpadeo. En
21

segundo lugar, tenemos la variable ledPin que indica el pin a utilizar. Por ltimo, est la
llamada a pinMod () que inicializa el pin como salida.
Vamos a empezar a convertir el programa en una librera!
Para una librera necesita al menos dos arcivos: un archivo de cabecera (w / con
extensin. H) y el cdigo fuente (w / extensin. cpp). El archivo de cabecera contiene
definiciones para la librera: bsicamente un listado de todo lo que hay dentro, mientras
que el archivo del cdigo fuente tiene el cdigo real. Vamos a llamar a nuestra librera
"Morse", por lo que nuestro archivo de cabecera ser Morse.h. Echemos un vistazo a lo
que contiene. Puede parecer un poco extrao al principio, pero tendr ms sentido una
vez que vea el cdigo fuente que lo acompaa.
El archivo de cabecera consiste bsicamente en una clase con una lnea para cada
funcin de la librera, junto con las variables que se van a usar:
class Morse {
public:
Morse(int pin);
void punto();
void raya();
private:
int _pin;
};
Una clase es simplemente una coleccin de funciones y variables agrupadas en
un mismo lugar. Estas funciones y variables pueden ser pblicas, lo que significa que
las podrn usar las personas que estn utilizando la librera, o privada, lo que significa
que slo se puede acceder a ellas desde la propia clase. Cada clase tiene una funcin
especial conocida como constructor, que se utiliza para crear una instancia de la clase (o
sea, un objeto). El constructor tiene el mismo nombre que la clase, y no devuelve nada.
Se necesitan un par cosas ms en el archivo de encabezado. Una de ellas es una
instruccin # include que da acceso a los tipos estndar y las constantes del lenguaje
Arduino (esto se agrega automticamente a los programas normales, pero no a las
libreras). Se parece a esto (y se coloca antes de la definicin de la clase mostrada
anteriormente):
1. Include "WProgram.h"
Por ltimo, es comn aadir las siguientes lineas de cdigo :
1. Ifndef Morse_h
2. Define Morse_h
// La declaracin # include y el cdigo van aqu ...
1. endif
22

Bsicamente, esto evita problemas si alguien accidentalmente usa dos veces el

#include con la librera que estamos construyendo, evitando que se declaren las
variables y funciones ms de una vez.
Por ltimo, se suele poner un comentario en la parte superior de la librera con su
nombre, una breve descripcin de lo que hace, quin lo escribi, la fecha y el tipo de
licencia.
Echemos un vistazo a la cabecera completa:
/*
Morse.h - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.

1. ifndef Morse_h
2. define Morse_h
3. include "WProgram.h"
class Morse {
public:
Morse(int pin);
void punto();
void raya();
private:
int _pin;
};
1. endif
Vamos a repasar las distintas partes del cdigo fuente de Morse.cpp.
Lo primero son un par de # include. Con esto el resto del cdigo tendr acceso a las
funciones estndar de Arduino, y a las definiciones definidas en Morse.h:
1. Include "WProgram.h"
2. Include "Morse.h"
A continuacin viene el constructor. Una vez ms, en el constructor se establece lo
que debe ocurrir cuando alguien crea una instancia de la clase. En este caso, el usuario
especifica el pin que le gustara utilizar. Configuramos el pin como salida en una
variable privada para su uso en las otras funciones:
MORSE:: Morse (pin int) ( pinMode (pin, OUTPUT); _pin = pin; )

23

Hay un par de cosas extraas en este cdigo. La primera es el Morse:: antes del
nombre de la funcin. Esto indica que la funcin es parte de la clase Morse. Vers esto
en otras funciones de la clase. Lo segundo es el subrayado en el nombre de nuestra
variable privada, _pin. Esta variable puede tener cualquier nombre, siempre y cuando
coincida con la definicin que figura en el archivo de encabezado. Agregar un
subrayado al inicio del nombre es una convencin comn para dejar claro que las
variables son privadas, y tambin para diferenciarlas del argumento de la funcin (el pin
en este caso).
Despus viene el cdigo del programa que estamos convirtiendo en una librera
(por fin!). Se ve ms o menos lo mismo, salvo Morse:: delante de los nombres de las
funciones, y en lugar de _pin pin:
void Morse::punto() {
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}
void Morse::raya() {
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Por ltimo, es tpico incluir un comentario en la parte superior del cdigo fuente.
Vamos a ver el cdigo:
/*
Morse.cpp - Library for flashing Morse code.
Created by David A. Mellis, November 2, 2007.
Released into the public domain.

1. include "WProgram.h"
2. include "Morse.h"
Morse::Morse(int pin) {
pinMode(pin, OUTPUT);
_pin = pin;

24

}
void Morse::punto() {
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}
void Morse::raya() {
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Y eso es todo lo que necesita (hay algunas otras cosas opcionales, pero
hablaremos de eso ms adelante). Vamos a ver cmo usar la librera.
En primer lugar, hay que crear el directorio Morse dentro del subdirectorio de
libreras . Copia o mueve los archivos Morse.h y Morse.cpp a ese directorio. Ahora
ejecuta el IDE de Arduino. Si vas al men Sketch > Import Library deberas ver el una
opcin Morse. La librera ser compilada con los programas que la utilizan. Si no
aparece la librera, asegrate de que los nombres de los archivos terminan realmente ten
.cpp y .h (y no en .pde o .txt, por ejemplo).
Vamos a ver cmo podemos modificar nuestro programa de SOS para hacer uso de la
nueva librera:
1. include <Morse.h>
Morse morse(13);
void setup() { }
void loop() {
morse.punto(); morse.punto(); morse.punto();
morse.raya(); morse.raya(); morse.raya();
morse.punto(); morse.punto(); morse.punto();
delay(3000);
}
Hay algunas diferencias con el programa original (aparte del hecho de que parte
del cdigo se ha trasladado a la librera).
25

En primer lugar, hemos aadido una declaracin # include al principio del

programa. Esto hace que la librera Morse est disponible para el programa y que se
enve a la placa de Arduino. Cuando ya no necesite una librera en un programa, debe
eliminar la sentencia # include para ahorrar espacio.
En segundo lugar, creamos una instancia de la clase Morse llamada morse:
Morse morse(13);
Cuando esta lnea se ejecute ( esto sucede incluso antes de que se ejecute la
funcin setup () ), se llamar al constructor de la clase Morse, y se le pasar un
parmetro (en este caso, el valor 13).
Tenga en cuenta que nuestro setup() est vaco, esto se debe a que la llamada a
pinMode () se produce dentro de la librera (cuando se construye la instancia).
Por ltimo, para llamar a las funciones punto() y raya(), tenemos que precederlas
del prefijo morse (que es el nombre de la instancia que hemos creado). Podramos tener
varias instancias de la clase Morse, cada una con su propio PIN almacenado en la
variable privada _pin de esa instancia. Al llamar a una funcin se indica que instancia
de la clase se debe utilizar. Es decir, si tuviramos:
Morse morse (13); Morse morse2 (12);
la llamada a morse2.dot (), hace que la salida sea por el pin 12.
Si pruebas el nuevo programa, probablemente te dars cuenta de que el IDE de
Arduino no reconoce las funciones de la librera y no resalta el cdigo. Por desgracia,
por ahora el software de Arduino no puede averiguar lo que hay definido en la librera
(aunque sera una buena caracterstica a tener en cuenta), as que tienes que ayudarle un
poco. Para ello, crea un archivo llamado keywords.txt en el directorio de Morse.. Que
debe tener este aspecto:
Morse KEYWORD1 raya KEYWORD2 punto KEYWORD2
Cada lnea tiene el nombre de la palabra clave, seguido de un tabulador (no
espacios), seguido por el tipo de palabra clave. Las clases deben ser del tipo
KEYWORD1 y se muestran de color naranja; las funciones deben ser del tipo
KEYWORD2 y sern de color marrn. Tendr que reiniciar el entorno Arduino para
conseguir que reconozca las nuevas palabras clave.
Es conveniente acompaar las libreras con algn programa de ejemplo que haga
uso las mismas. Para ello, cree un directorio examples dentro del directorio Morse. A
continuacin, copie el directorio que contiene el programa de ejemplo que escribimos
arriba (lo llamaremos SOS) en el directorio de ejemplos. (Puedes encontrar el programa
de ejemplo con la opcin Sketch > Show Sketch Folder) Si reinicias el entorno Arduino
(esta es la ltima vez, lo prometo) vers la opcin Library-Morse dentro de File >
Sketchbook > Examples que contiene su ejemplo. Es posible que quieras agregar
algunos comentarios para explicar mejor cmo usar la librera.

26

Si quieres echa un vistazo a la librera completa (con palabras clave y el

ejemplo), puede descargarlo: Morse.zip.
Eso es todo por ahora, pero probablemente voy a escribir una coleccin de tutoriales
avanzados pronto. Mientras tanto, si tienes cualquier problema o sugerencia, por favor
escribe en el foro de desarrollo de software.

27