Arduino Uno es una placa de microcontrolador basada en el microcontrolador ATmega328P de la compañía Atmel (ahora adquirida por Microchip Technology). Fue lanzada en 2010 y se convirtió en una de las placas más populares en la plataforma Arduino.
La placa Arduino Uno es una plataforma de hardware de código abierto que permite a los usuarios crear proyectos electrónicos interactivos y controlar dispositivos electrónicos usando software y hardware personalizado.
La placa Arduino Uno incluye pines de entrada y salida digitales y analógicos que permiten a los usuarios conectar sensores, actuadores y otros componentes electrónicos para crear proyectos personalizados. La placa se puede programar utilizando el entorno de desarrollo integrado (IDE) de Arduino, que se puede descargar gratuitamente desde el sitio web de Arduino, pero actualmente ya existen otras herramientas de desarrollo.
Vamos a ver una simple aplicación de una placa Arduino Uno conectada una placa de relés, lo cual puede servir como secuenciador por ejemplo para maquetas , juegos de luces, medidas eléctricas, escaparates , escenarios , SIMULAR LA ACTIVIDAD EN UNA VIVIENDA cuando estamos fuera, y un largo etc.
El aspecto del conjunto es el siguiente:
Como vemos en la iamgen anterior, solo usaremos 5 salidas binarias correspondientes a los pines d2, d3, d4, d5 las cuales conectaremos directaemente a las entradas de la placa de relés ( no olvidar la masa ).
Las conexiones no pueden ser mas simples ,porque se conectan las salidas binarias de la placa Arduino pin a pin a la placa de relés sin olvidar la masa o GND.
No recomendamos para nada alimentar desde la propia placa Arduino la placa de relés, porque esta puede consumir según el modelo de placa de relés mas energia de la que puede aportar la salida de Arduino de 5v y además casi todas las placas de relés de cierta calidad se alimentan a 12V, por lo que se recomienda alimentar la placa de relés externamente.
Y ahora presentamos el código Arduino del ejemplo , donde también sacamos por consola los nombres de las cargas que vamos encendiendo y el tiempo de conexión total.
Por supuesto los nombre de los aplicativos a conectar se deberían cambiar con el nombre de los dispositivos eléctricos que conectemos
Es de interes destacar que calculamos cualquier combinación de 5 bits , la cual sacamos por los puertos binarios.
Además del combinación de salidas activadas que es aleatoria, también permanece en un estado de tiempo aleatorio entre 6000 y 100.000 ( la variable se llama tiempoEncendido) así como también hay una breve pausa de todo apagado entre 10.000 y 60000 ( la variable se llama tiempo_pausa), ambas por supuesto que debemos cambiar en función de la utilidad que se desee.
El resto de la funcionalidad del programa es sacar por consola el / o los electrodomésticos a encender , el tiempo que se va a encender y luego apagar así como el tiempo total de funcionamiento
El código completo de todo el programa es el siguiente, el cual se debería adaptar y personalizar a las necesidades de cada caso concreto:
int soldador = 2;
int luz_led = 3;
int luz_halogena = 4;
int ordenador = 5;
int ventilador = 6;
unsigned long tiempoEncendidoTotal = 0; // tiempo total que se va invirtiendo en milisegundos
void setup() {
Serial.begin(115200);
Serial.println("Iniciando ..");
pinMode(soldador, OUTPUT);
pinMode(luz_led, OUTPUT);
pinMode(luz_halogena, OUTPUT);
pinMode(ordenador, OUTPUT);
pinMode(ventilador, OUTPUT);
randomSeed(analogRead(A0));
digitalWrite(soldador, HIGH); // apaga el soldador
digitalWrite(luz_led, HIGH); // apaga la luz LED
digitalWrite(luz_halogena, HIGH); // apaga la luz halógena
digitalWrite(ordenador, HIGH); // apaga el ordenador
digitalWrite(ventilador, HIGH); // apaga el ventilador
delay (1000);
}
void loop() {
long tiempo_pausa = random(10000, 60000); // tiempo aleatorio entre 10 y 60 segundos en milisegundos
int dispositivo = random(0, 33); // número aleatorio entre 0 y 32
Serial.print("Numero generado: ");
Serial.println(dispositivo);
String binaryString = String(dispositivo, BIN);
Serial.print("Cadena:");
Serial.println(binaryString);
if (dispositivo & (1 << 0)) { // verifica si el bit 0 está activado
digitalWrite(soldador, LOW); // enciende el soldador
Serial.println("Soldador encendido");
} else {
digitalWrite(soldador, HIGH); // apaga el soldador
}
if (dispositivo & (1 << 1)) { // verifica si el bit 1 está activado
digitalWrite(luz_led, LOW); // enciende la luz LED
Serial.println("Luz LED encendida");
} else {
digitalWrite(luz_led, HIGH); // apaga la luz LED
}
if (dispositivo & (1 << 2)) { // verifica si el bit 2 está activado
digitalWrite(luz_halogena, LOW); // enciende la luz halógena
Serial.println("Luz halógena encendida");
} else {
digitalWrite(luz_halogena, HIGH); // apaga la luz halógena
}
if (dispositivo & (1 << 3)) { // verifica si el bit 3 está activado
digitalWrite(ordenador, LOW); // enciende el ordenador
Serial.println("Ordenador encendido");
} else {
digitalWrite(ordenador, HIGH); // apaga el ordenador
}
if (dispositivo & (1 << 4)) { // verifica si el bit 4 está activado
digitalWrite(ventilador, LOW); // enciende el ventilador
Serial.println("Ventilador encendido");
} else {
digitalWrite(ventilador, HIGH); // apaga el ventilador
}
long tiempoEncendido = random(6000, 300000); //genera un número aleatorio entre 1 minuto (60000ms) y 5 minutos (300000ms)
Serial.print("Tiempo encendido nuevo estado: ");
Serial.println(tiempoEncendido/1000);
Serial.print(" Tiempo de pausa tras nuevo estado: ");
Serial.print(tiempo_pausa/1000); // muestra el tiempo en segundos
Serial.println(" segundos");
tiempoEncendidoTotal += tiempoEncendido;
unsigned long tiempoAcumulado = tiempoEncendidoTotal / 1000;
unsigned int horas = tiempoAcumulado / 3600;
unsigned int minutos = (tiempoAcumulado % 3600) / 60;
unsigned int segundos = tiempoAcumulado % 60;
delay(tiempoEncendido); //espera el tiempo aleatorio generado
digitalWrite(soldador, HIGH);
digitalWrite(luz_led, HIGH);
digitalWrite(luz_halogena, HIGH);
digitalWrite(ordenador, HIGH);
digitalWrite(ventilador, HIGH);
delay(tiempo_pausa);
Serial.print("Tiempo encendido total: ");
Serial.print(horas);
Serial.print(":");
if (minutos < 10) {
Serial.print("0");
}
Serial.print(minutos);
Serial.print(":");
if (segundos < 10) {
Serial.print("0");
}
Serial.println(segundos);
}Extracto
Este código, escrito en el IDE de Arduino , controla el estado de encendido/apagado de varios dispositivos (soldador, luz_led, luz_halogena, ordenador, ventilador) basándose en números binarios generados aleatoriamente. Los dispositivos están conectados a pines digitales específicos de la placa Arduino y se encienden/apagan cambiando la señal digital de estos pines de alta a baja (encendido) o de baja a alta (apagado).
El programa también realiza un seguimiento del tiempo total de encendido de todos los dispositivos en segundos y lo muestra en horas, minutos y segundos. El tiempo de encendido de cada dispositivo se genera aleatoriamente y varía entre 1 minuto (6000ms) y 5 minutos (300000ms), mientras que el tiempo de pausa entre los tiempos de encendido de cada dispositivo también se genera aleatoriamente entre 10 y 60 segundos.
El programa comienza inicializando todos los dispositivos en el estado de apagado, luego entra en un bucle infinito que genera un nuevo número binario y enciende/apaga los dispositivos en consecuencia, basándose en el estado de cada bit en el número binario. Después de cada período de encendido, todos los dispositivos se apagan y se inserta un tiempo de pausa antes de que comience el siguiente ciclo.
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.