ARDUINO Y OTRAS HIERBAS. - noeju.com · ARDUINO Y OTRAS HIERBAS. Introducción. En esta serie de tutoriales vamos a realizar una presentación de las plataformas Open Hardware para

ARDUINO Y OTRAS HIERBAS.

Introducción.

En esta serie de tutoriales vamos a realizar una presentación de las plataformas Open Hardware

para computación y control que están proliferando en los últimos meses. Nos centraremos en Arduino y

en Raspberry, aunque la oferta actual es intensiva: STM32F103 (ARM), Radxa (ARM), Cubieboard

(ARM), Odroid (ARM), Gizmo 2 (AMD), Netduino (ATMEL), en fin, una explosión en la oferta de placas

open hardware cuyo coste está en el rango de los 5-160€.

Comencemos con Arduino. ¿Qué es Arduino?.

Arduino es una plataforma para crear prototipos basada en código (y hardware) abierto. Eso quiere

decir que todo lo que hay en una placa Ardunio es accesible y se puede estudiar y modificar. La

mayoría de los Arduino se basan en microcontroladores Atmel, pero existen también algunos basados

en procesadores ARM.

La gama Arduino es muy amplia y la propia compañía la clasifica por niveles:

Nivel de entrada: Ardunio UNO y PRO.

Nivel mejorado: Arduino MEGA, ZERO y DUE.

Internet de la cosas: Arduino YÚN.

Wearable (serie pret a portet): Arduino GEMMA, LILYPAD, LILYPAD SIMPLE, LILYPAD USB.

Y de forma gráfica esto es un Arduino:

Figura 1. Placa Arduino UNO.

Sergio RomeroIngeniero en Automática y Electrónica Industrial

Figura 2. Placa Arduino MEGA.

Y aunque parezca mentira, esto también es un Arduino:

Figura 3.- PLC Ethernet MDuino de Industrial Shields con 58 E/S y un coste de 320,00€.


En la última imagen ya podemos apreciar que no es una plataforma “de juguete”. De hecho los

dispositivos de Industrial Shields cumplen con los requisitos que se esperan de un dispositivo de

desempeño industrial.

¿Qué se puede hacer con Arduino?

Con una placa de Arduino se pueden leer entradas: estado de un sensor, la pulsación de un botón o

un mensaje de Twitter y activar una salida: arrancar un motor, encender un LED, publicar algo online.

Todo se define mediante un conjunto de instrucciones programadas a través del IDE Arduino.

Figura 4.- Aplicación de Arduino a CNC. Control de 3 ejes.

Figura 5.- Máquina CNC de 3 Ejes Controlada con Arduino.


Figura 6. Maqueta de casa domótica Arduino-based controlada a través del móvil.

Básicamente se puede realizar cualquier aplicación de control que se puedan realizar con equipos

comerciales mucho más costosos y generalmente con las mismas prestaciones y sin depender de un

fabricante en concreto. Como comentamos las placas son Open Hardware y se venden clones incluso

a menor precio, ya de por si económico.

Hablamos que una placa MEGA ronda un coste de 10 euros y con ella podemos controlar hasta 54

Entradas/Salidas Digitales y además dispone de 16 entradas analógicas.

Si además consideramos la llegada de compañías como Industrial Shields que han adaptado y

acomodado este tipo de producto a un entorno industrial, podemos comprobar como la electrónica de

control tradicional tiene un serie competidor.

¿Como se programa un Arduino?

Las placas Arduino se programan mediante su propio IDE que es open source y que se puede

descargar compilado para los sistemas operativos más populares: Windows, Linux y Max OS X.

Actualmente va por la versión ARDUINO 1.6.5. El software Arduino IDE se encarga de compilar y subir

el programa a la placa, normalmente mediante un cable USB.

El Entorno de Desarrollo Integrado (IDE) contiene un editor de código, un área de mensajes, una

consola de texto una barra de herramientas con botones para las funciones más frecuentes y una serie

de menús. El software se conecta con el hardware Arduino y Genuino para subir los programas y

comunicarse con ellos.


Figura 7. Entorno Arduino IDE.

Además Arduino cuenta con una alta conectividad, siendo posible conectar la placa a entornos

como LabView, Matlab, Scilab u Octave. Inlcuso el SCADA comercial Indusoft Web Studio de

Schneider Electric disponde de drivers y conexión con estas placas controladoras por lo que

desarrollar software de supervisión tanto con soluciones open source como con software propietario

resulta altamente accesible.

Contras de Arduino.

Al igual que sucedió en décadas anteriores, las transiciones llevan su tiempo. Los primeros

armarios de control estaban formados por enormes cantidad de relés discretos. Con la entrada de los

primeros controladores se desarrolló de forma paralela entornos para los profesionales electrotécnicos

con lenguajes parecidos a lo que ellos conocía. Surgió así por ejemplo el Ladder y los lenguajes de la

IEC 61131-3.

Estos profesionales actualmente están altamente habituados a trabajar con estos entornos en los

que son productivos y en los que se sienten cómodos. Como en todas las transiciones existe una curva

de aprendizaje que es necesario subir para poder ser productivo en estas plataformas, el tiempo es

dinero.

No obstante esto está cambiando y ya se están desarrollando entornos similares los de los “PLCs

tradicionales” que van a facilitar la transición.

Con Arduino se pueden realizar aplicaciones de control extremadamente complejas (tanto como

con cualquier PLC). No obstante su formato de presentación “prototipo” hace que sea vista por muchos

como una plataforma “de juguete” y no es así. No obstante ya se están viendo productos Arduino-


Based con un desempeño industrial y un aspecto más pulido, como los Autómatas Programables de

Industrial Shields.

Fundamentos de la programación de Arduino.

En los siguientes apartados de este tutorial vamos a realizar una pequeña introducción a la

programación de un Arduino y daremos explicaciones de algunos de los elementos del hardware y

software Arduino así como algunos de los conceptos que hay tras ellos. Lo esencial de estas

secciones se ha sacado de la página oficial http://www.arduino.cc. Esto será lo que veremos:

Lo esencial

- Boceto: Que es un boceto, los diferentes componentes de un boceto y como trabajan.

Microcontroladores

• Pines de entrada: como trabajan los pines y que implica configurarlos como entradas o como

salidas.

• Pines de Entrada Analógica: Detalles sobre la conversión analógica a digital y otros usos de los

pines.

• PWM: Como la función analogWrite()simula una salida analógica usando la modulación por

anchura de pulso.

• Memoria: Los distintos tipos de memoria disponibles en una placa Arduino.

Técnica de Programación

• Variables: Como definir y usar variables.

• Funciones: Como definir y usar funciones.

• Librerías: Como escribir tu propia librería.

Circuitos

• Arduino en una placa de prototipos: Usaremos el microcontrolador desde un Ardunio en una

placa de prototipos (cualquiera de las disponibles).

Primer Boceto.

En este tutorial aprenderás como trabaja cada parte de un boceto. Para ello crearemos un boceto

que hará parpadear un led. El hardware que necesitaremos será algo tal que así:

Comencemos definiendo que es un boceto (sketch):


http://www.arduino.cc/

Figuras 7 y 8. El hardware para el boceto parpadeo.

Boceto.

Un boceto es el nombre que Arduino utiliza para referirse a un programa, es la unidad de código

que se sube y se ejecuta en una placa Arduino.

Comentarios.

Las primeras líneas del boceto Parpadeo que vamos a crear serán un comentario:

/** Parpadeo** El ejemplo básico de Arduino. Enciende un LED durante un segundo,* luego lo apaga durante un segundo, y vuelta a empezar...* Usamos el pin 13 ya que, * dependiendo de tu placa Arduino,* este tiene incorporado o bien un LED o bien una resistencia* con lo que solo necesitarías un LED extra.** http://www.arduino.cc/en/Tutorial/Blink*/

Todo lo que hay entre el /* y el */ es ignorado por Arduino cuando ejecuta el boceto (el * al

comienzo de cada línea es solo para hacer al comentario algo más estético y no es necesario). Los

comentarios son útiles para la gente que lee el código: explica que hace el programa, como trabaja o

por que está escrito de esa forma. Es muy recomendable comentar los bocetos y mantener los

comentarios actualizados cuando modificas el código. Esto ayuda al resto de la gente a aprender a

partir de el o a modificar tu código.

Hay otro estilo para comentarios cortos de una sola línea. Estos empiezan con // y continúan

hasta el final de la línea. Por ejemplo, en la línea:


http://www.arduino.cc/en/Tutorial/Blink

int ledPin = 13; // LED conectado al pin digital 13

el mensaje “LED conectado al pin digital 13” es un comentario.

Variables.

Una variables es un lugar donde almacenar un dato y tiene un nombre, un tipo y un valor. Por

ejemplo, la línea anterior del boceto Parpadeo declara una variable con el nombre ledPin, el tipo int

y el valor inicial de 13. Esta variable se utiliza para indicar en que pin de Arduino está conectado el

LED. Cada vez que el nombre ledPin aparezca en el código se recupera suvalor. En este caso

podríamos haber elegido no crear la variable ledPin y en su lugar simplemente escribir el número 13

en todos los sitios en que sea necesario indicar el número de patilla. La ventaja de usar variables es

que es más fácil mover el LED a una patilla diferente: solo necesitas editar la única línea que asigna el

valor inicial a la variable.

Sin embargo,habitualmente el valor de una variable cambiará durante la ejecución del boceto. Por

ejemplo, podrías almacenar el valor leído en una entrada en una variable.

Funciones.

Una función (también conocida como procedimiento o subrutina) es el nombre de un fragmento de

código que se puede usar desde cualquier parte de un boceto. Por ejemplo, aquí está la definición de

la función setup() del ejemplo Parpadeo:

void setup()

{

pinMode(ledPin, OUTPUT);

// Configura una patilla como salida

}

La primera línea proporciona información sobre la función, como su nombre: “setup”. El texto antes

y después del nombre indican el tipo devuelto y sus parámetros: esto se explicará más tarde. El código

entre { y } se llama cuerpo de la función: lo que la función hace.

Puedes llamar a una función que ya haya sido definida (tanto definida dentro de tu boceto como si

forma parte del lenguaje Arduino). Por ejemplo, la línea pinMode(ledPin, OUTPUT); llama a la

función pinMode(), y le pasa dos parámetros: ledPin y OUTPUT. Esto parámetros son utilizados por

la función pinMode() para decidir que pin y que modo configurar.

pinMode(), digitalWrite() y delay()

La función pinMode()configura un pin, bien como entrada o bien como salida. Para usarla hay que

pasarle el número de pin a configurar y la constante INPUT o OUTPUT. Cuando se configura como una


entrada el pin puede detectar el estado de un sensor como por ejemplo un pulsador; esto se verá algo

más tarde. Como salida puede accionar un actuador como por ejemplo, un led.

La función digitalWrite() escribe un valor en una patilla. Por ejemplo, la línea:

digitalWrite(ledPin, HIGH);

configura el ledPin (pin 13) a HIGH, o 5 Voltios. Escribir LOW en un pin lo pone a tierra, es decir 0

Voltios.

La función delay() provoca que Arduino espere durante un número determinado de milisegundos

antes de continuar con la siguiente línea de código. Hay 1.000 milisegundos en un segundo, por lo

que:

delay(1000);

provoca un retardo de un segundo.

setup() y loop()

Hay dos funciones especiales que son parte de cualquier boceto Arduino: setup() y loop(). La

función setup() se llama una sola vez, cuando se inicia el boceto. Es un buen sitio para hacer tareas

de configuración como establecer los modos de los pines o para inicializar librerías. La función loop()

se llama una y otra vez y es el corazón de la mayoría de los bocetos (los programadores de autómatas

tradicionales estarán familiarizados con este bucle) Necesitas incluir ambas funciones en tu boceto,

incluso si no las necesitas para nada.

El código para el programa de ejemplo tendrá este aspecto:

/* * Parpadeo * Activa un LED un segundo, lo apaga otro segundo y vuelta a empezar. * Este ejemplo es de dominio público. */

// El Pin 13 tiene un led conectado en la mayoría de las placas Arduino.int led = 13;

// la rutina setup se ejecuta solo una vez después pulsar resetvoid setup(){ // Inicializa el pin digital como entrada. pinMode(led, OUTPUT);}

// la rutina loop se ejecuta una y otra vezvoid loop(){ digitalWrite(led, HIGH); // enciende el LED (HIGH es +5V). delay(1000); // espera un segundo. digitalWrite(led, LOW); // apaga el led (LOW es 0V). delay(1000); //espera un segundo.}


Propuesta para esta sección.

Te propongo que pruebes a hacer esto:

1. Cambiar el código de forma que el LED esté encendido 100 ms y apagado 1000 ms.

2. Cambiar el código de forma que el LED se encienda cuando el boceto se inicie y permanezca

encendido.

Hemos visto hasta ahora:

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

Microcontroladores.

Vamos a hacer un pequeño repaso al corazón de Arduino: el microcontrolador.

Patillas digitales.

Las patillas o pines en Arduino se puede configurar como entradas o como salidas. Vamos a

explicar el funcionamiento de las patillas en esos modos. Aunque el título de la sección se refiere a las

patillas digitales es importante señalar que la amplia mayoría de las patillas analógicas de Arduino

(Atmega), se pueden configurar y usar exactamente de la misma manera que las patillas digitales.

Propiedades de los pines configurados como INPUT (entrada).

Los pines del Arduino (Atmega) son por defecto entradas, así que no es necesario declararlos

explícitamente con la función pinMode() si se usan como entradas. Los pines configurados como

entradas están en un estado de alta impedancia. Las entradas tienen una demanda de corriente

extremadamente baja sobre el circuito en el que están insertadas, equivalente a una resistencia en

serie de 100 MΩ al frente del pin. Esto significa que se necesita una intensidad muy pequeña para

llevar un pin de un estado a otro, lo que es muy útil para tareas como la implementación de un sensor

táctil capacitivo, la lectura de un LED o fotodiodo, o la lectura de un sensor analógico con un esquema

como el del RCTime.

Esto implica también que los pines configurados como pinMode(pin, INPUT) que no estén

conectados a nada (al aire) puedan reportar aparentemente cambios aleatorios en el estado del pin,

recogiendo el ruido del entorno o acoplando capacitivamente el estado de un pin cercano. Para evitar

esto se pueden usar resistencias pull-up (elevadoras).

Resistencia pull-up con los pines configurados como INPUT.

A menudo es útil llevar un pin de entrada a un estado conocido si no hay presente un entrada. Esto


se puede realizar añadiendo una resistencia elevadora o de pull-up (a +5V) o una resistencia

resistencia a tierra o pull-down en la entrada. Una resistencia de 10kΩ es un buen valor para una

resistencia pull-up o pull-down.

Propiedades de los pines configurados como INPUT_PULLUP.

Hay resistencias pull-up de 20KΩ incorporadas en el chip Atmega a las que se accede por software.

A estas resistencias pull-up incorporadas se accede configurado el pin con la función pinMode() y el

parámetro INPUT_PULLUP. Esto, sin embargo, invierte el comportamiento del modo INPUT, donde

HIGH significa que el sensor está apagado y LOW significa que el sensor está activado.

El valor de la resistencia de pull-up depende del microcontrolador utilizado. En la mayoría de las

placas Arduino basadas en AVR se garantiza un valor comprendido entre 20kΩ y 50 kΩ. En el Arduino

Due, está entre 50 kΩ y 150 kΩ. Para conocer el valor exacto hay que consultar las hojas de datos del

microcontrolador de tu placa.

Cuando se conecta un sensor a un pin configurado como INPUT_PULLUP, el otro extremo debe

conectarse a tierra. En el caso de un simple interruptor esto provoca que se lea en el pin HIGH cuando

el interruptor está abierto y LOW cuando se pulsa el interruptor (se invierten sus valores).

La resistencia pull-up proporciona suficiente corriente para iluminar débilmente un LED conectado

al pin que ha sido configurado como entrada.

Las resistencias elevadoras se controlan con los mismos registros (posiciones internas del chip de

memoria) que controlan si el pin está HIGH o LOW. Por tanto un pin que se configura para tener

resistencias pull-up activas cuando la patilla es una INPUT, tendrá el pin configurado como HIGH si el

pin se convierte en una OUTPUT con la función pinMode().

Antes de Arduino 1.0.1 erá posible configurar las resistencias elevadoras de la siguiente manera:

pinMode(pin, INPUT);

// configura el pin como entrada

digitalWrite(pin, HIGH); // activa las resistencia elevadoras.

NOTA: El pin 13 es más difícil de usar como entrada digital que el resto de pines ya que tiene un

LED y/o una resistencia asociada que están soldados a la placa en la mayoría de los modelos. Si

habilitas su resistencia elevadora interna de 20kΩ, desde fuera veremos alrededor de 1.7V en lugar de

los 5V esperados ya que el LED y la resistencia serie hacen que baje el nivel de voltaje, implicando

que siempre devuelva LOW. Si quieres usar el pin 13 como una entrada digital, configura su modo con

pinMode() a INPUT y utiliza una resistencia pull-down externa.

Propiedades de los pines configurados como OUTPUT.

Los pines configurados como OUTPUT con la función pinMode() se dice que están en un estado de

baja impedancia. Esto implica que pueden proporcionar una cantidad sustancial de intensidad a otros

circuitos. Los pines del Atmega puede suministrar (intensidades positivas) o absorber (intensidades

negativas) hasta 40 mA (miliamperios) de intensidad a/de otros dispositivos o circuitos. Esta es una


corriente suficiente para iluminar un LED (no olvides la resistencia en serie) o para activar muchos

sensores, pero insuficiente para activar la mayoría de los relés, solenoides o motores.

Los cortocircuitos en los pines de Arduino o el intento de obtener altas intensidades de él puede

dañar o destruir el transistor de salida del pin o incluso dañar el chip Atmega por completo. A menudo

estos fallos convierte la patilla en un pin “muerto” del microcontrolador, pero el resto del chip seguirá

funcionando adecuadamente. Por este motivo es una buena idea conectar los pines OUTPUT a otros

dispositivos con resistencias de 470Ω o 1kΩ, a menos que se necesite obtener la máxima corriente

posible del pin para una aplicación en particular.

Pines de entradas analógicas.

Vamos a dar ahora una breve descripción de los pines de entrada analógica de los chips que

incluyen las placas Arduino (Atmega8, Atmega168, Atmega328 o Atmega1280).

Conversor Analógico / Digital.

El micro Atmega utilizado en las placas Arduino contiene un conversor analógico-digital (A/D) de 6

canales. El conversor tiene una resolución de 10 bits y devuelve enteros comprendidos entre 0 y 1023.

Aunque la función principal del los pines para la mayoría de los usuarios de Arduino será la de leer

sensores analógicos, estos pines analógicos también puede tener la funcionalidad general de los pines

de entrada/salida (GPIO) (la misma que los pines digitales 0 – 13).

Por tanto, si un usuario necesita más pines de entrada salida generales y ninguno de los pines

analógicos se utilizan, se pueden utilizar como GPIO.

Mapeo de pin.

Los pines analógicos se pueden usar de forma idéntica a los pines digitales, usando alias A0 (para

la entrada analógica 0), A1, etc. Por ejemplo, el código para configurar el pin analógico 0 como salida y

asignarle el valor HIGH se parece a esto:

pinMode(A0, OUTPUT);

digitalWrite(A0, HIGH);

Resistencias Pull-Up.

Los pines analógicos también tienen resistencias elevadoras, que trabajan de forma idéntica a las

resistencias elevadoras de los pines digitales. Estas se habilitan usando un comando como:

digitalWrite(A0, HIGH); // activa la resistencia elevadora del pin 0

cuando el pin es una entrada.

Ten cuidado de todos modos ya que activar una resistencia elevadora puede afectar a los valores

reportados por analogRead().

Detalles y advertencias.

El comando analogRead no trabajará de forma correcta si el pin ha sido previamente configurado


como salida, por lo que si es este el caso, vuelve a configurarlo como entrada antes de usar

analogRead. De forma similar si el pin ha sido configurado a HIGH como un salida, la resistencia

elevadora estará activa cuando se cambia de nuevo a una entrada.

La hoja de datos de Atmega también advierte contra el cambio de pines analógicos en

proximidades temporales a realizar una lectura A/D (analogRead) en otros pines analógicos. Esto

puede provocar ruido eléctrico e introducir irregularidades en el sistema analógico. Puede ser

deseable, después de manipular pines analógicos (en modo digital), añadir un corto retardo antes de

usar analogRead() para leer otros pines analógicos.

PWM.

El Software Arduino IDE contiene un ejemplo denominado “Desvanecer” que muestra el uso de una

salida analógica (PWM) para desvanecer un LED. Está disponible en el menú File → Sketchbook →

Examples → Analog del software Arduino.

La modulación por anchura de pulso, o PWM, es una técnica para obtener resultados analógicos

con medios digitales. El control digital se utiliza para crear una onda cuadrada, una señal conmutada

entre activo e inactivo. Este patrón on-off puede simular tensiones en el rango completo desde ON (5

Voltios) a OFF (0 Voltios) cambiando la parte del tiempo que la señal permanece a on contra el tiempo

de la señal que permanece a off. La duración del intervalo que la señal está a ON se llama ancho del

pulso. Para obtener valores analógicos variables, puedes cambiar o modular, ese ancho del pulso. Si

repites este patrón on-off lo suficientemente rápido con un LED por ejemplo, el resultado es como si la

señal permaneciera en una tensión comprendida entre 0V y 5V controlando el brillo del LED.

En el gráfico anterior las lineas verdes representan un período de tiempo regular. Su duración o

período es la inversa de la frecuencia del PWM. En otras palabras, con la frecuencia PWM de Arduino

sobre 500Hz, las lineas verdes podrían medir 2ms cada una. Una llamada a analogWrite() está

sobre la escala de 0 a 255, de forma que analogWrite(255) es el 100% del ciclo de trabajo (siempre


ON) y analogWrite(127) es un 50% del ciclo de trabajo (la mitad del tiempo) por ejemplo.

Memoria.

Las notas de este apartado son para todas las placas excepto para la DUE, que tiene una

arquitectura diferente.

Hay tres tipos de memorias en los microcontroladores utilizados por las placas Arduino basadas en

AVR:

• Memoria Flash (espacio de programa) que es donde el boceto Arduino se guarda.

• SRAM (Memoria de acceso aleatorio estática) que es donde el sketch crea y manipula las

variables cuando se ejecuta.

• EEPROM es una espacio de memoria que los programadores pueden usar para guardar

información a largo plazo.

La memoria Flash y la memoria EEPROM son memorias no volátiles (la información persiste

después de que se apague la alimentación). La SRAM es volátil y perderá su contenido cuando se

apague y se vuelva a encender.

El chip ATmega328 que se encuentra en la placa Uno tiene las siguientes cantidades de memoria:

• Flash: 32 kbytes (de los cuales 5k se utilizan por el cargador de arranque).

• SRAM: 2kbytes

• EEPROM: 1kbyte

El ATmega2560 en la placa Mega2560 tiene un espacio de direcciones mayor:

• Flash: 256 kbytes (de los cuales 8 se utilizan por el cargador de arranque).

• SRAM: 8 kbytes

• EEPROM: 4kbytes.

Nota que no hay mucha SRAM disponible en UNO. Es fácil usarla toda si tienes muchas cadenas

de texto en tu programa. Por ejemplo, una declaración como:

char message[] = “Yo apoyo el proyecto eólico del Cabo.”;

mete 38 bytes en la SRAM (cada uno de los caracteres ocupa un byte, más el terminador '\0') Esto

puede no parecer mucho, pero no se tarda mucho en alcanzar 2048, especialmente si tienes una gran

cantidad de texto que enviar al display, o una tabla de búsqueda grande, por ejemplo.

Si estás ejecutando fuera del espacio de la SRAM tu programa podría fallar de una forma

inesperada; parecerá que se ha subido con éxito, pero no correrá, o correrá de forma extraña. Para

comprobar si esto está pasando, puedes intentar comentar, acortar las cadenas de texto o otras

estructuras de datos en tu boceto (sin cambiar el código). Si se sigue ejecutando correctamente


probablemente estás corriendo fuera de la SRAM. Hay algunas cosas que puedes hacer para

reconducir este problema:

- Si tu boceto se comunica con un programa que se ejecuta en computador (de escritorio o portátil)

podrías intentar mover los datos o cálculos al computador reduciendo la carga del Arduino.

- Si tienes tablas de búsqueda u otros arrays grandes, utiliza el tipo de dato más pequeño

imprescindible para almacenar los valores que necesitas; por ejemplo un int ocupa hasta 2 bytes

mientras un byte usa solo uno (pero puede almacenar datos en un rango más pequeño).

- Si no necesitas modificar las cadenas o datos cuando tu boceto se está ejecutando puedes

guardarlas en la memoria flash (programa) en lugar de la SRAM; para hacer eso utiliza la palabra

reservada PROGMEM.

Para usar la EEPROM consulta la Librería EEPROM de la referencia de Arduino.

TÉCNICA DE PROGRAMACIÓN.

Ahora que tenemos una visión reducida pero más o menos general, vamos a profundizar un poco

en la técnica de programación de las placas Arduino. Vamos introducir con algo más de detalles las

Variables, las Funciones y las Librerías.

Variables.

Una variable es un lugar para almacenar un dato. Tiene un nombre, un valor y un tipo. Por ejemplo,

esta sentencia (llamada declaración):

int pin = 13;

crea una variable cuyo nombre es pin, con un valor de 13 y con el tipo int (entero).

Posteriormente en el programa puedes hacer referencia a esta variable por su nombre, con lo que se

consultará su valor y se utilizará. Por ejemplo, en esta sentencia:

pinMode(pin, OUTPUT);

será el valor del pin (13) el que se pasará a la función pinMode(). En este caso, no necesitarías

usar una variable, esta sentencia podría hacer exactamente lo mismo:

pinMode(13, OUTPUT);

La ventana de una variable en este caso es que solo necesitas especificar el número del pin una

vez, pero usarlo montones de veces. Si posteriormente decides cambiar el pin del 13 al 12, solo

necesitas cambiar un solo lugar en el código. Además, puedes usar un nombre descriptivo para darle

un significado más claro a la variable (por ejemplo, el programa que controla un LED RGB podría tener

variables llamadas redPin, greenPin y bluePin.

Una variable tiene otras ventajas sobre un valor numérico. La más importante: puedes cambiar el

valor de la variable usando una asignación (que se indica mediante el signo igual). Por ejemplo:


pin = 12;

cambiará el valor de la variable a 12. Nota que no especificamos el tipo de la variable: el tipo no se

cambia con la asignación. Esto es, el nombre de la variable permanece asociado con un tipo; solo

cambia su valor.

En Arduino tienes que declarar obligatoriamente una variable antes de asignarle un valor. Si

incluyes la anterior sentencia en un programa, obtendrás un mensaje como: “error, el pin no ha sido

declarado en este ámbito”.

Cuando asignas una variable a otra, estás haciendo una copia de su valor y lo estás guardando en

la posición de memoria asociada con la otra variable. Cambiar una no tiene efectos sobre la otra. Por

ejemplo, después de:

int pin = 13;int pin2 = pin;pin = 12;

solo la variable pin contendrá el valor 12, pin2 seguirá conteniendo 13.

Puede haberte sorprendido leer la palabra “ámbito” en el mensaje de error anterior. ¿Qué significa?.

Pues se refiera a la parte del programa en la que una variable se puede usar. El ámbito está

determinado por el lugar en el que declaras la variable. Por ejemplo, si quieres utilizar una variable en

cualquier lugar de tu programa, tienes que declararla al inicio de tu código, fuera de cualquier función.

Estas se llaman variables globales, aquí hay un ejemplo:

int pin = 13;

void setup(){ pinMode(pin, OUTPUT);}

void loop(){ digitalWrite(pin, HIGH);}

Como puedes ver, pin se utiliza tanto dentro de la función setup() como dentro de la función

loop(). Ambas funciones se refieren a la misma variable, por lo que cambiarla desde una de ellas

afectará al valor en la otra, así:

int pin = 13;

void setup(){ pin = 12; pinMode(pin, OUTPUT);}

void loop(){ digitalWrite(pin, HIGH);}


Aquí a la función digitalWrite() llamada desde loop() se le pasará el valor 12 es decir, el valor

asignado a la variable dentro de la función setup().

Si solo quieres usar una variable dentro de una función, puedes declararla dentro de ella. En este

caso el ámbito se limitará a la función. Por ejemplo:

void setup(){ int pin = 13; pinMode(pin, OUTPUT); digitalWrite(pin, HIGH);}

En este caso, la variable pin solo se puede usar dentro de la función setup(). Si intentar hacer

algo como esto:

void loop(){ digitalWrite(pin, LOW); // Error: el pin no está en este ámbito.}

obtendrás un mensaje como el anterior: “error, “pin” no ha sido declarada en este ámbito”.

Es decir, aunque hayas declarado una variable pin en algún lugar del programa, estás intentado

usarlo en alguna parte fuera de su ámbito.

¿Porqué debería sorprenderte que no es buena idea hacer todas tus variables globales?. Después

de todo, si no sabes donde podrías necesitar una variable, ¿porqué limitar su ámbito a solo una

función?. La respuesta puede ser más fácil si se explica que es lo que pasaría si no fuera así. Si una

variable es global y se puede cambiar su valor desde cualquier parte del código, esto implica que

necesitarás comprender el programa completo para saber que pasará con la variable. Por ejemplo, si

tu variable tiene un valor que no esperas, puede resultar mucho más fácil saber la causa cuando el

ámbito de tu variable está limitado.

[1] En algunos lenguajes, como Python, los tipos están asociados a los valores, no a los nombres

de las variables y puedes asignar valores de cualquier tipo a una variable. Esto se referencia como

tipado dinámico.

Funciones.

La división o fragmentación del código en funciones permite al programador crear piezas de código

modulares que realicen un determinada tarea y a continuación volver al área de código desde la que la

función “se llamó”. El caso típico para crear una función es cuando necesitamos realizar la misma

acción muchas veces en un programa.

Para los programadores acostumbrados a usar BASIC, las funciones en Arduino proporcionan (y

extiende) la utilidad de usar subrutinas (GOSUB en Basic).

Los fragmentos de código estandarizados en funciones tienen algunas ventajas:


• Las funciones ayudan al programador a permanecer organizado. A menudo esto ayuda a

conceptualizar el programa.

• Las funciones codifican una acción en un lugar por lo que las funciones solo han de ser

escritas en un sitio y depuradas una vez.

• Se reduce las opciones de error en las modificaciones en el caso de que el código tenga que

cambiarse.

• Las funciones hacen al boceto en conjunto más pequeño y más compacto ya que las secciones

de código se reutilizan muchas veces.

• Hacen más fácil reutilizar código en otros programas haciéndolo más modular, y tiene un efecto

colateral, el uso de funciones también hace al código más legible.

Hay dos funciones obligatorias en un boceto Arduino, setup() y loop(). El resto de funciones

deben crearse fuera de los corchetes de estas dos funciones obligatorias. Como en el ejemplo,

crearemos un función simple para multiplicar dos números.

Ejemplo

int miFuncionMultiplica(int x, int y){ int result; result = x * y; return result;}

El tipo de dato devuelto es cualquier tipo de C, en este caso se devuelve un int (“void” si no se

devuelve nada). El nombre de la función es miFuncionMultiplica, los parámetros de entrada son

dos enteros x e y (los parámetros pasados a la función pueden ser cualquier tipo de C). En la

sentencia return el tipo de datos se tiene que ajustar a la declaración (tipo entero).

Para “llamar” a esta función tan simple pasamos los parámetros del tipo de datos que se espera:

void loop(){ int i = 2; int j = 3; int k; k = miFuncionMultiplica(i, j); // k contendrá 6}

Nuestra función necesita ser declarada fuera de cualquier otra función, de forma que“miFuncionMultiplica()” puede tanto estar antes o después de la función “loop()”.

El boceto completo podría tener el siguiente aspecto:

void setup(){ Serial.begin(9600);}void loop(){ int i = 2; int j = 3; int k;


k = miFuncionMultiplica(i , j); // k contendrá 6 Serial.println(k); delay(500);}int miFuncionMultiplica(int x, int y){ int result; result = x * y; return result;}

Otro ejemplo.

Esta función leerá un sensor cinco veces con la función analogRead() y calculará la media de las

lecturas. A continuación escalará el dato a 8 bits (0 a 255) y lo invertirá, devolviendo el valor invertido

como resultado.

int LeeSensor_E_Invierte(){ int i; int sval = 0; for (i = 0; i < 5; i++){ sval = sval + analogRead(0); // el sensor está en el pin analógico 0 } sval = sval / 5; // media sval = sval / 4; // escala a 8 bits (0 a 255) sval = 255 – sval; // invierte la salida return sval;}

Para llamar a la función solo necesitamos asignarla a una variable.

int sens;

sens = LeeSensor_E_Invierte();

Escribiendo una librería para Arduino.

Este apartado explicará como crear una librería para Arduino. Comenzaremos con un boceto para

transmitir código Morse y explicaremos como convertir sus funciones en una librería. Esto permitirá a

otros usar fácilmente el código que hemos escrito y actualizarlo si mejoras la librería.

Para más información, ver la Guía de estilo de la API de Arduino que contiene información sobre

como hacer una buena API al estilo Arduino para tu librería.

Comenzamos con un boceto que hace un código Morse sencillo:

int pin = 13;voi setup(){

pinMode(pin, OUTPUT);}void loop(){

dot(); dot(); dot();dash(); dash(); dash();dot(); dot(); dot();delay(3000);

}


void dot(){

digitalWrite(pin, HIGH);delay(250);digitalWrite(pin, LOW);delay(250);

}void dash(){

digitalWrite(pin, HIGH);delay(1000);digitalWrite(pin, LOW);delay(250);

}

Si ejecutas este boceto, mostrará el código para el SOS (una llamada de socorro) en el pin 13.

El boceto tiene distintas partes que necesitariamos añadir a nuestra librería. Primero tenemos las

funciones dot() y dash() que hacen el parpadeo actual. Segundo, tenemos la variable ledPin que

las funciones usan para determina que pin tienen que utilizar. Finalmente, está la llamada a

pinMode() que inicializa el pin como salida.

Vamos a empezar a convertir un boceto en una librería.

Necesitas al menos dos archivos para una librería: un archivo de cabecera (con la extensión .h) y

un archivo fuente (con la extensión .cpp). El archivo de cabecera contiene la definición de la librería:

básicamente una lista de todo lo que hay dentro; mientras que el archivo fuente tiene el código actual.

Llamaremos a nuestra librería “Morse” de forma que su archivo de cabecera será Morse.h. Vamos a

echar un vistazo a que hacer dentro de él. Puede parecer algo extraño al principio, pero cobrará más

sentido una vez que veas lo que hay dentro del archivo fuente.

El núcleo de un archivo de cabecera consta de una línea para cada función de la librería, envuelta

en una clase junto con todas las variables que necesitas:

class Morse{

public:Morse(int pin);void dot();void dash();

private:int _pin;

}

Una clase es simplemente una colección de funciones y variables que se mantienen juntas en

algún lugar. Estas funciones y variables pueden ser públicas, con lo que cualquiera que use la librería

puede acceder a ellas, o privadas, implicando que solo se puede acceder a ellas desde dentro de la

propia clase. Cada clase tiene una función especial conocida como constructor que se utiliza para

crear las instancias de la clase. El constructor tiene el mismo nombre que la clase y no devuelve

ningún tipo.

Necesitas un par de cosas más en el archivo de cabecera. Una es la sentencia #include que te de


acceso a los tipos estándar y constantes del lenguaje Arduino (se añade de forma automática en los

bocetos normales, pero no a las librerías). Se parece a esto (y viene antes de la definición de clase

dada anteriormente):

#include “Arduino.h”

Finalmente es habitual para envolver el archivo de cabecera dentro de una construcción con un

aspecto algo extraño:

#ifndef Morse_h#define Morse_h // la sentencia #include y el código irán aquí#endif

Básicamente esto previene problemas si alguien de forma accidental #include dos veces tu

librería.

Finalmente, normalmente colocarás comentarios al inicio de la librería con el mismo nombre, una

breve descripción de que hace, quién la escrito y la licencia.

Vamos a echar un vistazo al archivo de cabecera completo:

/*Morse.h – Librería para transmitir código Morse.Creada por Sergio romero, 8 de Agosto de 2015.Liberada al dominio público.

*/#ifndef Morse_h#define Morse_h#include “Arduino.h”class Morse{

public:Morse(int pin);void dot();void dash();

private:int _pin;

};

Ahora vamos con las distintas partes del archivo fuente. Morse.cpp.

La primera son un par de sentencias #include. Estas dan acceso al resto del código a las funciones

estándar de Arduino y a las definiciones de tu archivo de cabecera.

#include “Arduino.h”#include “Morse.h”

A continuación viene el constructor. De nuevo, este explica lo que podría pasar cuando alguien crea

una instancia de tu clase. En este caso, el usuario especifica que pin quiere usar. Configuramos el pin

como salida y lo salvamos dentro de una variable privada para el uso en otras funciones:


Morse::Morse(int pin){

pinMode(pin, OUTPUT);_pin = pin;

}

Hay un par de cosas raras en este código. La primera es el Morse:: antes del nombre de la

función. Esto indica que la función es parte de la clase Morse. Verás esto continuamente en el resto de

funciones de la clase. La segunda cosa inusual es el carácter de subrayado en el nombre de nuestra

variable privada _pin. La variable puede tener cualquier nombre que quieras, siempre que se ajuste a

la definición en el archivo de cabecera. Añadir un carácter de subrayado al inicio del nombre es una

convención habitual para identificar más fácilmente que variables son privadas y también para

distinguir el nombre de lo que es el argumento de la función (pin en este caso).

Lo siguiente procede del código del boceto que estás intentando convertir en una librería

(finalmente). Será más o menos igual con la excepción de Morse:: al inicio de los nombre de función, y

el uso de _pin en lugar de pin:

void Morse:: dot(){

digitalWrite(_pin, HIGH);delay(250);digitalWrite(_pin, LOW);delay(250);

}

void Morse::dash(){


}

Y finalmente, es típico incluir un comentario como encabezado al inicio del archivo fuente. Así se

vería todo:

/* Morse.cpp - Library for flashing Morse code. Created by David A. Mellis, November 2, 2007. Released into the public domain.*/

#include "Arduino.h"#include "Morse.h"

Morse::Morse(int pin){

pinMode(pin, OUTPUT);_pin = pin;

}

void Morse::dot(){



}

void Morse::dash(){


}

Y eso es todo lo que necesitas (hay otra serie de cosas opcionales, pero se tratarán más tarde).

Ahora veremos como usar la librería.

Primero, crea un directorio Morse dentro del subdirectorio libraries de tu directorio de bocetos.

Copia o mueve los archivos Morse.h y Morse.cpp al directorio. Ahora lanza el entorno Arduino. Si abres

el menú Boceto → Importar Librería, deberías ver Morse dentro. La librería será compilada con los

bocetos para usarla. Si la librería no parece construirse, asegúrate de que los archivos realmente

terminan en .cpp y en .h (sin extensiones extra .pde o .txt, por ejemplo)

Vamos a ver como podemos reescribir nuestro antiguo boceto SOS usando la nueva librería:

#include <Morse.h>void setup(){}void loop(){

morse.dot(); morse.dot(); morse.dot();morse.dash(); morse.dash(); morse.dash();morse.dot(); morse.dot(); morse.dot();delay(3000);

}

Hay algunas diferencias con el antiguo boceto (además del hecho que parte del código se ha

movido a una librería).

Lo primero, hemos añadido una sentencia #include al inicio del boceto. Esto hace que la librería

Morse esté disponible al boceto y la incluya en el código enviado a la placa. Esto implica que si ya no

necesitas más una librería en boceto puedes borrar la sentencia #include para salvar espacio.

Lo segundo, podemos crear una instancia de la clase Morse llamada morse:

Morse morse(13);

Cuando se ejecuta esta línea (lo que pasa incluso antes de la función setup() se llama al

constructor de la clase Morse y se le pasa el argumento (en este caso, el 13).

Nota que ahora nuestra setup() está vacío; esto es porque la llamada a pinMode() se hace


desde dentro de la librería (cuando se construye la instancia).

Finalmente para llamar a las funciones dot() y dash() necesitamos añadir el prefijo morse.

Podríamos tener múltiples instancias de una clase Morse, cada una con su propio pin almacenado

en la variable privada _pin de dicha instancia. Llamando a una función de una instancia en particular

especificamos que variables de instancia tenemos que usar durante la llamada a la función. Esto es,

podemos hacer tanto:

Morse morse(13);

Morse morse2(13);

Si has iniciado un nuevo boceto habrás notado que nada de nuestra librería ha sido reconocido por

el entorno Arduino ni está resaltado en color. Desafortunadamente el software Arduino no puede

todavía descifrar automáticamente lo que se ha definido en nuestra librería (aunque sería una buena

característica que debería tener) así que tenemos que darle algo de ayuda. Para hacer esto, crea un

archivo llamado keywords.txt en el directorio Morse. Se verá de esta forma:

Morse KEYWORD1dash KEYWORD2dot KEYWORD2

Cada una de las líneas tiene el nombre de la palabra clave, seguida por un tabulador (sin

espacios), seguido por el tipo de palabra clave. Las clases deben ser KEYWORD1 y se colorean en

naranja; las funciones deben ser KEYWORD2 y serán marrones. Tendrás que reiniciar el entorno

Arduino para conseguir reconocer las nuevas palabras clave.

También sería una buena idea facilitar a la gente un ejemplo que haga uso de tu librería. Para hacer

esto, crea un directorio ejemplo dentro del directorio Morse. A continuación mueve o copia el directorio

que contiene el boceto (lo puedes llamar SOS) que hemos escrito dentro del directorio ejemplos.

(Puedes encontrar el boceto usando Boceto → Mostrar Carpeta de Bocetos). Si reinicias el entorno

Arduino (esto es lo último que haremos) verás un elemento Libray-Morse dentro del menú File →

Seketchbook → Examples . Puedes añadir algunos comentarios con mejores explicaciones sobre el

uso de tu librería.

Para más información, consulta la Guía de Estilo de la API que contiene detalles sobre hacer que tu

librería siga una buena API estilo Arduino.


Reconocimientos.

La mayor parte del contenido de este tutorial procede de la página web de Arduino

http://www.arduino.cc, en inglés. Así que si después de leer el tutorial se te ha despertado el gusanillo

puedes consultar la página. Seguiremos preparando tutoriales ampliados.

Saludos.

Sergio RomeroIngeniero en Automática y Electrónica Industrialemail: [email protected].: epmlince


mailto:[email protected]

http://www.arduino.cc/

Documents

ARDUINO Y OTRAS HIERBAS. - noeju.com · ARDUINO Y OTRAS HIERBAS. Introducción. En esta serie de tutoriales vamos a realizar una presentación de las plataformas Open Hardware para