Arduino, programación

Arduino, panorámica

Tutorial ARDUINO: Programación (“Sketch”)

 

post it colaboracionEl compañero Martínrv84 ha elaborado un sencillo tutorial (Publicado en EAG) sobre un tema complejo como es Arduino. Con sencillez y de modo práctico nos explicará todo lo necesario para un montaje básico de controlador de dos tanques simultáneamente. Ya puestos en materia no será difícil observando los procedimientos adaptarlo a nuestras necesidades concretas.

 

Programando Arduino

 

Sketch

Esta palabra viene del inglés y significa borrador, con ella definimos a todo el “texto” que contendrá las órdenes que le demos al Arduino y que consta de varias partes:
1.   Para empezar tendremos que incluir las librerías que necesitemos usando el menú sketch -> importar librerías y ahí las que necesitemos.
2.   Luego vendrán las definiciones que vienen a ser los nombres que le ponemos a determinados pines, periféricos,… para que nos quede más bonito y fácil de entender.
3.   Ahora tendremos el void setup(), todo lo que pongamos entre dos corchetes después de esto se ejecutara una única vez.
4.   Y por último el void loop(), este es igual que el anterior a excepción de que al llegar al final vuelve de nuevo al principio y se vuelve a ejecutar y así infinitamente mientras tengamos alimentado el Arduino.

Si abrís el IDE y en archivo -> ejemplos y miráis uno aleatoriamente podréis ver cada una de las partes que aquí os acabo de enumerar.

Dicho esto os voy a poner el sketch desmenuzado para que veáis cada cosilla:

Código (* No copiar):
#include <DallasTemperature.h>
#include <OneWire.h>
#include <RelojDS1307.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

 

Estas son nuestras librerías que harán trabajar las sondas de temperatura, el reloj y la pantalla. Las “wire” son para los dispositivos conectados por el I2C y en serie (las sondas en este caso).

Código (* No copiar):
#define TEMP           7
#define LUZ            8
#define LUZLUNA        4
#define CAL1           5
#define CAL2           6

 

Estos son los pines en los que conectaremos cada una de los elementos (No tiene ningún misterio).

Código (* No copiar): 
LiquidCrystal_I2C lcd(0x27,20,4);
OneWire oneWire(TEMP);
DallasTemperature sensors(&oneWire);
DeviceAddress ACUARIO, GAMBARIO;
RelojDS1307Class Reloj;

 

Aquí lo que hemos hecho es decirle al Arduino que la pantalla se pasará a llamar “lcd”, su dirección en 0×27 y su tamaño es de 10 caracteres en horizontal y 4 en vertical. Al pin donde conectaremos las sondas se llamara “TEMP” y la sonda que está instalada primero se llamara “ACUARIO” mientras que la segunda “GAMBARIO”. De la misma manera al DS1307 se denominará “Reloj”.

Código (* No copiar):
void setup()
{
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();

  pinMode(LUZ, OUTPUT);
  pinMode(LUZLUNA, OUTPUT);
  pinMode(CAL1, OUTPUT);
  pinMode(CAL2, OUTPUT);

 

Ahora ya estamos dentro del “void setup”. Lo que se encuentre aquí solo se ejecutará una sola vez al inicio. Con “Serial begin” hacemos que se inicie la comunicación de datos con el pc mediante el USB y el numero entre paréntesis es la velocidad en baudios. “lcd.init()” inicia la pantalla (ningún misterio traduciendo las palabras) y si cambiamos el “init” por “backlight” lo que le decimos es que encienda la iluminación de la misma. Para finalizar, las siguientes cuatro líneas lo que hacen es poner los pines indicados en modo salida para que envíen una señal eléctrica a los relés de manera que podrán funcionar.

Código (* No copiar): 
Serial.print("Localizando sondas de temperatura: ");
  Serial.print("Encontradas  ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" sondas.");
  lcd.setCursor(4,0);
  lcd.print("ACUARATOR V2");
  lcd.setCursor(5,2);
  lcd.print("MARTINRV84");
  delay(5000);
  //Reloj.SetDateTime( 17, 04, 13, 20, 47, 00 );
}

 

El Serial.print(“TEXTO”) lo utilizamos para enviar texto al PC mediante el USB donde la parte TEXTO es lo que se verá. En caso de usar el “Serial.println(“TEXTO”)” la acción es exactamente la misma pero escribirá un punto y aparte después del texto.

Ahora empezaremos a pintar la pantalla, el “lcd.setCursor(X,X)” lo usamos para decirle donde queremos empezar a pintar y lo demás es lo mismo pero cambiando “Serial” por “lcd” para que sepa que es en la pantalla y no en el PC.

La función “delay” es una pausa expresada en milisegundos y en este caso lo que hace es que al encenderse el Arduino, durante 5000 milisegundos (5 segundos) se verá lo de “ACUARATOR V2”  y “MARTINRV84” en las coordenadas que le he indicado (Es que tengo que alimentar un poquitín mi autoestima de vez en cuando).

La última frase la usamos para configurar el reloj, una vez hayamos cargado el sketch en el Arduino y este se haya iniciado tendremos que escribir “//” al principio de la frase para que se convierta en un comentario y no se ejecute cada vez que encendamos el Arduino sino siempre sobrescribiría esa fecha y hora y sería imposible que el encendido de las luces se produjera a su hora correcta.

Código (* No copiar):
void loop()
{
 Serial.print("Recibiendo temperaturas...");
 sensors.requestTemperatures();
 Serial.println("OK");
printData(ACUARIO);
 printData(GAMBARIO);
float AGUA1 = sensors.getTempC(ACUARIO);
 float AGUA2 = sensors.getTempC(GAMBARIO);

 

Como podéis observar, ahora nos encontramos en el “void loop()” esto es igual que el anterior a diferencia que una vez el Arduino llega al final regresa aquí para seguir trabajando. Aquí las novedades son el “sensors.requestTemperatures()”que es una petición de los parámetros de las sondas y que almacenamos momentáneamente con los “float” por separado y con el nombre que esta antes del paréntesis.
Los “printData” es una llamada a una función que se encuentra fuera del “void loop()” pero como esta llamada está dentro pues es casi lo mismo. Las futuras funciones las colocaremos también fuera del “void loop()” pero con llamadas a las mismas dentro para tener el sketch más limpio, ordenado y fácil de modificar.

Código (* No copiar):

if(AGUA1 < 24)
  {
    digitalWrite (CAL1, HIGH);
    lcd.setCursor(19,2);
    lcd.print("I");
  }

  if(AGUA1 > 25)
  {
    digitalWrite (CAL1, LOW);
    lcd.setCursor(19,2);
    lcd.print("O");
  }

  if(AGUA2 < 24)
  {
    digitalWrite (CAL2, HIGH);
    lcd.setCursor(19,3);
    lcd.print("I");
  }

  if(AGUA2 > 25)
  {
    digitalWrite (CAL2, LOW);
    lcd.setCursor(19,3);
    lcd.print("O");
  }

 

Esta es la configuración de las temperaturas y también tenemos un par de funciones nuevas. “if” es una condición, de forma que si se cumple que está dentro del siguiente paréntesis, se ejecutan las ordenes de dentro de los corchetes del “if” y el “digitalWrite” que lo usaremos para enviar una señal eléctrica al relé (HIGH) o no enviar nada (LOW). De forma que aquí la explicación seria (tomamos como ejemplo el primer “if”) – si la sonda 1 que es la del acuario, marca menos de 24º, encenderemos el calentador 1 que también es del acuario y en las coordenada 19,2 escribiremos una i mayúscula para marcar que esta encendido.

Código (* No copiar):
if(Reloj.IsLater(9, 59) && Reloj.IsPrevious(21, 59))
  {
    digitalWrite(LUZ, HIGH);
    digitalWrite(LUZLUNA, LOW);
  }

  else
  {
    digitalWrite(LUZ, LOW);
    digitalWrite(LUZLUNA, HIGH);
  }

 

Y para seguir complicando las cosas añadimos alguna cosilla más como es el caso del “else” que es complementario al “if” y quiere decir que si no se cumplen las condiciones para ejecutar el “if” debe ejecutar lo que está dentro de los corchetes del “else”. En esta frase,(Reloj.IsLater(9, 59) && Reloj.IsPrevious(21, 59) lo que he dejado en letra normal significa “y” (es que los que diseñaron el lenguaje les parecía demasiado simple escribir solo “y”). Con esto ya tenemos listo el tema de las luces.

Código (* No copiar):
 if (!sensors.getAddress(ACUARIO, 0))
 { 
  Serial.println("INCAPAZ DE ENCONTRAR SONDA ACUARIO");
  lcd.setCursor(0,1);
  lcd.print("FALLO S1");
 } 
  if (sensors.getAddress(ACUARIO, 0))
 { 
  lcd.setCursor(0,1);
  lcd.print("S1 -- OK");
 }

  if (!sensors.getAddress(GAMBARIO, 1)) 
  {
  Serial.println("INCAPAZ DE ENCONTRAR SONDA GAMBARIO");
  lcd.setCursor(10,1);
  lcd.print("FALLO S2");
  }
  if (sensors.getAddress(GAMBARIO, 1)) 
  {
  lcd.setCursor(10,1);
  lcd.print("S2 -- OK");
  }
}

 

Este es el final del “void loop()” y corresponde a una función que implemente para saber al visualizar la pantalla si las sondas están trabajando adecuadamente o no. Para ello solo he usado una frase nueva (!sensors.getAddress(GAMBARIO, 1))  esta dice que si no se reciben datos de la sonda (del gambario en este caso) se ejecuta el “if”, una pequeña aclaración, la exclamación expresa negación por lo que si no hay error nos marca cada una de las sondas OK.

Código (* No copiar): 
void printTemperature(DeviceAddress deviceAddress)
{
  float AGUA1 = sensors.getTempC(ACUARIO);
  float AGUA2 = sensors.getTempC(GAMBARIO);
  Serial.print("ACUARIO: ");
  Serial.print(AGUA1);
  Serial.print("  ");
  Serial.print("GAMBARIO: ");
  Serial.print(AGUA2);
  Serial.print("  ");
  lcd.setCursor(0,0);
  lcd.print(Reloj.DateTime());
  lcd.setCursor(0,2);
  lcd.print("ACUARIO:  ");
  lcd.print(AGUA1);
  lcd.setCursor(0,3);
  lcd.print("GAMBARIO: ");
  lcd.print(AGUA2);
}
Esta es la llamada de la que os hablé antes y creo que ya está todo explicado. Este es el sketch completo desmenuzado y explicado (posiblemente no muy bien pero se intenta al menos), en él se encuentra todo el funcionamiento y ordenes que harán de nuestro Arduino y sus periféricos un perfecto controlador para nuestros acuarios y gambarios.

 

PELIGROSO* Nota de C.: Ante los evidentes problemas de tabulación que presenta esta página y a la espera de poder solucionarlos, se hace imprescindible la copia del sketch AQUÍ. Rogamos disculpéis las molestias pero de este modo trabajaréis sobre seguro y partiendo de un texto ya copiado, insertado y probado (Testado).

 

(Texto e imágenes: MartínRV. CCBYSA3.0)

 

 

Bueeeno, y ya para terminar quisiéramos hacer tan solo un apunte que creemos del interés general. Un microordenador programable asociado a una serie de periféricos requiere de una ardua tarea de I+D. Diseño de proyectos, prototipos, optimización, testado, etc… Todo esto se ha llevado a cabo gratuitamente por parte de ingenieros, técnicos de diferentes ámbitos y programadores bajo licencia CC con el fin de hacer accesible una tecnología de elevado coste a los sectores más pobres de población. No, no para que monten acuarios sino para comandar equipamiento médico, de purificación de agua, etc… Pues eso, comprando equipos oficiales Arduino, además de contar con la mayor seguridad y estabilidad en nuestro sistema, contribuiremos a que la plataforma prosiga su investigación.

Tutorial:

Ir a Introducción a Arduino, software>

Ir a Arduino, el hardware>

Ir a Arduino, el montaje>

Estás en Arduino, programación

 

Volver a Automatismos<

Volver a Taller<

Suscribete a Zootecnia Domestica

Apuntate a nuestro newsletter y recibe nuestras novedades el primero.

Leave a Reply

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. CERRAR