Etiqueta: matriz de leds

Los ojos de mi robota: Utilizar funciones en el Arduino IDE

Una función es un fragmento de código que realiza una tarea específica, a la que llamamos cada vez que necesitamos que se realice esta tarea.

En mi ejemplo, tengo una matriz de leds MAX7219CNG que utilizo como ojos y boca de mi robota humanoide. Entonces programé cuatro funciones:

  • Mirar para adelante: ojosdefrente()
  • Pestañear: pestaneo()
  • Mirar para la izquierda: mirar_izquierda();
  • Mirar para la derecha: mirar_derecha();

En este primer ejemplo sólo utilizaremos funciones que no devuelven ningún valor, por eso comienzan con void, igual que las ya conocidas void setup() y void loop().

Si una función va a devolver un valor, en lugar de void debe comenzar con el tipo de dato que tendrá lo que devuelva, por ejemplo int. En ese caso, la última línea de la función será return y el valor que debe devolver.

Voy a tomar como ejemplo la función “mirar_izquierda”. Comienza con void porque no devuelve ningún valor, pero entre paréntesis declara la variable tiempo. Esa variable tomará el valor que nosotros le enviemos al llamar a la función:

void mirar_izquierda(int tiempo)

Luego, entre llaves, se escriben todas las acciones de esa función. En este caso todas las líneas de código dibujan la cara mirando a la izquierda:

{ lc.setColumn (0, 7, B11100111);
lc.setColumn (0, 6, B00000000);
lc.setColumn (0, 5, B00010001);
lc.setColumn (0, 4, B00110011);
lc.setColumn (0, 3, B00000000);
lc.setColumn (0, 2, B00111100);
lc.setColumn (0, 1, B01000010);
lc.setColumn (0, 0, B00111100);

En la última línea se utiliza la variable que se pasó como parámetro, con un delay:

delay(tiempo); }

Entonces, cada vez que yo necesite que la carita mire hacia la izquierda, puedo escribir simplemente el nombre de la función, y entre paréntesis indicarle el tiempo en milisegundos:

mirar_izquierda(1000)

Aquí el código completo para la carita:

#include "LedControlMS.h"
#define NumMatrix 1 // Cuantas matrices vamos a usar
LedControl lc = LedControl(12, 11, 10, NumMatrix); // Creamos una instancia de LedControl

void setup() {
//matriz de leds
for (int i = 0; i < NumMatrix ; i++)
  {
   lc.shutdown(i, false); // Activar matrices, por si hay más de una
   lc.setIntensity(i, 0); // Poner el brillo a un valor bajo
   lc.clearDisplay(i); // Borrar todo
  }
}

void loop() {
   ojosdefrente(500); 
   mirar_derecha(1000);
   mirar_izquierda(500);
   ojosdefrente(100);
}

void ojosdefrente(int tiempo) {
   lc.setColumn (0, 7, B11100111);
   lc.setColumn (0, 6, B00000000);
   lc.setColumn (0, 5, B01000100);
   lc.setColumn (0, 4, B01100110);
   lc.setColumn (0, 3, B00000000);
   lc.setColumn (0, 2, B00000000);
   lc.setColumn (0, 1, B01000010);
   lc.setColumn (0, 0, B00111100);
   delay(tiempo);
   numeroalazar = random(100); // escribe un número aleatorio de 0 a 300 en la variable 'numAleatorio'
   Serial.println(numeroalazar);
   if (numeroalazar == 10) { pestaneo(); }
}

void pestaneo() {
   lc.setColumn (0, 7, B00000000);
   lc.setColumn (0, 6, B11100111);
   lc.setColumn (0, 5, B00000000);
   lc.setColumn (0, 4, B00000000);
   lc.setColumn (0, 3, B11101110);
   lc.setColumn (0, 2, B01000100);
   lc.setColumn (0, 1, B00000000);
   lc.setColumn (0, 0, B00111100);
   delay(100);
   lc.setColumn (0, 7, B00000000);
   lc.setColumn (0, 6, B00000000);
   lc.setColumn (0, 5, B11100111);
   lc.setColumn (0, 4, B00000000);
   lc.setColumn (0, 3, B00000000);
   lc.setColumn (0, 2, B01100110);
   lc.setColumn (0, 1, B00000000);
   lc.setColumn (0, 0, B00111100);
   delay(100);
}

void mirar_derecha(int tiempo) {
   lc.setColumn (0, 7, B11100111);
   lc.setColumn (0, 6, B00000000);
   lc.setColumn (0, 5, B10001000);
   lc.setColumn (0, 4, B11001100);
   lc.setColumn (0, 3, B00000000);
   lc.setColumn (0, 2, B00111100);
   lc.setColumn (0, 1, B01000010);
   lc.setColumn (0, 0, B00111100);
   delay(tiempo);
}


void mirar_izquierda(int tiempo) {
   lc.setColumn (0, 7, B11100111);
   lc.setColumn (0, 6, B00000000);
   lc.setColumn (0, 5, B00010001);
   lc.setColumn (0, 4, B00110011);
   lc.setColumn (0, 3, B00000000);
   lc.setColumn (0, 2, B00111100);
   lc.setColumn (0, 1, B01000010);
   lc.setColumn (0, 0, B00111100);
   delay(tiempo);
}

Gracias a Prometec por este tutorial en que me basé para el uso básico de la matriz de leds.

Para conocer más funciones de la librería que maneja la matriz de leds, este es un excelente lugar donde buscar referencias.

Matriz de led MAX7219CNG y feliz día a las mujeres en Ciencia y Tecnología

Observando detalladamente la leyenda impresa, se puede ver que la matriz que usé para este video tiene un driver MAX7219CNG

Matriz de leds MAX7219CNG

Gracias a este tutorial de Prometec, en cinco minutos pude usar mi nueva matriz de leds.

Las conexiones:

Indicador en el sensor Conexión en la placa Arduino
VCC se conecta al positivo (5v)
GND va conectado al negativo (GND)
DIN 12
CS 10
CLK 11

El código lo adapté del tutorial de Prometec, donde se incluye el código para varias matrices porque estas matrices pueden conectarse una con otra. En este caso, al tener una sola matriz sería:

#include "LedControlMS.h"
LedControl lc=LedControl(12,11,10, 1);  // Creamos una instancia de LedControl, el último parámetro es la cantidad de matrices

void setup()
   {
     lc.shutdown(0,false);    // Activar matriz número 0
     lc.setIntensity(0,0);    // Poner el brillo bajo a la matriz 0
     lc.clearDisplay(0);      // Borrar la matriz 0
   }

void loop()
   {
        lc.writeString(0,"Feliz Ada Lovelace Day");
        delay(1000);
   }

Y de paso aproveché para felicitar a las mujeres que aportan a la ciencia y la tecnología, en el día de Ada Lovelace:

 

Medir el nivel de agua con Arduino

Hoy utilicé un sensor de nivel de agua con mi nuevo arduino Mega, pero es igual para arduino Uno. La forma de conectarlo es muy sencilla, simplemente tiene tres pines:

Indicador en el sensor Conexión en la placa Arduino
+ se conecta al positivo (5v)
– va conectado al negativo (GND)
S a un pin analógico. En mi ejemplo lo conecté a A0

Arduino UNOSensor de nivel de agua
Gracias a este tutorial de Prometec aprendí que alcanza con este sencillo código para ver la medición:

void setup()
   {
       Serial.begin(9600);
   }
 
void loop()
   {
       Serial.println(analogRead(A0));
   }

Utilizando el menú abrimos el monitor serial (en el menú Herramientas), y podemos ver cómo se muestra el nivel de agua:

Monitor serial

No conforme con ver en el monitor serial el resultado, conecté también un display LCM 1602. La explicación de como conectarlo es sencilla:

GND – va a GND

VCC – a 5v

SDA y SCL, en el caso del arduino Mega, va a los pines que tienen ese nombre: SDA y SCL. En el caso del arduino Uno, van a A4 / A5 (aquí, más información)

Una vez realizadas todas las conexiones, este fue el código que utilicé:

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity
int agua = 0;

void setup()
{
Serial.begin(9600); // para utilizar el sensor de agua
lcd.begin(16,2); // inicializa el display
lcd.backlight(); // enciende la luz del display
lcd.setCursor(0, 0); // acomoda el cursor
lcd.print("Nivel de agua: "); // escribe el texto

}
void loop()
{
lcd.clear(); // borra el contenido del display
lcd.setCursor(0, 0); // acomoda el cursor
lcd.print("Nivel de agua: "); // escribe el texto
lcd.setCursor(12, 1); // acomoda el cursor
agua = analogRead(A0); // guarda en variable valor del sensor de agua
lcd.print(agua); //Escribe en el display el valor del sensor
Serial.println(agua); //Escribe en el monitor serial el valor de agua
delay(50); // espera un poquito antes de continuar

}

Un dato: Al conectar el display, el valor devuelto por el sensor de agua se altera, no vuelve a 0 sino que queda en 8 aproximadamente.