Sumérgete en Arduino con un primer proyecto sencillo

Azahara Fernández Guizán

Programadora de .NET y Angular en Sngular

10 de mayo de 2023

Hace unos días trataba de explicar cómo iniciarse en Arduino es más fácil de lo que parece y que incluso, no hacen falta muchos conocimientos de electrónica para comenzar y disfrutar iniciándose. Desde entonces llevo pensando en cómo transmitirlo de forma más clara y me he dado cuenta de que la mejor manera es con un ejemplo. Así que allá vamos, vamos a realizar nuestra primera estación meteorológica de interior y vas a ver que es algo entretenido y muy sencillo.

¿Qué necesitas?

Lo primero de todo, si nunca has hecho nada con Arduino es hacerte con las herramientas y los utensilios necesarios para ello, así que aquí te dejo una pequeña lista, con enlaces a un conocido ecommerce, pero puedes comprarlos en muchos lugares:

Placa de Arduino. Aquí puedes elegir entre varios modelos, yo por ejemplo he usado la ELEGOO Mega de 2560 R3 y está bien de precio.
Una protoboard con algunos cables dupont (tener un buen montón nunca está de más).
Un kit de botones, resistencias y leds, de nuevo nunca sobran y verás como luego se te ocurren mil ideas para aprovecharlos. Con los leds vamos a crear un semáforo que indique nuestros niveles de luz y calidad de aire.
Un sensor de luz para arduino (Yo usé el MH series)
Un sensor de calidad del aire para arduino (Yo usé el MQ135)
Una caja que puedas agujerear (o bien si tienes impresora 3D, te la imprimes)
Un soldador y estaño (En casa tenemos uno profesional, pero te dejo el enlace a uno más normalito).

¿Para qué sirve la protoboard?

Es una placa para pruebas y desarrollo en electrónica que te permite conectar dispositivos sin necesidad de soldarlos. Para ello se unen por cables dupont y hay que tener en cuenta que las filas de puntitos están conectadas entre sí, de forma que se alimentan de la misma fuente de energía y tienen conductividad.
En la protoboard que te he recomendado hay tres grupos de puntitos, en los extremos hay unas dos filas en cada parte, que transmiten la conductividad en filas y una parte central que se transmite por columnas. Así que lo que conectes en los extremos en la misma fila, recibirá la misma corriente y en el centro ocurrirá lo mismo con lo que pongas en las mismas columnas.

Así que si desde la placa de Arduino conectas un cable dupont al pin de la tierra y luego este cable lo unes en una fila de un extremo, todos los puntitos de esa fila de la protoboard actuarán como tierra.

Lo mismo para las entradas de voltaje, desde uno de los pins de voltaje de la protoboard. Yo suelo poner en una fila de un extremo la tierra, y en el otro extremo el voltaje para no liarme. Y luego en el centro ya agrupas por columnas las resistencias, y cables que unen con los sensores.

¿Cómo se trabaja con la placa Arduino?

La placa Arduino hay que conectarla a una fuente de alimentación para proveerla de energía, es por eso que si la conectas por el USB al ordenador ya funciona. En ella tienes diferentes pins que traen un número y otros indican un voltaje o que son una tierra.

En la documentación de cada placa encontrarás para qué sirve cada uno, o incluso en la página oficial de Arduino te explican muy fácil cualquier duda que tengas. Pero calma, te voy a poner ahora un esquema de cómo la vas a unir.

¿Cómo programo?

Para eso vamos a usar el IDE de Arduino que es muy sencillo. En la propia documentación te explican como usarlo, pero en resumidas cuentas, escribes el código, lo compilas (botón icono check) y te permite subirlo a la placa si la tienes conectada (botón icono flecha lateral)

Además te permite importar directamente librerías, configurarlo para la placa que estás usando y poder sacar una consola que te muestra información sobre la ejecución. Te lo resumen todo muy bien en este manual.

¿Para qué quiero la caja y el soldador?

Pues simplemente para terminarlo y dejarlo como cualquier aparato que te pudieses haber comprado en una tienda. Esta parte no es obligatoria y de hecho al terminar si quieres, puedes deshacerlo todo y aprovecharlo para nuevos proyectos, pero si te apeteciera terminarlo, simplemente al terminar tendrías que ir soldando las distintas partes y meterlo en una cajita para darle una apariencia profesional.

¿Cómo comienzo?

Lo primero es poner un led y ver que se enciende, si eso lo has conseguido es que has entendido en que va a consistir.

Para ello tienes que colocarlo en la protoboard como muestran aquí en el manual de Geek Factory:

arduino

Y el código que necesitas, para encenderlo en Arduino es el siguiente:

int ledOnOFf = 48;

void setup()
{
  // Led onoff que indica si está funcionando
  pinMode(ledOnOFf, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledOnOFf, HIGH); //encendemos el led
}

Este código lo compilas y lo subes a la placa y verás como tu led se enciende. Aquí te darás cuenta de una cosa, en Arduino tienes 3 partes: declaración de variables, configuración (método setup) y un loop donde pones las acciones y van todas secuenciales y se repiten. No hay hilos, así que cuidado con cómo vas a programar las cosas.

Vale, pero y ¿cómo hago mi estación meteorológica?

Pues conectando parte a parte y poco a poco viendo que funciona, yo ahora te voy a dejar aquí el código por partes para que lo veas y lo vayas probando de como lo hice yo y verás en las declaraciones que pins utilicé de la placa Arduino. Puedes cambiarlos como desees, pero recuerda actualizar los datos en el código para que te los reconozca. Partiremos del código del led de encendido y lo vamos a ir complementando.

Y también adapta los valores que encienden los leds indicativos según tus circunstancias porque seguro que tu vivienda no tiene el mismo rango de luz que la mía.

Añadimos el sensor de luz

Lo primero de todo vamos a definir los pins que vamos a usar para los leds y para conectar nuestro sensor. Y lo conectaremos usando la protoboard y los cables dupont.

Para ello mira en la documentación del sensor (la oficial o busca un ejemplo en internet) donde debes unir la tierra del sensor a la protoboard y también dónde debes unir la toma de corriente del sensor a la hilera correspondiente de la protoboard.

El resto de pins libres del sensor, serán para unirlos con los que definas de la placa Arduino que serán los que tomarán los datos.

Recuerda que la protoboard en los extremos comunica la conectividad por filas y en el centro por columnas y que es una buena idea tener definida una fila para tierra y otra para voltage.

int ledGreen_PhotoSensor = 36;
int ledYellow_PhotoSensor = 38;
int ledRed_PhotoSensor = 40;



/* Configuracion Sensores */
int photoSensorDig = 9;
int photoSensorAnalog = 0;

Ahora haremos el setup de los leds y del sensor:

void setup()
{
  // Pins que indiquen cómo van los sensores, sin falta de la pantalla
  pinMode(ledGreen_PhotoSensor, OUTPUT);
  pinMode(ledYellow_PhotoSensor, OUTPUT);
  pinMode(ledRed_PhotoSensor, OUTPUT);
}

Y dentro del loop llamaremos al método que tomará los datos:

void loop()
{
  PhotoSensorControl(); 
  delay(500);
}

void PhotoSensorControl()
{
  int sensorValue = analogRead(photoSensorAnalog); //leemos analógicamente
  float photoVoltage = sensorValue * (5.0 / 1024.0); // con esta fórmula se calibra

  //decido que valores para cada color de led
  if (photoVoltage >= 0 && photoVoltage <= 1)
  {
  //verde
    digitalWrite(ledGreen_PhotoSensor, HIGH);
    digitalWrite(ledYellow_PhotoSensor, LOW);
    digitalWrite(ledRed_PhotoSensor, LOW);
  }
  else if (photoVoltage > 1 && photoVoltage <= 2)
  {
  //amarillo
    digitalWrite(ledGreen_PhotoSensor, LOW);
    digitalWrite(ledYellow_PhotoSensor, HIGH);
    digitalWrite(ledRed_PhotoSensor, LOW);
  }
  else if (photoVoltage > 2)
  {
  //rojo
    digitalWrite(ledGreen_PhotoSensor, LOW);
    digitalWrite(ledYellow_PhotoSensor, LOW);
    digitalWrite(ledRed_PhotoSensor, HIGH);
  }
  else
  {
  //estropeado o no funciona
    digitalWrite(ledGreen_PhotoSensor, HIGH);
    digitalWrite(ledYellow_PhotoSensor, HIGH);
    digitalWrite(ledRed_PhotoSensor, HIGH);
  }
}

Añadimos el sensor de C02

Lo primero de todo vamos a definir los pins que vamos a usar para los leds y para conectar nuestro sensor. Y lo conectaremos usando la protoboard y los cables dupont, similar a lo que has hecho para el sensor de luz.

/* Configuracion leds*/
int ledGreen_AirSensor = 30;
int ledYellow_AirSensor = 32;
int ledRed_AirSensor = 34;

/* Configuracion Sensores */
int airSensorDig = 10;
int airSensorAnalog = 3;
int ppm_AirSensor = 0;
float tension_AirSensor = 0;
bool state_AirSensor = false;

Ahora de nuevo vamos a ponerlos en el setup.

void setup()
{
  // Led onoff que indica si está funcionando
  pinMode(ledOnOFf, OUTPUT);

  // Pins que indiquen cómo van los sensores, sin falta de la pantalla
  pinMode(ledGreen_AirSensor, OUTPUT);
  pinMode(ledYellow_AirSensor, OUTPUT);
  pinMode(ledRed_AirSensor, OUTPUT);
}

Y añadir la lógica a nuestro loop para encender los leds.

void loop()
{
  AirSensorControl();
  delay(500);
}

void AirSensorControl()
{
//lectura digital del sensor
  state_AirSensor = digitalRead(airSensorDig);
//lectura analógica del sensor
  ppm_AirSensor = analogRead(airSensorAnalog); 
//fórmula para calibrar los datos
  tension_AirSensor = ppm_AirSensor * (5.0 / 1023.0); 


//ahora decidimos los valores para el semáforo
  if (!state_AirSensor || tension_AirSensor >= 700)
  {
  //nivel rojo
    digitalWrite(ledGreen_AirSensor, LOW);
    digitalWrite(ledYellow_AirSensor, LOW);
    digitalWrite(ledRed_AirSensor, HIGH);
  }
  else if (tension_AirSensor >= 100 && tension_AirSensor < 700)
  {
  //nivel amarillo
    digitalWrite(ledGreen_AirSensor, LOW);
    digitalWrite(ledYellow_AirSensor, HIGH);
    digitalWrite(ledRed_AirSensor, LOW);
  }
  else if (tension_AirSensor > 0 && tension_AirSensor < 100)
  {
  //nivel verde
    digitalWrite(ledGreen_AirSensor, HIGH);
    digitalWrite(ledYellow_AirSensor, LOW);
    digitalWrite(ledRed_AirSensor, LOW);
  }
  else
  {
  //todos los leds encendidos porque está estropeado o no funciona
    digitalWrite(ledGreen_AirSensor, HIGH);
    digitalWrite(ledYellow_AirSensor, HIGH);
    digitalWrite(ledRed_AirSensor, HIGH);
  }
}

¿Cómo queda el código completo?

/* Configuracion leds*/
int ledOnOFf = 48;
int ledGreen_AirSensor = 30;
int ledYellow_AirSensor = 32;
int ledRed_AirSensor = 34;
int ledGreen_PhotoSensor = 36;
int ledYellow_PhotoSensor = 38;
int ledRed_PhotoSensor = 40;

/* Configuracion Sensores */
int airSensorDig = 10;
int airSensorAnalog = 3;
int ppm_AirSensor = 0;
float tension_AirSensor = 0;
bool state_AirSensor = false;
int photoSensorDig = 9;
int photoSensorAnalog = 0;

void setup()
{
  // Led onoff que indica si está funcionando
  pinMode(ledOnOFf, OUTPUT);

  // Pins para los sensores
  pinMode(ledGreen_AirSensor, OUTPUT);
  pinMode(ledYellow_AirSensor, OUTPUT);
  pinMode(ledRed_AirSensor, OUTPUT);
  pinMode(ledGreen_PhotoSensor, OUTPUT);
  pinMode(ledYellow_PhotoSensor, OUTPUT);
  pinMode(ledRed_PhotoSensor, OUTPUT);
}
void loop()
{
  digitalWrite(ledOnOFf, HIGH); //encendemos el led

  AirSensorControl(); 
  PhotoSensorControl();

  delay(500);
}

void AirSensorControl()
{
  state_AirSensor = digitalRead(airSensorDig);
  ppm_AirSensor = analogRead(airSensorAnalog);
  tension_AirSensor = ppm_AirSensor * (5.0 / 1023.0); //calibramos


//creamos el semáforo de leds
  if (!state_AirSensor || tension_AirSensor >= 700)
  {
  //nivel rojo
    digitalWrite(ledGreen_AirSensor, LOW);
    digitalWrite(ledYellow_AirSensor, LOW);
    digitalWrite(ledRed_AirSensor, HIGH);
  }
  else if (tension_AirSensor >= 100 && tension_AirSensor < 700)
  {
  //nivel amarillo
    digitalWrite(ledGreen_AirSensor, LOW);
    digitalWrite(ledYellow_AirSensor, HIGH);
    digitalWrite(ledRed_AirSensor, LOW);
  }
  else if (tension_AirSensor > 0 && tension_AirSensor < 100)
  {
  //nivel verde
    digitalWrite(ledGreen_AirSensor, HIGH);
    digitalWrite(ledYellow_AirSensor, LOW);
    digitalWrite(ledRed_AirSensor, LOW);
  }
  else
  {
  //todos los leds encendidos porque está estropeado o no funciona
    digitalWrite(ledGreen_AirSensor, HIGH);
    digitalWrite(ledYellow_AirSensor, HIGH);
    digitalWrite(ledRed_AirSensor, HIGH);
  }
}

void PhotoSensorControl()
{
  int sensorValue = analogRead(photoSensorAnalog);
  float photoVoltage = sensorValue * (5.0 / 1024.0); //calibramos

//creamos el semáforo
  if (photoVoltage >= 0 && photoVoltage <= 1)
  {
  //verde
    digitalWrite(ledGreen_PhotoSensor, HIGH);
    digitalWrite(ledYellow_PhotoSensor, LOW);
    digitalWrite(ledRed_PhotoSensor, LOW);
  }
  else if (photoVoltage > 1 && photoVoltage <= 2)
  {
  //amarillo
    digitalWrite(ledGreen_PhotoSensor, LOW);
    digitalWrite(ledYellow_PhotoSensor, HIGH);
    digitalWrite(ledRed_PhotoSensor, LOW);
  }
  else if (photoVoltage > 2)
  {
  //rojo
    digitalWrite(ledGreen_PhotoSensor, LOW);
    digitalWrite(ledYellow_PhotoSensor, LOW);
    digitalWrite(ledRed_PhotoSensor, HIGH);
  }
  else
  {
  //estropeado o no funciona
    digitalWrite(ledGreen_PhotoSensor, HIGH);
    digitalWrite(ledYellow_PhotoSensor, HIGH);
    digitalWrite(ledRed_PhotoSensor, HIGH);
  }
}

¿Cómo lo puedes complementar?

Puedes añadirle un sensor de humedad, como el DHT11, o incluso uno de movimiento o uno de frecuencia cardíaca como hice yo en casa con mi pareja en nuestra Anxiety Station (en el enlace verás todo el código y los diagramas de conexiones). En este ejemplo tenemos además añadida una pantalla LCD para que muestre en texto los valores, algo que también puedes añadir a tu proyecto.

Y recuerda, no tengas miedo a probar y si te atascas, busca información que hay mucha online.

Azahara Fernández Guizán

Programadora de .NET y Angular en Sngular

Anterior Siguiente