¿Cuáles son los mejores proyectos que podemos programar con Arduino fáciles y útiles? Lista 2024

En los últimos años, Arduino ha sido ampliamente elogiado porque puede proporcionar a los desarrolladores de todo el mundo los beneficios de usar su plataforma y placa de desarrollo para elaborar proyectos digitales e interactivos.

Con la ayuda del programa de lenguaje Arduino IDE, puedes agregar instrucciones al microcontrolador de una placa, para que el hardware o software que desees diseñar pueda realizar tareas específicas.

Dicho esto, la razón por la que realizamos este post puede variar según el propósito que tengas en mente. Por lo tanto, te presentamos algunas de las tecnologías más comunes y simples que puede desarrollar con Arduino.

¿Qué clase de dispositivos puedo crear utilizando Arduino y sus placas de desarrollo de hardware?

Una de las ventajas que ofrece Arduino es su gran flexibilidad para trabajar en cualquier proyecto. Esto se basa, en general, por el desarrollo que posee la plataforma, la cual es de código abierto. De esta manera, puede ser usada en la creación de diferentes tipos de tareas y dispositivos únicos.

Si quieres conocer algunos proyectos que puedes programar de manera rápida, mira a continuación:

Wearables

La tecnología wearable es muy conocida hoy en día. El tamaño pequeño que presentan sus dispositivos, los cuales pueden ser usados por debajo o encima de la ropa, y las funciones que ofrece al usuario son aspectos distintivos de esta herramienta.  Se puede crear con Arduino una prótesis, una pulsera, un reloj y cualquier objeto corporal que se te ocurra.  Con esta tecnología portátil se identifica qué accesorios inteligentes se pueden incluir en la vestimenta.

Una de las diferencias que posee un receptor y emisor de datos para el cuerpo con un dispositivo común es que los primeros poseen funciones exclusivas, por ejemplo, pantallas, sensores y un procesador para gestionar información específica que requiere el usuario. Mientras que el resto de los equipos electrónicos están pensados para realizar funciones estándares, sin importar qué tipo de operador lo usa.

Veamos a continuación un ejemplo de un proyecto Wearable con Arduino. Para crear un sensor de pulso vas a necesitar una placa Arduino UNO y un sensor electrónico ProtoCentral para rotura de oxímetro, también deberás contar con cables para realizar las uniones.

Una vez que tengas todos los elementos deberás abrir el IDE de Arduino y copiar este código:

#include "Protocentral_MAX30100.h"

#include <Wire.h>

MAX30100 sensor;

uint8_t data_len=8;

uint8_t DataPacketHeader[15];

volatile long IRR,REDD;

void setup() {

begin();

begin(57600);

while(!Serial);

begin(pw1600, i50, sr100 );

printRegisters();

}

void loop() {

readSensor();

IRR=sensor.IR;

REDD=sensor.RED;

DataPacketHeader[0] = 0x0A;

DataPacketHeader[1] = 0xFA;

DataPacketHeader[2] = (uint8_t) (data_len);

DataPacketHeader[3] = (uint8_t) (data_len>>8);

DataPacketHeader[4] = 0x02;

DataPacketHeader[5] = REDD;

DataPacketHeader[6] = REDD>>8;

DataPacketHeader[7] = REDD>>16;

DataPacketHeader[8] = REDD>>24;

DataPacketHeader[9] = IRR;

DataPacketHeader[10] = IRR>>8;

DataPacketHeader[11] = IRR>>16;

DataPacketHeader[12] = IRR>>24;

DataPacketHeader[13] = 0x00;

DataPacketHeader[14] = 0x0b;

for(int i=0; i<15; i++) // esto servirá para transmitir los datos al sensor

{

write(DataPacketHeader[i]);

}

//Serial.println(sensor.getPartID());

/* Tener presente:

println(REDD,HEX);

println(IRR,HEX);*/

delay(10);

}

Domótica

Cuando hablamos de domótica, en general, hace referencia a los sistemas de hogares inteligentes. Estas tecnologías son muy reconocidas por sus múltiples ventajas a la hora de automatizar de forma ingeniosa cualquier parte de una casa. Existen diversos tipos de dispositivos que podemos usar en este entorno, uno de los ejemplos más interesantes y que ha ayudado a arreglar los respectivos problemas de seguridad son aquellos sistemas de vigilancia, alarma y cerraduras antirrobos que pueden incluirse en el hogar.

Para que realices un proyecto sin cometer errores, podrás crear una cámara de vigilancia con sensor de movimiento. Cuando se dispare una alerta recibirás una foto en la plataforma Discord. Vas a necesitar un kit de conectores, una placa Arduino Nano R3, una protoboard, en sensor de movimientos y una cámara de tipo ESP32.

Los códigos que deberás escribir son:

/*

Ejemplo de uso de una placa Arduino Nano R3 para cámara ESP32

Internet Paso a Paso

*/

#include <WiFiClientSecure.h>

#include <credentials.h>

const char* ssid = mySSID;

const char* password = myPASSWORD;

const char* server = "howsmyssl.com";  // Server URL

const char* root_ca = \

//Ingresa un certificado para autenticación de clientes, los puedes conseguir desde plataformas autorizadas peer to peer

//Si lo deseas, puedes usar x.509 client certificates

//const char* test_client_key = ""; //esto es para verificar el cliente

//const char* test_client_cert = ""; //autenticación de clientes

WiFiClientSecure client;

void setup() {

//Initialize serial and wait for port to open:

begin(115200);

delay(100);

print("Attempting to connect to SSID: ");

println(ssid);

begin(ssid, password);

// attempt to connect to Wifi network:

while (WiFi.status() != WL_CONNECTED) {

print(".");

// wait 1 second for re-trying

delay(1000);

}

print("Connected to ");

println(ssid);

setCACert(root_ca);

//client.setCertificate(test_client_key);

//client.setPrivateKey(test_client_cert);

println("\Iniciando conexión al servidor");

if (!client.connect(server, 443)) {

println("¡Sin conexión!");

}

else {

println("¡Conectado al servidor de forma correcta!");

// Make a HTTP request:

println("GET https:// "); //ingresar la dirección de host

println("Host: "); // URL del host

println("Conección OK");

println();

while (client.connected()) {

String line = client.readStringUntil('\n');

if (line == "\r") {

println("headers received");

break;

}

}

// if there are incoming bytes available

// from the server, read them and print them:

while (client.available()) {

char c = client.read();

write(c);

}

stop();

}

}

void loop() {

// no hacer nada

}

Robótica

El término robótica es uno de los más mencionados, y no solo en este campo de diseño, sino también a nivel internacional. Como bien sabemos, esta ciencia se utiliza para la producción de robots, esto se conoce, por ser dispositivos o computadoras que tienen la facultad de moverse y realizar una tarea concreta. Un proyecto simple que puedes realizar con una placa Mega 2560, un sensor HC-SR04, un kit de cables y un servomotor SG90 es un animador Arduino.

Para ello deberás ingresar estos códigos de programación en el entorno IDE:

#include <Servo.h>

#include <SPI.h>

#include <Adafruit_GFX.h>

#include <Max72xxPanel.h>

//matrix

int l;

int Cs = 53;

int i=0;

int x=7;

bool Mprint=false;

bool ok=false;

unsigned long time3;

Max72xxPanel m1 = Max72xxPanel(Cs, 1, 1);

String msg = "Internet Paso a Paso, Curso de Arduino";

int w8 = 70;

int esp = 1;

int ancpal = 5 + esp;

bool msgact =false;

// Ultrasonido

int medida;

int ultra=15;

int eco=14;

int dura;

int distancia;

int dist;

bool distOk= false;

int tomas=0;

int c5=0;

unsigned long time4;

// buzzer

int push;

int c1;

int c=0;

bool coff = false;

bool actB = false;

unsigned long time2;

//servos

Servo servoR;

Servo servoL;

unsigned long time1;

int R=90,L=90;

boolean c2=false;

bool cs2=false;

int c22=0;

bool actS = false;

//System

bool systemF= false;

void setup() {

pinMode(ultra,OUTPUT);

pinMode(eco,INPUT);

attach(9);

attach(10);

pinMode(30,OUTPUT);

pinMode(31,OUTPUT);

pinMode(32,OUTPUT);

pinMode(33,OUTPUT);

pinMode(2,INPUT_PULLUP);

pinMode(7,OUTPUT);

write(0);

write(180);

setIntensity(7);

}

void loop() {

push=digitalRead(2);

if(push==0){

dist=100;

actS=!actS;

actB=!actB;

cs2=!cs2;

c2=!c2;

msgact=!msgact;

systemF=false;

time1=millis();

time2=millis();

time3=millis();

time4=millis();

analogWrite(7,0);

RGBoff();

}

if(dist>0 && dist<50 && distOk == true && systemF == false){

actS=!actS;

actB=!actB;

cs2=!cs2;

c2=!c2;

msgact=!msgact;

time1=millis();

time2=millis();

time3=millis();

time4=micros();

systemF=true;}

if(c==0 && coff == false && actB==true){

analogWrite(7,277);

RGBon();}

if((millis() - time1 )>= 100 && c==0 && coff==false && actB==true){

analogWrite(7,0);

coff=!coff;

RGBoff();

time1=millis();}

if((millis() - time1 )>= 350 && c==0 && coff==true&& actB==true){

c++;

coff=!coff;

time1=millis();}

if(c==1 && coff==false&& actB==true){

analogWrite(7,277);

RGBon();}

if((millis() - time1 ) >= 100 && c==1&& coff==false && actB==true){

analogWrite(7,0);

RGBoff();

coff=!coff;

time1=millis();}

if((millis() - time1 )>= 350 && c==1 && coff==true && actB==true){

c++;

coff=!coff;

time1=millis();}

if(c==2 && coff==false && actB==true){

analogWrite(7,277);

RGBon();}

if(millis() - time1 >= 100 && c==2 && coff==false && actB==true){

analogWrite(7,0);

coff=!coff;

time1=millis();}

if((millis() - time1 )>= 150 && c==2 && coff==true && actB==true){

c++;

coff=!coff;

time1=millis();}

if(c==3 && coff==false && actB==true){

analogWrite(7,277);

RGBon();}

if(millis() - time1 >= 100 && c==3 && coff==false && actB==true){

analogWrite(7,0);

RGBoff();

coff=!coff;

time1=millis();}

if((millis() - time1 )>= 150 && c==3 && coff==true && actB==true){

c++;

coff=!coff;

time1=millis();}

if(c==4 && coff==false && actB==true){

analogWrite(7,277);

RGBon();}

if(millis() - time1 >= 100 && c==4 && coff==false && actB==true){

analogWrite(7,0);

RGBoff();

coff=!coff;

time1=millis();}

if((millis() - time1 )>= 350 && c==4 && coff==true && actB==true){

c=0;

coff=!coff;

time1=millis();}

// Servos

if(c2==true && cs2==true && c22==0 && actS==true){

if(R==150 && L==30){time2=millis();c22++;c2=false;}

write(R);

write(L);

if(millis()-time2 >=5 && c22==0){

L--;R++;

time2=millis();

}

}

if((millis()-time2 >=1000) && c2==false && actS==true){

c2=true;time2=millis();

}

if(c2==true && cs2==true && c22==1 && actS==true){

if(R==30 && L==150){time2=millis();c22=0;}

write(R);

write(L);

if(millis()-time2 >=5 && c22==1){

L++;R--;

time2=millis();

}

}

//matrix

if (i < ancpal * msg.length() + m1.width() - 1 - esp && ok == true && Mprint == false && msgact==true){

i++;m1.fillScreen(LOW); ok=false;

l = i / ancpal;

x = (m1.width() - 1) - i % ancpal;

if(i >= ancpal * msg.length() + m1.width() - 1 - esp){i=0;}

}

if ( x + ancpal - esp >= 0 && l >= 0 && ok == false && Mprint == false && msgact==true) {

if ( l < msg.length() ) {

drawChar(x, 1, msg[l], HIGH, LOW, 1);

}

l--;

x -= ancpal;

}

else if(Mprint == false && msgact==true) {

ok=true; time3=millis(); Mprint=true;m1.write();}

if(millis() - time3 >= w8 && ok ==true && Mprint==true && msgact==true){

Mprint=false;}

//Ultrasonido

if(systemF == false){

if(micros()-time4>=10 && c5== 0){

digitalWrite(ultra,LOW);

c5++;

time4=micros();}

if(micros()-time4>=10 && c5== 1){

digitalWrite(ultra,HIGH);

c5++;

time4=micros();}

if(micros()-time4>=20 && c5== 2){

digitalWrite(ultra,LOW);

c5=0;tomas++;

dura=pulseIn(eco,HIGH);

distancia=int(dura/58);

distancia=(0.9775*distancia)-0.2461;

if(tomas<=10){dist+=distancia;distOk=false;}

if(tomas==10){dist=dist/10; distOk=true;tomas=0;}

}}

}

void RGBon(){

analogWrite(30,140);

analogWrite(31,140);

analogWrite(32,140);

analogWrite(33,140);

}

void RGBoff(){

analogWrite(30,0);

analogWrite(31,0);

analogWrite(32,0);

analogWrite(33,0);

}

Monitorización

Otra de las cosas que nos permite hacer un Arduino, es la composición de dispositivos que puedan monitorear situaciones que requieran ser evaluadas, para que luego, puedan ser intervenidas y solucionadas. Un ejemplo de monitorización, es un sistema manejado por un programa que tenga la capacidad de examinar y analizar la eficiencia energética dentro de una empresa o casa.

De esta forma, se consigue controlar el consumo eléctrico y volverlo mucho más rentable. Si quieres practicar con un proyecto de este tipo podrás realizar un registrador de datos de energía. Para ello tendrás que elegir una placa Arduino UNO o Arduino Nano R3, un módulo MicroSD, una placa integrada periférica DS3231MPMB1, un transformador de 9 voltios, resistencias y cables para la conexión.

Vas a necesitar escribir los siguientes códigos:

/* Conexiones de hardware / uso de pines

Placa Arduino Nano

Pines 0 y 1 -> Conexión serie/USB

SD - Se comunica por SPI

MOSI -> pin 11

MISO -> pin 12

CLK -> pin 13

CS (SS) -> Pin 10

Reloj RTC DS3231 - por I2C/Wire

SDA -> pin A4

SCL -> pin A5

Monitoreo de señales analógicas

Tensión: // Es necesario para medir tensión que se genera la conectar el transformador

pin A2

Corriente: // Mide los parámetros eléctricos.

pin A3

Senales de info/control

LED "latido" -> pin 2

LED "errorSD" -> pin 3

Pines reservados para futuras mejoras

LED (reservado) -> pin 4

Boton "arriba" |

Boton "abajo" |

Boton "izquierda" | -> array (teclado analógico) conectado a A1

Boton "derecha" |

Boton "enter" |

*/

#include <SPI.h> //Comunicación con periferícos SPI

#include <Wire.h> //Comunicación I2C

#include <SdFat.h> //Librería SdFat en lugar de la de arduino por estar optimizada - Manejo de tarjeta SD -

SdFat SD; //Línea necesaria para compatibizar el programa escrito para SD.h (libreria original)

#include <TimeLib.h>

#include <DS1307RTC.h>

#include <EmonLib.h>

// Declaración de etiquetas para los pines utilizados

// pines reservados para futuras mejoras

//const int pinLedReservado = 4; // LED reservado

//const int pinTeclado = A1; // Pin para teclado analógico

// Pin para selección de la SD

const int CS_SD = 10;

// Pin para led´s

const int pinLedLatido = 2;

const int pinErrorSD = 3;

// Pines analógicos, señales analógicas

const int pinTension = 2; // Pin (analógico) para la medición (Valor de tensión) de la energía eléctrica.

const int pinCorriente = 3; // Pin (analógico) para la medición (Valor de Corriente) de la energía eléctrica.

const unsigned long intervaloLectura = 2000; //intervalo de lectura de sensores

const unsigned long intervaloEscrituraSD = 300; //intervalo de escritura de datos en la SD

EnergyMonitor emon1;

// Variable para indicar presencia de tarjeta SD

boolean presenciaSD = 0;

// Sincro de reloj

const int intervaloSincro = 300; //Intervalo de sincronización del reloj arduino con el RTC

void setup() {

begin(9600);

voltage(pinTension, 169.17, 1.7);

current(pinCorriente, 60.6);

pinMode(pinLedLatido, OUTPUT); //salida donde se conecta el led "latido"

pinMode(pinErrorSD, OUTPUT); //salida donde se conecta el led "errorSD"

//Inicializa tarjeta SD

if (!SD.begin(CS_SD)) {

presenciaSD = 0;

digitalWrite(pinErrorSD, HIGH);

}

else {

presenciaSD = 1; //tarjeta detectada

digitalWrite(pinErrorSD, LOW); // apaga led error SD

}

//Icicializamos el reloj y el tiempo

setTime(RTC.get());

ajustarReloj();

setSyncProvider(RTC.get);

setSyncInterval(intervaloSincro);

}

void loop() {

static unsigned long millisPrevio = intervaloLectura;

static unsigned long millisPrevio2 = intervaloEscrituraSD;

static float energia = 0;

static float energiaParcial = 0;

static boolean ledLatido = LOW;

static String datos;

unsigned long millisActual = millis();

if (millisActual - millisPrevio >= intervaloLectura){

println(F("Fecha/Hora; Potencia activa; Potencia aparente; Tensión; Corriente; Factor de potencia"));

print(timeLabel());

print(" ");

calcVI(20,1000); // Calcula todos los parámetros. No de medias ondas (cruces), time-out

serialprint();

energiaParcial = energiaParcial + ((emon1.realPower * (intervaloLectura/1000))/3600000); //calculamos la energía acumulada (desde el ultimo grabacion SD) expresado en KWh.

energia = energia + ((emon1.realPower * (intervaloLectura/1000))/3600000); //calculamos la energía acumulada (desde el ultimo reset) expresado en KWh.

print(F("\nEnergía consumida: "));

println(energia, 4);

datos = timeLabel(); // coloca la marca de tiempo en el String datos

datos = datos + ", " + String(emon1.Vrms, 2); //va agregando todos los valores medidos al string

datos = datos + ", " + String(emon1.Irms, 2);

datos = datos + ", " + String(emon1.realPower, 1);

datos = datos + ", " + String(emon1.powerFactor, 2);

datos = datos + ", " + String(emon1.apparentPower, 1);

datos = datos + ", " + String(energiaParcial, 4);

datos = datos + ", " + String(energia, 4);

if (ledLatido == LOW) {

ledLatido = HIGH;

}

else {

ledLatido = LOW;

}

digitalWrite(pinLedLatido, ledLatido);

millisPrevio = millisActual;

}

if (millisActual - millisPrevio2 >= intervaloEscrituraSD * 1000UL){ //procede a grabar los datos

if (grabarDatosSD(datos)) { //si hubo error al grabar devuelve 1

digitalWrite(pinErrorSD, HIGH); //como hubo error en el grabado se enciende el led error SD

}

energiaParcial = 0; //Vuelve a cero el contador de energía

millisPrevio2 = millisActual;

}

}

String timeLabel() {

time_t t = now();

String tiempoActual = String('0');

tiempoActual = year(t);

if (month(t) < 10)

tiempoActual = String(tiempoActual + '-' + '0' + month(t));

else

tiempoActual = String(tiempoActual + '-' + month(t));

if (day(t) < 10)

tiempoActual = String(tiempoActual + '-' + '0' + day(t));

else

tiempoActual = String(tiempoActual + '-' + day(t));

tiempoActual = String(tiempoActual + ' ');

if (hour(t) < 10)

tiempoActual = String(tiempoActual + '0' + hour(t));

else

tiempoActual = String(tiempoActual + hour(t));

tiempoActual = String(tiempoActual + ':');

if (minute(t) < 10)

tiempoActual = String(tiempoActual + '0' + minute(t) + ':');

else

tiempoActual = String(tiempoActual + minute(t) + ':');

if (second(t) < 10)

tiempoActual = String(tiempoActual + '0' + second(t));

else

tiempoActual = String(tiempoActual + second(t));

return tiempoActual;

}

boolean grabarDatosSD(String data) {

time_t t = now();

String date = String('0'); //Se crea string

date = year(t);

if (month(t) < 10)

date = String(date + '0' + month(t));

else

date = String(date + month(t));

if (day(t) < 10)

date = String(date + '0' + day(t));

else

date = String(date + day(t));

date = String(date + ".csv");

char fileName[13];

toCharArray(fileName, 13); //convertimos el string a un array de caracteres

if (!presenciaSD) {

return 1;

}

if (SD.exists(fileName)) { //Si existe el archivo "fileName" lo abrimos

File nrg_log = SD.open(fileName, FILE_WRITE);

if (nrg_log) { //Si el archivo se abre correctamente escribimos en el...

println(data);

close();

digitalWrite(pinErrorSD, HIGH);

delay(100);

digitalWrite(pinErrorSD, LOW);

delay(50);

digitalWrite(pinErrorSD, HIGH);

delay(100);

digitalWrite(pinErrorSD, LOW);

return 0;

}

else {

return 1;

}

}

else { //si no existe el archivo "nrg_log.cvs" se lo genera

File nrg_log = SD.open(fileName, FILE_WRITE);

if (nrg_log) { //Si el archivo se abre correctamente escribimos

print(F("Archivo de registro de mediciones de energía eléctrica. Creado: "));

println(timeLabel());

println('\n');

println(F("Fecha/Hora, Tensión, Corriente, Potencia activa, Factor de potencia, Potencia aparente, Energía de intervalo, Energía consumida total"));

println(data);

close();

digitalWrite(pinErrorSD, HIGH);

delay(100);

digitalWrite(pinErrorSD, LOW);

delay(50);            // Doble parpadeo de LED para indicar que grabamos a la SD

digitalWrite(pinErrorSD, HIGH);

delay(100);

digitalWrite(pinErrorSD, LOW);

return 0;

}

else {

return 1;

}

}

}

Lista de los mejores proyectos Arduino que puedes programar tu mismo para aprender a desarrollar hardware y software libre

Es importante considerar que Arduino puede ser utilizado para diseñar una gran magnitud de trabajos excepcionales.

A continuación, te mostramos una lista de los proyectos Arduino más destacados para que puedas hacer tus propios dispositivos y programas de código abierto:

Sensor para encender luces

En el primer lugar, tenemos a este asombroso dispositivo para tu habitación. Con tan solo el uso de sensores para una placa Arduino y una tira LED y la programación adecuada, puedes crear un sensor de presencia. Este proyecto los vas a poder aplicar en el exterior de tu casa, en un lugar en donde reciba una fuente directa de energía solar. Para este proyecto necesitarás una Arduino Nano R3, un sensor de luz y de movimiento, una tira de LED, baterías, un módulo MOSFET y un panel solar con salida USB de 14,5 cm por 14,5 cm.

Luego tendrás que ingresar este código para hacer funcionar sensor:

int Light  =  5 ;             // pin para LED

int PIRpower  =  13 ;         // alimentación al sensor PIR

int PIR  =  12 ;              // entrada del sensor PIR

int PIRState  =  LOW ;        // estado de PIR

int LDR  =  2 ;               // entrada de LDR

int LDRpower  =  3 ;          // alimentación al sensor LDR

int LDRState  =  LOW ;        // estado de LDR

Noche ()

{

escritura digital ( PIRpower , ALTA );

retraso ( 2000 );

Serial . println ( "A. Sensor PIR ENCENDIDO, detectando movimiento" );

retraso ( 3000 );

PIRState =  digitalRead ( PIR );

retraso ( 500 );

Serial . println ( "B. Lectura del sensor de movimiento, desactivando el PIR" );

digitalWrite ( PIRpower , BAJO );

retraso ( 500 );

if ( PIRState  ==  HIGH ) {

println(">>>>>>>>>> MOTION DETECTED");

delay(500);

println("I. switching Light ON");

delay(500);

digitalWrite(Light, HIGH);

println("II. Light 100%");

delay(15000); // esperar 15 sec

analogWrite(Light, 175);

println("II. Light 70%");

delay(15000); // esperar 15 sec

analogWrite(Light, 100);

println("II. Light 40%");

delay(15000); // esperar 15 sec

analogWrite(Light, 50);

println("II. Light 20%");

delay(500);

println(".......... Wait 5 seconds..........");

delay(1000);

}else {

println(">>>>>>>>>> MOTION NOT DETECTED");

delay(500);

println(".......... Wait 10 seconds..........");

delay(10000); // esperar 10 sec

}

}

void setup() {

pinMode(Light, OUTPUT); // declare LED as output

pinMode(PIRpower, OUTPUT); // declare PIRpower as output

pinMode(LDRpower, OUTPUT); // declare LDRpower as output

pinMode(LDR, INPUT); // declare LDR sensor as input

pinMode(PIR, INPUT); // declare PIR sensor as input

digitalWrite(PIRpower, LOW);

digitalWrite(LDRpower, LOW);

begin(9600);

}

void loop(){

println(".......... START..........");

digitalWrite(LDRpower, HIGH);

println("1. LDRpower ON, reading LDR sensor");

delay(3000);

LDRState = digitalRead(LDR);

delay(500);

println("2. LDR status read, turning LDRpower OFF");

delay(500);

println("3. LDRpower OFF");

digitalWrite(LDRpower, LOW);

delay(500);

if (LDRState == HIGH){ // Lee el estado del LDR

println(">>>>>>>>>> LUCES DETECTADAS!!!");

delay(500);

println("Switch ON Light 20%");

analogWrite(Light, 50);

Night();

println(".......... Restarting..........");

} else{

println(">>>>>>>>>> BRIGHTNESS DETECTED");

delay(500);

digitalWrite(Light, LOW);

println(".......... Waiting 5mins..........");

delay(60000); // Espera un minuto

println(".......... Waiting 4mins..........");

delay(60000); // Espera un minuto

println(".......... Waiting 3mins..........");

delay(60000); // Espera un minuto

println(".......... Waiting 2mins..........");

delay(60000); // Espera un minuto

println(".......... Waiting 1mins..........");

delay(60000); // Espera un minuto

println(".......... Restarting..........");

}

Dado electrónico

Con una placa Arduino se pueden hacer proyectos de gran provecho y de entretenimiento, por ejemplo, un dado eléctrico para jugar con tu familia cualquier juego de mesa. Puedes conectar LED de siete segmentos a una placa y configurarlo para mostrar números del 1 al 6, al tan solo presionar un botón para que pueda generar aleatoriamente un número. Con una placa Arduino Nano R3, una pantalla led, una resistencia de 330 ohmios, un interruptor de palanca de tipo SPDT y cables necesarios para la conexión podrás crear este proyecto.

Los códigos que necesitarás son:

int a  =  6 ;

int b  =  7 ;

int c  =  10 ;

int d  =  8 ;

int e  =  9 ;

int f  =  4 ;

int g  =  5 ;

número largo =  0 ;

salida larga =  0 ;

int displayTime  =  5000 ;

int sensorPin  =  0 ;

int sensorValue  =  0 ;

int switchIn  =  12 ;

int analogPin  =  A3 ;

int switchStatus ;

unsigned long  previousMillis  =  0 ;

unsigned long currentMillis = 0;

const long interval = 400;

int minus = 0;

void setup()

{

initialize();

pinMode(a, OUTPUT);

pinMode(b, OUTPUT);

pinMode(c, OUTPUT);

pinMode(d, OUTPUT);

pinMode(e, OUTPUT);

pinMode(f, OUTPUT);

pinMode(g, OUTPUT);

pinMode(switchIn, INPUT);

currentMillis = millis();

}

void initialize()

{

digitalWrite(a, LOW);

digitalWrite(b, LOW);

digitalWrite(c, LOW);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

}

void zero()

{

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

}

void one()

{

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

}

void two()

{

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

}

void three()

{

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

}

void four()

{

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

}

void five()

{

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

}

void six()

{

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

}

void shuffle()

{

digitalWrite(g, LOW);

digitalWrite(a, HIGH);

delay(100);

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

delay(100);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

delay(100);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

delay(100);

digitalWrite(d, LOW);

digitalWrite(e, HIGH);

delay(100);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

delay(100);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

digitalWrite(a, HIGH);

delay(100);

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

delay(100);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

delay(100);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

delay(100);

digitalWrite(d, LOW);

digitalWrite(e, HIGH);

delay(100);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

delay(100);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

digitalWrite(a, HIGH);

delay(100);

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

delay(100);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

delay(100);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

delay(100);

digitalWrite(d, LOW);

digitalWrite(e, HIGH);

delay(100);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

delay(100);

digitalWrite(f, LOW);

}

void sensorCheck()

{

sensorValue = analogRead(sensorPin);

}

void switchCheck()

{

switchStatus = analogRead(analogPin);

if (switchStatus >100)

{

randomSeed(analogRead(4));

number = random(1, 7);

switchStatus = digitalRead(switchIn);

}

else

{

randomSeed(analogRead(4));

output = random(1,17);

if (output == 1)

{

number = 0;

}

else if (output == 2 || output == 3)

{

number = 1;

}

else if (output == 4 || output == 5 || output == 6)

{

number = 2;

}

else if (output == 7 || output == 8 || output == 9 || output == 10)

{

number = 3;

}

else if (output == 11 || output == 12 || output == 13)

{

number = 4;

}

else if (output == 14 || output == 15)

{

number = 5;

}

else if (output == 16)

{

number = 6;

}

}

}

void loop()

{

currentMillis = millis();

if (currentMillis - previousMillis >= interval)

{

previousMillis = currentMillis;

sensorCheck();

while (sensorValue < 600)

{

shuffle();

sensorCheck();

switchCheck();

}

if (number == 0)

{

zero();

}

else if (number == 1)

{

one();

}

else if (number == 2)

{

two();

}

else if (number == 3)

{

three();

}

else if (number == 4)

{

four();

}

else if (number == 5)

{

five();

}

else if (number == 6)

{

six();

}

}

}

Reloj Despertador

También vas a poder elaborar un despertador avanzado para que lo conectes a Internet y de esta manera programar tus citas con mayor facilidad. Al conectar tu despertador a tu red, este se hará cargo de despertarte en caso de que recibas un correo importante. Vas a necesitar una placa Arduino UNO, un reloj de tipo RTC, un interruptor pulsador de 12 mm, y una pantalla LCD con retroalimentación de 16 por 2. También deberás elegir un kit de cables y conectores para unir todos los elementos.

A continuación, te detallamos los códigos que debes ingresar:

#include <Pushbutton.h> // part of arduino library. Search in manage libraries.

#include <EEPROM.h>

#include <RTClib.h>

#include <LCD.h>

#include <LiquidCrystal.h>

#include <LiquidCrystal_I2C.h>

#include <Wire.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address

RTC_DS1307 RTC;

const int DS1307 = 0x68;

const int lightAlarm_pin = 6;

const int selectButton_pin = 5;

const int nextButton_pin = 4;

const int upButton_pin = 3;

const int downButton_pin = 2;

const int alarmButton_pin = A1;

const boolean alarmSystem_pin = 7;

const boolean timerLightOnLED_pin = 8;

Pushbutton selectButton(selectButton_pin);

Pushbutton nextButton(nextButton_pin);

Pushbutton upButton(upButton_pin);

Pushbutton downButton(downButton_pin);

Pushbutton alarmButton(alarmButton_pin);

enum mainSelection {

ALARM_ON_OFF = 1, //switching alarm on or off            = 1

ALARM_SEASON, //change the time of starting          = 2

ALARM_SET, //to set the alarm start and stop time = 3

CLOCK_SET, //to set time and date                 = 4

AlARM_AUTO, //Light timer automatic or manual      = 5

RUN_CLOCK //Reading and displaying time and date = 6

};

enum mainSelection key = RUN_CLOCK;

int alarmMinuteStart = 1;

int alarmHourStart = 1;

int alarmMinuteStop = 2;

int alarmHourStop = 2;

int alarmPlus = 0;

boolean alarmOnOff = false;

boolean autoManual = false;

int alarmOffSet = 6;

int yr = 2000;

int mo = 1;

int dy = 1;

int hr = 0;

int mn = 0;

int setYr = 00;

int setMo = 1;

int setDy = 1;

int setHr = 0;

int setMn = 0;

boolean daylightSaving = true;

boolean aBlink = true;

const int loopCheckMax = 80; //duration of the loops in the settings

int loopCheck = 0;

unsigned long clockDisplayCheck = millis(); //counter in the loop

int lcdDisplayCheck = 0; //counter for controling the time the lcd will be on

boolean timerLight = false; //set the relais for the alarm lights

int timerLightStage = 0;

void setup() {

pinMode(lightAlarm_pin, OUTPUT);

pinMode(alarmSystem_pin, OUTPUT);

pinMode(timerLightOnLED_pin, OUTPUT);

begin(16, 2);

begin();

begin();

begin(9600);

clockRunning();

clear();

on();

displayLcdFirstLine( 2);

readTimeNow();

displayTimeNow(2);

readAlarm();

}

void loop() {

key = RUN_CLOCK;

lightManualyOnOff();

lcdLight();

if ((millis() - clockDisplayCheck) > 500) //Reading and displaying date and time continuesly every 0.5 second

{

clockRunning();

clockDisplayCheck = millis();

readTimeNow();

displayTimeNow(2);

readAlarm();

displayLcdFirstLine( 0); //Basic display line

alarmActivate(); //setting the alarm

timerLightOnOff();

}

if (selectButton.getSingleDebouncedPress())

{

lcdDisplayCheck = 0; // lcd back to maximum time

lcdLight(); //turns lcd on

mainKeySelection(); // reads keySelection ALARM_ON_OFF,ALARM_SEASON,ALARM_SET,CLOCK_SET,RUN_CLOCK,

// setCursor(0, 0);

switch (key) {

case ALARM_ON_OFF:

setTimerOnOff();

break;

case ALARM_SEASON:

setTimerPlus();

break;

case ALARM_SET:

setHr = alarmHourStop;

setMn = alarmMinuteStop;

setCursor(0, 0);

print("Set alarm time ");

presetClockTime(alarmOffSet);

if (setHr == 12) {

setHr = 11;

setMn = 59;

}

saveAlarmSet();

// readAlarm();

break;

case CLOCK_SET:

presetClockDate();

readTimeNow();

setHr = hr;

setMn = mn;

setCursor(0, 0);

print("Set clock time ");

presetClockTime(0);

saveClock();

break;

case AlARM_AUTO:

alarmAutoManual();

break;

}

}

}

void clockRunning() {

if (!RTC.begin() || !RTC.isrunning()) {

while (!selectButton.getSingleDebouncedPress ()) {

if (digitalRead(alarmSystem_pin) == LOW) digitalWrite(alarmSystem_pin, HIGH);

else digitalWrite(alarmSystem_pin, LOW);

delay(100);

}

}

}

void lcdLight() {

if (alarmButton.getSingleDebouncedPress()) lcdDisplayCheck = 0;

lcdDisplayCheck++;

if (lcdDisplayCheck < 900) { //times half a second the display will be on

display();

backlight();

}

else {

noDisplay();

noBacklight();

if (lcdDisplayCheck > 2000) lcdDisplayCheck = 900;

}

void timerLightOnOff() {

if (timerLight) {

digitalWrite(lightAlarm_pin, LOW); // the relay activates to zero

digitalWrite(timerLightOnLED_pin, HIGH);

} else {

digitalWrite(lightAlarm_pin, HIGH);

digitalWrite(timerLightOnLED_pin, LOW);

}

}

void lightManualyOnOff() {

if (!alarmOnOff) {

if (nextButton.getSingleDebouncedPress()) {

print (timerLight);

timerLight = !timerLight;

}

}

}

void readTimeNow() {

DateTime now = RTC.now();

yr = now.year();

mo = now.month();

dy = now.day();

hr = now.hour();

mn = now.minute();

}

void readAlarm() {

alarmHourStop = EEPROM.read(0);

delay(15);

alarmMinuteStop = EEPROM.read(1);

delay(15);

alarmPlus = EEPROM.read(2);

delay(15);

alarmOnOff = EEPROM.read(3);

delay(50);

autoManual = EEPROM.read(4);

delay(50);

if (alarmHourStop <= alarmOffSet) alarmHourStop = alarmOffSet + 1;

alarmHourStart = alarmHourStop - alarmPlus;

alarmMinuteStart = alarmMinuteStop; //calculating the timer stopping time

if (alarmAutoManual) automaticTimer();

dayLightSaving();

}

void alarmActivate() {

if (alarmOnOff) {

if ((hr - alarmHourStart) == 0)

{

if (mn >= alarmMinuteStart)

timerLight = true;

else timerLight = false;

}

else if (hr - alarmHourStop == 0)

{

if ( mn <= alarmMinuteStop)

timerLight = true;

else timerLight = false;

}

else if ((alarmHourStop - hr < alarmPlus) && (alarmHourStop - hr >= 1)) timerLight = true;

else timerLight = false;

}

// else timerLight = false;

}

void displayTimeNow(int digitBlink) {

char textDT[16];

sprintf(textDT, "%02d:%02d %02d/%02d/%04d", hr, mn, dy, mo, yr); //puts int variabels in the rigth format into textDT

setCursor(0, 1);

print(textDT); //prints in four and two digits

setCursor(digitBlink, 1);

if (aBlink) lcd.print(" "); else lcd.print(":");

aBlink = !aBlink;

}

void displayLcdFirstLine( int blinking) {

if (blinking > 0) {

for (int i = 1; i <= blinking; i++) {

setCursor(0, 0);

print(" ");

setCursor(0, 0);

delay(400);

print("TIMER-1.00 ");  //Titel

setCursor(11, 0);

if (alarmOnOff == false) lcd.print("off~ "); else lcd.print(" on~ ");

setCursor(15, 0);

if (autoManual) lcd.print("A"); else lcd.print(alarmPlus);

delay(400);

}

} else {

setCursor(0, 0);

print("TIMER-1.00"); //Titel

setCursor(10, 0);

if (alarmOnOff == false) lcd.print(" off~ "); else lcd.print(" on~ ");

setCursor(15, 0);

if (autoManual) lcd.print("A"); else lcd.print(alarmPlus);

delay(400);

}

}

void mainKeySelection() {

unsigned long started = millis();

delay(10);

unsigned long moment;

const int laps = 2000;

int state = 0;

int lapTime = 0;

while (selectButton.isPressed()) {

moment = millis();

delay(100);

lapTime = moment - started;

if (((lapTime) >= (0 * laps)) && ((lapTime) <= (1 * laps))) state = 1;

else if (((lapTime) >= (1 * laps)) && ((lapTime) <= (2 * laps))) state = 2;

else if (((lapTime) >= (2 * laps)) && ((lapTime) <= (3 * laps))) state = 3;

else if (((lapTime) >= (3 * laps)) && ((lapTime) <= (4 * laps))) state = 4;

else if (((lapTime) >= (4 * laps)) && ((lapTime) <= (5 * laps))) state = 5;

else if (((lapTime) >= (5 * laps)) && ((lapTime) <= (6 * laps))) state = 6;

delay(500);

switch (state) {

case 1:

setCursor(0, 1);

print("set alarm on/off");

break;

case 2:

setCursor(0, 1);

print("Timer hours set ");

break;

case 3:

setCursor(0, 1);

print("Alarm time set! ");

break;

case 4:

setCursor(0, 1);

print("Clock time set! ");

break;

case 5:

setCursor(0, 1);

print("Alarm man/auto");

break;

case 6:

setCursor(0, 1);

print("Back to the menu");

break;

}

if ((lapTime) > (6 * laps)) { //back into the same routine

started = moment;

}

}

key = state;// keySelection ALARM_ON_OFF,ALARM_SEASON,ALARM_SET,CLOCK_SET,AlARM_AUTO,RUN_CLOCK,

}

void setTimerOnOff() {

boolean setAlarmOnOff = alarmOnOff;

setCursor(0, 0);

print("switch it now ");

setCursor(0, 1);

print("Timer is: ");

setCursor(11, 1);

if (alarmOnOff == false) lcd.print("[off] "); else lcd.print("[on] ");

while (!selectButton.getSingleDebouncedPress ()) {

if (upButton.getSingleDebouncedPress()

setCursor(11, 1);

if (setAlarmOnOff == false) lcd.print("[off] "); else lcd.print("[on] ");

delay(30);

}

if (alarmOnOff != setAlarmOnOff) {

write(3, setAlarmOnOff);

delay(15);

}

}

void setTimerPlus() {

readAlarm();

int setAlarmPlus = alarmPlus;

setCursor(0, 0);

print("stop time: 00:00");

if (alarmHourStop < 10) lcd.setCursor(12, 0); else lcd.setCursor(11, 0);

print(alarmHourStop);

if (alarmMinuteStop < 10) lcd.setCursor(15, 0); else lcd.setCursor(14, 0);

print(alarmMinuteStop);

setCursor(0, 1);

print("hours on:      ");

setCursor(11, 1);

print(setAlarmPlus);

while (!selectButton.getSingleDebouncedPress ()) {

setCursor(11, 1);

if (alarmHourStop > 6) { /

if (upButton.isPressed() && (setAlarmPlus < 6)) setAlarmPlus++;

if (downButton.isPressed() && (setAlarmPlus > 1)) setAlarmPlus--;

print(setAlarmPlus);

}

else {

setCursor(0, 0);

print("Set alarm stop "); // in case the alarm is set too early in the day. Minimum after 6 am

setCursor(0, 1);

print("timer first !!!!");

}

delay(250);

}

if (alarmPlus != setAlarmPlus) {

write(2, setAlarmPlus);

delay(15);

}

}

void presetClockDate() {

int loops = 20;

boolean pBlink = false;

const int loopMax = 25; //Moment of refreshing the LCD

int loopCheck = 0; //to controll if if there is any interaction

enum YMD {YEAR = 1, MONTH, DAY};

enum YMD YrMoDy = YEAR;

setYr = (yr - 2000); setMo = mo; setDy = dy; setHr = hr; setMn = mn;

setCursor(0, 0);

print("Set Year // Date");

while (loopCheck < loopCheckMax) {

delay(10);

loops++;

if (YrMoDy == YEAR) {

setYear();

loopCheck = 0;

}

if (YrMoDy == MONTH) {

setMonth();

loopCheck = 0;

}

if (YrMoDy == DAY) {

setDay();

loopCheck = 0;

}

if (YrMoDy > DAY) loopCheck = loopCheckMax;

if (nextButton.getSingleDebouncedPress()) YrMoDy = YrMoDy + 1;

if (loops > loopMax) {

setCursor(0, 1);

print("Y-00 Mo-00 Dy-00");

if (setYr < 10) {

setCursor(2, 1);

print("00");

setCursor(3, 1);

} else lcd.setCursor(2, 1);

print(setYr);

if (setMo < 10) {

setCursor(8, 1);

print("00");

setCursor(9, 1);

}

else lcd.setCursor(8, 1);

print(setMo);

if (setDy < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

else lcd.setCursor(14, 1);

print(setDy);

if (YrMoDy == YEAR)lcd.setCursor(2, 1);

if (YrMoDy == MONTH)lcd.setCursor(8, 1);

if (YrMoDy == DAY)lcd.setCursor(14, 1);

if (pBlink)lcd.print(" ");

pBlink = !pBlink;

loops = 0;

loopCheck++;

}

if (selectButton.getSingleDebouncedPress ()) {

loopCheck = loopCheckMax;

}

delay(10);

}

setCursor(0, 0);

print(" ");

setCursor(0, 1);

print(" ");

}

void presetClockTime(int StartingPointHour) {

int loops = 20;

boolean pBlink = false;

const int loopMax = 25; //Moment of refreshing the LCD

int loopCheck = 0; //to controll if if there is any interaction

// setHr = hr; setMn = mn;

enum HM {HOUR = 1, MINUTE};

enum HM HrMn = HOUR;

while (loopCheck < loopCheckMax) {

delay(10);

loops++;

if (HrMn == HOUR) { //Setting hour function

setHr = hourReturn(setHr, StartingPointHour);

delay(10);

loopCheck = 0;

}

if (HrMn == MINUTE) { //Setting minute function

setMn = minuteReturn(setMn);

delay(10);

loopCheck = 0;

}

if (HrMn > MINUTE)loopCheck = loopCheckMax;

if (nextButton.getSingleDebouncedPress()) HrMn = HrMn + 1;

if (loops > loopMax) { // displaying whit a long interval

setCursor(0, 1);

print("hour:00 minu:00");

if (setHr < 10) {

setCursor(5, 1);

print("00");

setCursor(6, 1);

} else lcd.setCursor(5, 1);

print(setHr);

if (setMn < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

else lcd.setCursor(14, 1);

print(setMn);

if (HrMn == HOUR)lcd.setCursor(5, 1);

if (HrMn == MINUTE)lcd.setCursor(14, 1);

if (pBlink)lcd.print(" ");

pBlink = !pBlink;

loops = 0;

loopCheck++;

}

if (selectButton.getSingleDebouncedPress ()) { //breaks the loop by the select button or by time lapsed

loopCheck = loopCheckMax;

}

delay(10);

}

setCursor(0, 0);

print(" ");

setCursor(0, 1);

print(" ");

}

int lastDayOfTheMonth(int setMonth) {

switch (setMonth) {

case 1: //January

return 31;

break;

case 2: //February

if ((setYr % 4) == 0) return 29; else return 28;

break;

case 3: //March

return 31;

break;

case 4: //April

return 30;

break;

case 5: //May

return 31;

break;

case 6: //June

return 30;

break;

case 7: //Juli

return 31;

break;

case 8: //August

return 31;

break;

case 9: //September

return 30;

break;

case 10: //October

return 31;

break;

case 11: //November

return 30;

break;

case 12: //December

return 31;

break;

}

}

void setYear() {

int teller = 0;

if (setYr < 18) setYr = 17;

while (upButton.isPressed()) {

if (setYr < 99) setYr++;

setCursor(2, 1);

print(setYr);

teller++;

if (teller > 7) delay(100); else delay(250);

}

while (downButton.isPressed()) {

if (setYr > 17) setYr--;

setCursor(2, 1);

print(setYr);

teller++;

if (teller > 7) delay(100); else delay(250);

}

}

void setMonth() {

while (upButton.isPressed()) {

if (setMo < 12) setMo++;

setCursor(8, 1);

if (setMo < 10) {

setCursor(8, 1);

print("00");

setCursor(9, 1);

}

print(setMo);

delay(250);

}

while (downButton.isPressed()) {

if (setMo > 1) setMo--;

setCursor(8, 1);

if (setMo < 10) {

setCursor(8, 1);

print("00");

setCursor(9, 1);

}

print(setMo);

delay(250);

}

}

void setDay() {

int teller = 0;

int maxD = maxDay();

while (upButton.isPressed()) {

if (setDy < maxD) setDy++;

setCursor(14, 1);

if (setDy < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

print(setDy);

teller++;

if (teller > 7) delay(100); else delay(250);

}

while (downButton.isPressed()) {

if (setDy > 1) setDy--;

setCursor(14, 1);

if (setDy < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

print(setDy);

teller++;

if (teller > 7) delay(100); else delay(250);

}

}

int maxDay() {

switch (setMo) {

case 1:

return 31;

case 2:

if ((setYr % 4) == 0)return 29; else return 28;

case 3:

return 31;

case 4:

return 30;

case 5:

return 31;

case 6:

return 30;

case 7:

return 31;

case 8:

return 31;

case 9:

return 30;

case 10:

return 31;

case 11:

return 30;

case 12:

return 31;

}

}

int hourReturn(int setHour, int startingPoint) {

if (setHour < startingPoint) setHour = startingPoint;

while (upButton.isPressed()) {

if (setHour < 24) setHour++;

setCursor(5, 1);

if (setHour < 10) {

setCursor(5, 1);

print("00");

setCursor(6, 1);

}

print(setHour);

delay(200);

}

while (downButton.isPressed()) {

if (setHour > startingPoint) setHour--;

setCursor(5, 1);

if (setHour < 10) {

setCursor(5, 1);

print("00");

setCursor(6, 1);

}

print(setHour);

delay(200);

}

return setHour;

}

int minuteReturn(int setMinute) {

while (upButton.isPressed()) {

if (setMinute < 60) setMinute++;

setCursor(14, 1);

if (setMinute < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

print(setMinute);

delay(200);

}

while (downButton.isPressed()) {

if (setMinute > 1) setMinute--;

setCursor(14, 1);

if (setMinute < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

print(setMinute);

delay(200);

}

return setMinute;

}

void saveClock() {

boolean saveNew = true;

setCursor(0, 1);

print("00:00 00/00/2000"); //setHr is still two digets

if (setHr < 10) lcd.setCursor(1, 1); else lcd.setCursor(0, 1);

print(setHr);

if (setMn < 10) lcd.setCursor(4, 1); else lcd.setCursor(3, 1);

print(setMn);

if (setDy < 10) lcd.setCursor(7, 1); else lcd.setCursor(6, 1);

print(setDy);

if (setMo < 10) lcd.setCursor(10, 1); else lcd.setCursor(9, 1);

print(setMo);

setCursor(14, 1);

print(setYr);

setCursor(0, 0);

print("save clock?: yes");

while (!selectButton.getSingleDebouncedPress ()) {

setCursor(13, 0);

if (saveNew == false) lcd.print("no "); else lcd.print("yes");

if ((upButton.getSingleDebouncedPress() == 1) || (downButton.getSingleDebouncedPress() == 1))saveNew = !saveNew;;

delay(80);

}

if (saveNew = true) {

int setSec = 0;

int setWkDy = 1;

delay(100);

// The following codes transmits the data to the RTC

beginTransmission(DS1307);

write(byte(0));

write(decToBcd(setSec));

write(decToBcd(setMn));

write(decToBcd(setHr));

write(decToBcd(setWkDy)); //not in use

write(decToBcd(setDy));

write(decToBcd(setMo));

write(decToBcd(setYr)); //has to be two digits

write(byte(0));

endTransmission();

// Ends transmission of data

}

delay(100);

}

byte decToBcd(byte val) {

return ((val / 10 * 16) + (val % 10));

}

void saveAlarmSet() {

boolean saveNew = true;

setCursor(0, 1);

print("hour:00 minu:00");

if (setHr < 10) {

setCursor(5, 1);

print("00");

setCursor(6, 1);

} else lcd.setCursor(5, 1);

print(setHr);

if (setMn < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

else lcd.setCursor(14, 1);

print(setMn);

setCursor(0, 0);

print("save Alarm?: yes");

while (!selectButton.getSingleDebouncedPress ()) {

setCursor(13, 0);

if (saveNew == false) lcd.print("no "); else lcd.print("yes");

if ((upButton.getSingleDebouncedPress() == 1) || (downButton.getSingleDebouncedPress() == 1))saveNew = !saveNew;;

delay(80);

}

if (saveNew = true) {

write(0, setHr);

delay(15);

write(1, setMn);

delay(15);

}

delay(100);

}

void alarmAutoManual() {

boolean autoManualNew = autoManual; //using this variable makes the display less restless

setCursor(0, 1);

print("Lights off 00:00");

if (alarmHourStop < 10) {

setCursor(11, 1);

print("00");

setCursor(12, 1);

} else lcd.setCursor(11, 1);

print(alarmHourStop);

if (alarmMinuteStop < 10) {

setCursor(14, 1);

print("00");

setCursor(15, 1);

}

else lcd.setCursor(14, 1);

print(alarmMinuteStop);

setCursor(0, 0);

if (autoManualNew)lcd.print("Timer: automatic"); else lcd.print("Timer: manual ");

while (!selectButton.getSingleDebouncedPress ()) {

if (upButton.getSingleDebouncedPress() || downButton.getSingleDebouncedPress()) {

autoManualNew = !autoManualNew;

setCursor(0, 0);

if (autoManualNew)lcd.print("Timer: automatic"); else lcd.print("Timer: manual ");

}

delay(80);

}

if (autoManualNew != autoManual) {

write(4, autoManualNew);

delay(20);

}

}

void automaticTimer() {

switch (mo) {

case 1:

alarmOffSet = 6;

break;

case 2:

alarmOffSet = 5;

break;

case 3:

alarmOffSet = 5;

break;

case 4:

alarmOffSet = 4;

break;

case 5:

alarmOffSet = 3;

break;

case 6:

alarmOffSet = 2;

break;

case 7:

alarmOffSet = 2;

break;

case 8:

alarmOffSet = 3;

break;

case 9:

alarmOffSet = 4;

break;

case 10:

alarmOffSet = 5;

break;

case 11:

alarmOffSet = 6;

break;

case 12:

alarmOffSet = 6;

break;

}

}

void dayLightSaving() {

boolean daylightSavingNew = false;

switch (yr) {

case 2017:

if ((mo == 3 && dy >= 26) || (mo > 3 && mo < 10) || (mo == 10 && dy < 29)) daylightSavingNew = true;

break;

case 2018:

if ((mo == 3 && dy >= 25) || (mo > 3 && mo < 10) || (mo == 10 && dy < 28)) daylightSavingNew = true;

break;

case 2019:

if ((mo == 3 && dy >= 31) || (mo > 3 && mo < 10) || (mo == 10 && dy < 27)) daylightSavingNew = true;

break;

case 2020:

if ((mo == 3 && dy >= 29) || (mo > 3 && mo < 10) || (mo == 10 && dy < 25)) daylightSavingNew = true;

break;

case 2021:

if ((mo == 3 && dy >= 28) || (mo > 3 && mo < 10) || (mo == 10 && dy < 31)) daylightSavingNew = true;

break;

case 2022:

if ((mo == 3 && dy >= 27) || (mo > 3 && mo < 10) || (mo == 10 && dy < 30)) daylightSavingNew = true;

break;

case 2023:

if ((mo == 3 && dy >= 26) || (mo > 3 && mo < 10) || (mo == 10 && dy < 29)) daylightSavingNew = true;

break;

case 2024:

if ((mo == 3 && dy >= 31) || (mo > 3 && mo < 10) || (mo == 10 && dy < 27)) daylightSavingNew = true;

break;

case 2025:

if ((mo == 3 && dy >= 30) || (mo > 3 && mo < 10) || (mo == 10 && dy < 26)) daylightSavingNew = true;

break;

case 2026:

if ((mo == 3 && dy >= 29) || (mo > 3 && mo < 10) || (mo == 10 && dy < 25)) daylightSavingNew = true;

break;

case 2027:

if ((mo == 3 && dy >= 28) || (mo > 3 && mo < 10) || (mo == 10 && dy < 31)) daylightSavingNew = true;

break;

case 2028:

if ((mo == 3 && dy >= 26) || (mo > 3 && mo < 10) || (mo == 10 && dy < 29)) daylightSavingNew = true;

break;

case 2029:

if ((mo == 3 && dy >= 25) || (mo > 3 && mo < 10) || (mo == 10 && dy < 28)) daylightSavingNew = true;

break;

}

if (daylightSavingNew != daylightSaving) {

if (hr > 2) {

if (daylightSavingNew) hr = hr + 1;

if (!daylightSavingNew) hr = hr - 1;

daylightSaving = daylightSavingNew;

}

}

}

Chaqueta de instrucción para ciclistas

Cabe mencionar, que existen diferentes tipos de placas para diseñar dispositivos singulares. Tal como una chaqueta con luces que pueda indicar qué dirección tomar al desplazarnos por las carreteras de la ciudad. Con una placa especial para la ropa, puedes crear este dispositivo e insertarlo en tu chaqueta sin ningún problema.

En este proyecto necesitarás una placa Arduino del modelo LilyPad, también un soporte para baterías, 5 leds blancos para la versión de la placa, sensor ultrasónico HC-SR04, un tablero para botones sparkfun y un zumbador. Además, deberás contar con kits de conectores y cables que sirvan para la unión de los componentes.

El código que deberás ingresar a tu placa de Arduino es:

#include <Ultrassonico.h>

#define Echo 10

#define Trigger 11

#define zumbador 3

Ultrassonico ultra ( Echo ,  Trigger );  // Eco, disparador

configuración vacía () {

Serial . comenzar ( 9600 );

pinMode ( 4 , SALIDA );

pinMode ( 5 , SALIDA );

pinMode ( zumbador , SALIDA );

}

bucle vacío () {

uint16_t cm = ultra . centimetrosUltra ();

De serie . println ( cm );

si (( cm > 80 ) y ( cm < 130 ))

{

tono ( zumbador , 3000 );

escritura digital( 4 , BAJO );

escritura digital ( 5 , BAJO );

retraso ( 500 );

ni uno( zumbador );

demora( 500 );

}

si (( cm > 30 ) y  ( cm < 50 ))

{

tono ( zumbador , 2000 );

escritura digital ( 4 , ALTA );

escritura digital ( 5, BAJO );

demora ( 100 );

ni uno( zumbador );

demora ( 100 );

}

si ( cm < 30 )

{

tono ( zumbador , 1000 );

digitalWrite ( 4 , BAJO );

escritura digital ( 5 , ALTA );

retraso ( 30 );

noTone ( zumbador );

retraso ( 30 );

}

retraso ( 50 );

}

Semáforo avanzado

Para este dispositivo se utilizan varios pulsadores que indiquen la cercanía de un coche. De este modo, su función se activa y se desactiva, cambiando de color verde mientras un auto se encuentre lejos, y rojo mientras algún coche se esté cercando a un cruce. Para llevar adelante este proyecto necesitarás una placa YÚN, una Arduino UNO, un reloj en tiempo real, resistencias, leds, un módulo de 433 MHz, una tarjeta de memoria SD, un sensor ultrasónico HC- SR04 y cables.

Luego tendrás que pasar a la programación ingresando:

#define RedLED 5

#define OrangeLED 6

#define GreenLED 7

#define rx_pin 9

#include <VirtualWire.h> // Para los módulos RF 433 MHz

#include <TimeAlarms.h> // Alarma

#include <Wire.h>

#include "RTClib.h"

#include <Process.h>

long UnixTime_green_1 ;

long UnixTime_red_1;

long UnixTime_green_2;

long UnixTime_red_2;

long s_till_orange;

RTC_DS3231 rtc;

char StringReceived[22];

boolean i;

int interval = 5; // in seconds

int distance; // in cm

void setup() {

begin();

//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

begin(9600);

begin(); // Initialize Bridge

vw_setup(2000); // Bits per sec

vw_set_rx_pin ( rx_pin );

vw_rx_start ();

Alarma . timerRepeat ( intervalo , UpdateTrafficLData );  // siguiente semáforo verde, en rojo...

Alarma . timerRepeat ( 1 , PrintCurrentTime );

pinMode ( GreenLED , SALIDA );

pinMode ( OrangeLED , SALIDA );

pinMode ( LED rojo , SALIDA );

digitalWrite ( GreenLED , BAJO );

digitalWrite ( OrangeLED , BAJO );

digitalWrite ( LED rojo , BAJO );

Serial . println ( "Instalación finalizada" );

}

bucle vacío () {

Alarma . retraso ( 0 );

RF_Listen ();

}

void RF_Listen  () {

uint8_t buf [ VW_MAX_MESSAGE_LEN ];

uint8_t buflen  =  VW_MAX_MESSAGE_LEN ;

si ( vw_get_message ( buf ,  y buflen ))  {

int a ;

para ( a  =  0 ;  a  <  buflen ;  a ++ )  {

StringReceived [ a ] =  char ( buf [ a ]);

}

sscanf ( StringReceived , "% d" ,  & distancia );

MySQL_UpdateDistance ();

Serial . print ( "Distancia:" );

Serial . println ( distancia );

}

memset ( StringReceived ,  0 ,  sizeof (  StringReceived ));

}

void UpdateTrafficLData ()  {

DateTime ahora  =  rtc . ahora ();

si ( i  ==  1 )  {

UnixTime_green_1 =  ahora . unixtime ()  +  intervalo  +  1 ;

UnixTime_red_1 =  ahora . unixtime ()  +  2  *  intervalo  +  1 ;

UnixTime_green_2 =  ahora . unixtime ()  +  3  *  intervalo  +  1 ;

UnixTime_red_2 =  ahora . unixtime ()  +  4  *  intervalo  +  1 ;

MySQL_UpdateTrafficLData ();

i =  0 ;

}

más si  ( i  ==  0 )  {

UnixTime_red_1 =  ahora . unixtime ()  +  intervalo  +  1 ;

UnixTime_green_1 = now.unixtime() + (2 * interval) + 1;

UnixTime_red_2 = now.unixtime()+ 3 * interval + 1;

UnixTime_green_2 = now.unixtime() + 4 * interval + 1;

MySQL_UpdateTrafficLData();

i = 1;

}

print(" Green_1 at ");

print(UnixTime_green_1);

print(" Red_1 at ");

print(UnixTime_red_1);

print(" Green_2 at ");

print(UnixTime_green_2);

print(" Red_2 at ");

println(UnixTime_red_2);

}

void MySQL_UpdateTrafficLData() {

long dataArray[4]={UnixTime_green_1, UnixTime_red_1, UnixTime_green_2,UnixTime_red_2};

Process p;

begin("/mnt/sda1/MySQL_UpdateTrafficLData.php");

for (int b = 0; b < 4; b++){

addParameter(String(dataArray[b]));

}

run();

while (p.available() > 0) {

char c = p.read();

print(c);

}

flush();

}

void MySQL_UpdateDistance(){

Process p;

begin("/mnt/sda1/MySQL_UpdateDistance.php");

addParameter(String(distance));

run();

while (p.available() > 0) {

char c = p.read();

print(c);

}

flush();

}

void PrintCurrentTime ()  {

DateTime ahora  =  rtc . ahora ();

SetLEDsTrafficL ();

Serial . imprimir ( ahora . hora (), DEC );

Serial . imprimir ( ':' );

Serial . imprimir ( ahora . minuto (), DEC );

Serial . imprimir ( ':' );

Serial . imprimir ( ahora . segundo (), DEC );

Serial . imprimir ( "" );

Serial . println ( ahora . unixtime ());

}

void SetLEDsTrafficL  ()  {

DateTime ahora  =  rtc . ahora ();

s_till_orange =  UnixTime_red_1  -  ahora . unixtime ();

si ( i  ==  0 )  {

digitalWrite ( GreenLED , BAJO );

digitalWrite ( OrangeLED , BAJO );

escritura digital ( LED rojo , ALTO );

}

if ( i  ==  1  &&  s_till_orange  <=  3 )  {

digitalWrite ( GreenLED , BAJO );

digitalWrite ( OrangeLED , ALTA );

digitalWrite ( LED rojo , BAJO );

}

if ( i  ==  1  &&  s_till_orange  >  3 )  {

digitalWrite ( GreenLED , HIGH );

digitalWrite ( OrangeLED , BAJO );

digitalWrite ( LED rojo , BAJO );

}

}

Alarma para casa

La construcción de una alarma para el hogar es uno de los proyectos más asequibles y llamativos. Este dispositivo se utiliza para detectar cualquier tipo de presencia que desee invadir nuestro hogar. Si conectamos una placa Arduino con algunos detectores de movimiento, luces y un medidor de sonido, podremos construir nuestra propia alarma. Además de tu placa de Arduino UNO vas a necesitar un protoboard genérico, un sensor ultrasónico, un zumbador y un kit de cables y conectores para unir toda la instalación.

Deberás escribir en el IDE de Arduino los siguientes comandos:

const int  TrigPin  =  2 ;

const int  EchoPin  =  3 ;

const int  Datos  =  8 ;

flotar cm ;

configuración vacía ()

{

Serial . comenzar ( 9600 );

pinMode ( TrigPin , SALIDA );

pinMode ( EchoPin , ENTRADA );

pinMode ( Datos , SALIDA );

}

bucle vacío ()

{

digitalWrite ( TrigPin , BAJO );

delayMicroseconds ( 2 );

digitalWrite ( TrigPin , ALTO );

delayMicroseconds ( 10 );

digitalWrite ( TrigPin , BAJO );

cm =  pulseIn ( EchoPin ,  ALTO )  /  0 ;  // El tiempo de eco se convierte en cm

cm =  ( int ( cm  *  0 ))  /  100.0 ;

Serial . println ();

if ( cm < 15 ) { // si está colocando el sensor detrás de la puerta será necesario usar  ">" sysmbole en lugar de ">" ps. Hay que tener en cuenta que la puerta esté a menos de 15 cm de distancia con el sensor

digitalWrite ( Datos , ALTO );

retraso ( 200 );

Serial . print ( "Puerta cerrada" );

}

demás

{

digitalWrite ( Datos , BAJO );

retraso ( 200 );

Serial . print ( "Puerta abierta" );

}

retraso ( 200 );

}

Cámara de espionaje

Para muchos, poder colocar elementos en espacios tan pequeños como una taza es un gran desafío, y mucho más cuando nos referimos a una cámara espía. Si quieres llevar a cabo este proyecto, deberás insertar un módulo acelerómetro para activar y tomar una fotografía a través del movimiento del objeto utilizado.

Los componentes y suministros que serán necesarios en este proyecto deben incluir una placa Arduino Micro, resistencia de fotocélula CdS, ojo de puerta y una placa Raspberry Pi con su pantalla LED. Conectores y el objeto donde deseas instalar la cámara espía.

Cuando tengas todos los elementos anteriores tendrás que ingresar este código:

long previousMillis  =  0 ;

tiempo de calibración  largo =  5000 ;

long startMillis  =  0 ;

int sensorMin  =  1024 ;

int sensorMax  =  0 ;

int promedio  =  0 ;

int umbral  =  5 ;

bool lastState  =  true ;

bool isClosed  =  true ;

#include "Keyboard.h"

configuración vacía () {

Serial . comenzar ( 9600 );

Serial . println ( " Configuración " );

Teclado . comenzar ();

startMillis =  millis ();

}

bucle vacío () {

unsigned largo  currentMillis  =  millis ();

int sensorValue  =  analogRead ( A0 );

//Serial.println(sensorValue);

si ( currentMillis - startMillis <  calibrationtime )  {

// guarda la última vez que hiciste parpadear el LED

// imprime el valor que leíste:

int ElapsedTime  =  currentMillis  -  startMillis ;

Serial . println (tiempo transcurrido );

Serial . println ( sensorMin );

Serial . println ( sensorMax );

if ( sensorValue <  sensorMin ) {

sensorMin =  sensorValue ;

promedio =  ( sensorMin  +  sensorMax  ) / 2;

}

if ( sensorValue >  sensorMax ) {

sensorMax =  sensorValue ;

promedio =  ( sensorMin  +  sensorMax  ) / 2 ;

}

retraso ( 100 );

}

else {

if ( sensorValue >  promedio  +  umbral ) {

isClosed =  false ;

if ( lastState ! =  isClosed ) {

}

}

else {

isClosed =  true ;

if ( lastState ! =  isClosed) {

Teclado . imprimir ( "" );

}

}

lastState =  isClosed ;

retraso ( 100 );

}

}

Jardín automatizado

Si quieres asegurar que tus plantas se encuentren en buen estado al estar fuera de tu casa, puedes considerar crear un sistema automático de riego y temperatura, para que puedas mantener tu jardín cuidado en todo momento. 

Para este tipo de proyectos, es preciso incluir sensores que puedan detectar el cambio de clima, para así, adecuar el sistema. Para que puedas regar y monitorear tus plantas del jardín vas a necesitar el modelo Nano R3 de Arduino, un sensor de temperatura y humedad de la versión DHT11, un relé genérico y conectores generales para la unión.

Vas a tener que programar la placa ingresando:

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#include <DHT.h>

#define DHTPIN 2 // a qué pin estamos conectados

#define DHTTYPE DHT11 // DHT 11

#define OLED_RESET 4

Pantalla Adafruit_SSD1306 ( OLED_RESET );

DHT DHT ( DHTPIN ,  DHTTYPE );

Información de cadena ;

riego booleano = falso ,  estado = falso ;

configuración vacía ()

{

Alambre . comenzar ();

dht . comenzar (); // inicializar dht

pantalla . comenzar ( SSD1306_SWITCHCAPVCC , 0x3C );

Serial . comenzar ( 9600 );

}

void displayTempHumid(){

delay(2000);

// Lectura de humedad y temperatura

float h = dht.readHumidity();

float t = dht.readTemperature();

float f = dht.readTemperature(true);

if (isnan(h) || isnan(t) || isnan(f)) {

clearDisplay(); // clearing the display

setTextColor(WHITE); //setting the color

setTextSize(1); //set the font size

setCursor(5,0); //set the cursor coordinates

print("Failed to read from DHT sensor!");

return;

}

clearDisplay();

setTextColor(WHITE);

setTextSize(1);

setCursor(0,0);

print("Humidity: ");

print(h);

print(" %\t");

setCursor(0,10);

pantalla . print ( "Temperatura:" );

pantalla . imprimir ( t );

pantalla . imprimir ( "C" );

pantalla . setCursor ( 0 , 20 );

pantalla . print ( "Temperatura:" );

pantalla . imprimir ( f );

pantalla . imprimir ( "F" );

}

bucle vacío ()

{

displayTempHumid ();

pantalla . display ();

}

Sistema de calefacción inteligente

La placa Arduino UNO es una de las más usadas para proyectos ventajosos y de gran escala. Una de las facultades de tener un sistema avanzado es que puedes manejar la calefacción de tu casa desde tu smartphone y en cualquier lugar donde te encuentres. Incorporando un sensor de temperatura, algunas resistencias, junto con una conexión estable a la estructura de una placa, tendrás la función de este espectacular sistema.

Además de la placa deberás tener para este sistema de calefacción un tablero para relés de 8 canales de 5v, un actuador termoeléctrico MT8-230-NC y un kit de cables que te ayudarán a unir los pines con los elementos mencionados.

Cuando estés listo, solo tendrás que ingresar en el IDE estos códigos:

#include <avr / wdt.h>

#define VALVE_TIME 3000L

#ifdef FAST_MODE

#define PUMP_MAINTENANCE_TIME 108000L

#else

#define PUMP_MAINTENANCE_TIME 1300000L

#endif

#define PUMP_ACTIVATION_TIME 5000L

#define COOLDOWN_TIME 18000L

#include "./Devices.h"

struct Zone {

String name;

Valve valve;

Thermostat thermostat;

};

// Configuración del bloque

#define HEATER_PIN 4

#define FU_PUMP_PIN 5

#define LIVING_VALVE 7

#define KITCHEN_VALVE 6

#define DINING_VALVE 3

#define LIVING_THERMO 8

#define KITCHEN_THERMO 9

#define DINING_THERMO 11

#define NO_ZONE_THERMO 10

#define HEATING_LED 12

#define INDICATION_LED 13

#define NR_ZONES 3

Zone Zones[NR_ZONES] = { {"Living Room", Valve(LIVING_VALVE, "Living Valve"),  Thermostat(LIVING_THERMO, "Living Thermostat")},

{"Kitchen Area", Valve(KITCHEN_VALVE,"Kitchen Valve"), Thermostat(KITCHEN_THERMO,"Kitchen Thermostat")},

{"Dining Room", Valve(DINING_VALVE, "Dining Valve"),  Thermostat(DINING_THERMO, "Dining Thermostat")}};

// Fin de la configuración del bloque

LED iLED(INDICATION_LED, "Indicator LED");

LED hLED(HEATING_LED, "Heating LED");

Manipulator CV(HEATER_PIN, "CV Heater");

Pump FUPump(FU_PUMP_PIN, "Floor Unit Pump");

Thermostat ZonelessThermo(NO_ZONE_THERMO, "Zoneless Thermostat");

void printConfiguration() {

println("------ Board Configuration: ---------");

Print();

Print();

Print();

Print();

Print();

for(int i=0; i<NR_ZONES; i++) {

print("Zone["); Serial.print(i+1);

print("]: "); Serial.println(Zones[i].name);

Serial . imprimir ( "-" ); Zonas [ i ]. válvula . Imprimir ();

Serial . imprimir ( "-" ); Zonas [ i ]. termostato . Imprimir ();

}

Serial . println ( "-------------------------------------" );

}

{

publico :

estados de enumeración {

ralentí ,

sobre ,

enfriarse

};

privado :

// vars

estados _State ;

unsigned long  cooldownCount ;

publico :

//constructor

StateMAchine () {

_State =  inactivo ;

}

// Getter

estados const &  operator () ()  const  {

return _State ;

}

// Setter

operador void () ( estados const y  newState )  {

printTimeStamp ();

Serial . print ( ": cambio de estado de [" );

Imprimir ();

_State =  newState ;

print("] to [");

Print();

println("]");

// deal with transition actions to the new state

switch(_State)

{

case idle:

Off();

Off(); // stop heating

Off();

allValvesOff();

break;

case on:

On();

On();

break;

case cooldown:

Off();

allValvesOn();

break;

default:

println("WARNING Unhandled State transition");

break;

}

}

void doProcessingActions() {

switch(_State) {

case on:

onProcessing();

break;

case cooldown:

coolDownProcessing();

break;

case idle:

idleProcessing();

break;

default:

println("ERROR Unhandled State");

break;

}

}

void setCoolDownNeeded() {

cooldownCount = COOLDOWN_TIME;

}

bool whileCoolDownNeeded() {

if (cooldownCount > 0) {

cooldownCount--;

}

return checkCoolDownNeeded();

}

bool checkCoolDownNeeded() {

return (cooldownCount> 0);

}

void Print() {

switch(_State)

{

case idle:

print("idle");

break;

case on:

print("on");

break;

case cooldown:

print("cooldown");

break;

}

}

};

State CVState;

void setup()

{

begin(115200);

printTimeStamp();

print(": ");

#ifdef FAST_MODE

println("CV Zone Controller started in TestMode!\n"

" - Board time runs ca 50 times faster\n"

" - Pump maintenance cycle runs ever 3 hours instead once per 36 hours");

#else

println("CV Zone Controller started. Time stamps (dd:hh:mm:ss)");

#endif

println(" - Time stamps format (dd:hh:mm:ss)");

printConfiguration();

wdt_enable(WDTO_1S);

}

void loop()

{

#ifdef FAST_MODE

delay(2);

#else

delay(100);

#endif

Alternate();

Update();

for (int i=0; i<NR_ZONES; i++) {

Zones[i].valve.Update();

}

wdt_reset();

doProcessingActions();

}

void onProcessing() {

if (ProcessThermostats()) {

if (FloorPumpingAllowed()) {

On();

}

else {

Off();

}

}

else if ( CVState.checkCoolDownNeeded() ) {

CVState(State::cooldown);

}

else {

CVState(State::idle);

}

}

void coolDownProcessing() {

Alternate();

if (HeatingRequested()) {

CVState(State::on);

}

else {

if ( CVState.whileCoolDownNeeded() ) {

if (FloorPumpingAllowed()) {

On();

} else {

Off();

}

}

else {

CVState(State::idle);

}

}

}

void idleProcessing()

{

if (HeatingRequested()) {

CVState(State::on);

}

else

{

if ( FUPump.doMaintenanceRun()) {

if (FUPump.IsOff()) {

if ( allValvesOpen() == false ) {

printTimeStamp(); Serial.println(": Start daily cycle for Floor Unit Pump; open valves: ");

allValvesOn();

}

if (FloorPumpingAllowed()) {

printTimeStamp(); Serial.println(": Start daily cycle for Floor Unit Pump; start pump ");

On();

}

}

}

else if (FUPump.IsOn()) {

printTimeStamp(); Serial.println(": Stop daily cycle for Floor Unit Pump; stop pump and close valves");

Off();

allValvesOff();

}

}

}

Disparador para fotografía de alta velocidad

Si eres un fotógrafo de gran potencial que busca captar la atención del público con imágenes fascinantes, puedes hacer uso de un microcontrolador Arduino para tomar una foto óptima a una alta velocidad con tu GoPro. Vas a necesitar una Arduino del modelo MKR1000, luces LEDs genéricas, una protoboard, una resistencia de 221 ohmios, un interruptor pulsador de 12mm del tipo sparkfun y cables de puente.

Todos estos componentes electrónicos deberás unirlos y luego escribir en el IDE lo siguiente:

#include <GoPRO.h>

#define CONNECT_PRESSED 1

#define ON_PRESSED 2

#define CAPTURE_PRESSED 3

char ssid[] = "yourNetwork";

char pass[] = "yourPassword";

const int buttonConnect = A1;

const int buttonOn = A2;

const int buttonCapture = A3;

const int connectLED = 3;

const int onLED = 4;

const int captureLED = 5;

bool onStatus = true;

bool captureStatus = false;

void setup() {

pinMode(buttonConnect, INPUT_PULLUP);

pinMode(buttonOn, INPUT_PULLUP);

pinMode(buttonCapture, INPUT_PULLUP);

pinMode(connectLED, OUTPUT);

pinMode(onLED, OUTPUT);

pinMode(captureLED, OUTPUT);

digitalWrite(connectLED, LOW);

digitalWrite(onLED, HIGH);

digitalWrite(captureLED, LOW);

}

void loop() {

switch (isButtonPressed()) {

default: break;

case CONNECT_PRESSED:

if (!GoPRO.checkConnection()) {

if (GoPRO.begin(ssid, pass)) {

digitalWrite(connectLED, HIGH);

}

else {

digitalWrite(connectLED, LOW);

}

}

else {

digitalWrite(connectLED, HIGH);

}

break;

case ON_PRESSED:

if (GoPRO.checkConnection()) {

onStatus = !onStatus;

if (onStatus) {

if (GoPRO.turnOn())

digitalWrite(onLED, HIGH);

}

else {

if (GoPRO.turnOff())

digitalWrite(onLED, LOW);

}

}

break;

case CAPTURE_PRESSED:

if (GoPRO.checkConnection()) {

captureStatus = !captureStatus;

if (captureStatus) {

if (GoPRO.startCapture())

digitalWrite(captureLED, HIGH);

}

else {

if (GoPRO.stopCapture())

digitalWrite(captureLED, LOW);

}

}

break;

}

delay(100);

}

int isButtonPressed() {

if (digitalRead(buttonConnect) == LOW) return 1;

else if (digitalRead(buttonOn) == LOW) return 2;

else if (digitalRead(buttonCapture) == LOW) return 3;

else return 0;

}

Sensor de luces ambientales

La programación de este proyecto es sencilla, por lo que no queríamos dejar a un lado la idea de tener tus propias luces ambientales para cualquier ambiente de tu casa. Vas a lograr que se reflejen en la pared, dando un estilo único. Deberás tener una placa Pro Mini 328 de tipo SparkFun, el sensor de luz ambiental TEMT6000, soporte para baterías AA, cables y conectores en general.

Ingresa este código para programar tu Arduino:

int temt6000Pin = A0;

float light;

int light_value;

void setup() {

begin(112500);

pinMode(temt6000Pin, INPUT); //data pin for ambientlight sensor

pinMode(13, OUTPUT);

}

void loop() {

int light_value = analogRead(temt6000Pin);

light = light_value * 0.0976;// percentage calculation

println(light);

delay(100);

if (light_value > 1000) {

digitalWrite(13, HIGH);

}

else {digitalWrite(13,LOW);}

}

Robot que dobla la ropa

Este proyecto es categorizado entre los más complejos que pueden ser desarrollados, es un invento bastante creativo y exclusivo, que también, requiere de mucho más dinero que un diseño común.  Con la ayuda de una placa Arduino, puedes crear un robot y programarlo con un mecanismo para que doble tu ropa o realice cualquier otra tarea. Deberás tener una Arduino 101, un brazo robótico que lo podrás conseguir por alrededor de 25€, cuatro motores micro servo, un módulo de Ethernet y un móvil Android.

Luego, vas a tener que ejecutar estos comandos en el entorno de programación:

#include <Servo.h>

// Used pins

#define GRIPPER_SERVO 9

#define UPPER_JOINT_SERVO 6

#define LOWER_JOINT_SERVO 5

#define BASE_ROTATOR_JOINT_SERVO 3

#define GRIPPER_OPEN 0

#define GRIPPER_CLOSED_SOFT 1

#define GRIPPER_CLOSED_MEDIUM 2

#define GRIPPER_CLOSED_HARD 3

// Gripper configuration

#define GRIPPER_OPEN_ANGLE 150 // The angle of the servo in different positions

#define GRIPPER_CLOSED_SOFT_ANGLE 75 // Closing with low force (less stressful on the servo)

#define GRIPPER_CLOSED_MEDIUM_ANGLE 65 // Closing with medium force (slightly stressful on the servo)

#define GRIPPER_CLOSED_HARD_ANGLE 0 // Closing with high force (quite stressful on the servo, it will also heat up)

#define SERVO_ANGLE_UPPER_LIMIT 170

#define SERVO_ANGLE_LOWER_LIMIT 0

#define SERVO_ANGLE_RESTING 90

#define MIN_MOVEMENT_DELAY 2

// Commands

#define MOVE_GRIPPER 'G'

#define MOVE_ARM 'A'

Servo gripper, upperJoint, lowerJoint, baseRotator;

unsigned int movementDelay = 5;

int gripperState;

int targetUpperJointAngle;

int targetLowerJointAngle;

int targetBaseRotatorAngle;

float currentUpperJointAngle, currentLowerJointAngle, currentBaseRotatorAngle;

float upperJointStep, lowerJointStep, baseRotatorStep;

unsigned long lastStepTime = 0;

void setup() {

begin(115200);

attach(GRIPPER_SERVO);

attach(UPPER_JOINT_SERVO);

attach(LOWER_JOINT_SERVO);

attach(BASE_ROTATOR_JOINT_SERVO);

gripperState = GRIPPER_CLOSED_SOFT;

targetUpperJointAngle = currentUpperJointAngle = 140;

targetLowerJointAngle = currentLowerJointAngle = 45;

targetBaseRotatorAngle = currentBaseRotatorAngle = 85;

moveGripper(gripperState);

moveTo(targetUpperJointAngle, targetLowerJointAngle, targetBaseRotatorAngle);

}

void loop() {

if (Serial1.available() > 0) {

char command = Serial1.read();

if (command == MOVE_GRIPPER) {

updateGripperState();

moveGripper(gripperState);

delay(250);

}

else if (command == MOVE_ARM) {

updateArmMovement();

}

}

if (millis() - lastStepTime >= movementDelay) {

if (targetUpperJointAngle != round(currentUpperJointAngle)) currentUpperJointAngle -= upperJointStep;

if (targetLowerJointAngle != round(currentLowerJointAngle)) currentLowerJointAngle -= lowerJointStep;

if (targetBaseRotatorAngle != round(currentBaseRotatorAngle)) currentBaseRotatorAngle -= baseRotatorStep;

moveTo(currentUpperJointAngle, currentLowerJointAngle, currentBaseRotatorAngle);

printPosition();

lastStepTime = millis();

}

}

void updateGripperState() {

if (Serial1.available() > 0)

gripperState = Serial1.parseInt();

else

return;

clearSerial1();

}

void updateArmMovement() {

int mDelay;

if (Serial1.available() > 0)

mDelay = Serial1.parseInt();

else

return;

int upperJointAngle;

if (Serial1.available() > 0)

upperJointAngle = Serial1.parseInt();

else

return;

int lowerJointAngle;

if (Serial1.available() > 0)

lowerJointAngle = Serial1.parseInt();

else

return;

int baseRotatorAngle;

if (Serial1.available() > 0)

baseRotatorAngle = Serial1.parseInt();

else

return;

clearSerial1();

movementDelay = mDelay >= MIN_MOVEMENT_DELAY ? mDelay : MIN_MOVEMENT_DELAY;

targetUpperJointAngle = upperJointAngle;

targetLowerJointAngle = lowerJointAngle;

targetBaseRotatorAngle = baseRotatorAngle;

upperJointStep = (currentUpperJointAngle - targetUpperJointAngle) / 100;

lowerJointStep = (currentLowerJointAngle - targetLowerJointAngle) / 100;

baseRotatorStep = (currentBaseRotatorAngle - targetBaseRotatorAngle) / 100;

}

void clearSerial1() {

while (Serial1.available() > 0)

read();

}

void moveGripper(int state) {

switch (state) {

case GRIPPER_OPEN:

write(GRIPPER_OPEN_ANGLE);

break;

case GRIPPER_CLOSED_SOFT:

write(GRIPPER_CLOSED_SOFT_ANGLE);

break;

case GRIPPER_CLOSED_MEDIUM:

write(GRIPPER_CLOSED_MEDIUM_ANGLE);

break;

case GRIPPER_CLOSED_HARD:

write(GRIPPER_CLOSED_HARD_ANGLE);

break;

}

}

void moveTo(int upperJointAngle, int lowerJointAngle, int baseRotatorAngle) {

write(upperJointAngle);

write(lowerJointAngle);

write(baseRotatorAngle);

}

void printPosition() {

print(movementDelay);

print(" ");

print(gripperState);

print(" ");

print(round(currentUpperJointAngle));

print(" ");

print(round(currentLowerJointAngle));

print(" ");

println(round(currentBaseRotatorAngle));

}

Lector de huellas dactilares

La seguridad de nuestro hogar es algo fundamental en nuestro día a día, y con el uso de una placa Arduino Nano R3 podemos instalar un sistema de acceso muy particular que funcione por medio de nuestra huella. Para este proyecto, se requiere de algunas baterías, transistores y un sensor de huella dactilar, de esta forma, podrás colocar tu sistema de seguridad en cualquier parte de tu casa.

Mira los códigos que debes escribir en el IDE para programar la placa:

#include <Adafruit_Fingerprint.h>

#include <SoftwareSerial.h>

uint8_t getFingerprintEnroll(int id);

// pin #2 is IN from sensor (GREEN wire)

// pin #3 is OUT from arduino (WHITE wire)

SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

void setup()

{

begin(9600);

println("fingertest");

begin(57600);

if (finger.verifyPassword()) {

println("Found fingerprint sensor!");

} else {

println("Did not find fingerprint sensor :(");

while (1);

}

}

void loop()

{

println("Type in the ID # you want to save this finger as...");

int id = 0;

while (true) {

while (! Serial.available());

char c = Serial.read();

if (! isdigit(c)) break;

id *= 10;

id += c - '0';

}

print("Enrolling ID #");

println(id);

while (! getFingerprintEnroll(id) );

}

uint8_t getFingerprintEnroll(int id) {

int p = -1;

println("Waiting for valid finger to enroll");

while (p != FINGERPRINT_OK) {

p = finger.getImage();

switch (p) {

case FINGERPRINT_OK:

println("Image taken");

break;

case FINGERPRINT_NOFINGER:

println(".");

break;

case FINGERPRINT_PACKETRECIEVEERR:

println("Communication error");

break;

case FINGERPRINT_IMAGEFAIL:

println("Imaging error");

break;

default:

println("Unknown error");

break;

}

}

p = finger.image2Tz(1);

switch (p) {

case FINGERPRINT_OK:

println("Image converted");

break;

case FINGERPRINT_IMAGEMESS:

println("Image too messy");

return p;

case FINGERPRINT_PACKETRECIEVEERR:

println("Communication error");

return p;

case FINGERPRINT_FEATUREFAIL:

println("Could not find fingerprint features");

return p;

case FINGERPRINT_INVALIDIMAGE:

println("Could not find fingerprint features");

return p;

default:

println("Unknown error");

return p;

}

println("Remove finger");

delay(2000);

p = 0;

while (p != FINGERPRINT_NOFINGER) {

p = finger.getImage();

}

p = -1;

println("Place same finger again");

while (p != FINGERPRINT_OK) {

p = finger.getImage();

switch (p) {

case FINGERPRINT_OK:

println("Image taken");

break;

case FINGERPRINT_NOFINGER:

print(".");

break;

case FINGERPRINT_PACKETRECIEVEERR:

println("Communication error");

break;

case FINGERPRINT_IMAGEFAIL:

println("Imaging error");

break;

default:

println("Unknown error");

break;

}

}

p = finger.image2Tz(2);

switch (p) {

case FINGERPRINT_OK:

println("Image converted");

break;

case FINGERPRINT_IMAGEMESS:

println("Image too messy");

return p;

case FINGERPRINT_PACKETRECIEVEERR:

println("Communication error");

return p;

case FINGERPRINT_FEATUREFAIL:

println("Could not find fingerprint features");

return p;

case FINGERPRINT_INVALIDIMAGE:

println("Could not find fingerprint features");

return p;

default:

println("Unknown error");

return p;

}

p = finger.createModel();

if (p == FINGERPRINT_OK) {

println("Prints matched!");

} else if (p == FINGERPRINT_PACKETRECIEVEERR) {

println("Communication error");

return p;

} else if (p == FINGERPRINT_ENROLLMISMATCH) {

println("Fingerprints did not match");

return p;

} else {

println("Unknown error");

return p;

}

Pequeña estación meteorológica

Utilizando una placa UNO, una pantalla LED Adafruit RGB 16x2 y una protoboard con potenciómetros y resistencias conseguirás instalar en cualquier lugar, un dispositivo que pueda medir e inspeccionar el tiempo. Su programación es muy sencilla, solo debes configurar la pantalla LED para mostrar los datos, e incluso podrás ver los pronósticos para los próximos días.

Los códigos a ingresar son:

#include <LiquidCrystal.h> // Liquid Cristal Mgt Lib

#include <Wire.h> // Gestión de conexiones de cables

#include "cactus_io_BME280_I2C.h" // Gestiona el sensor de temperatura, humedad y presión

// Pines LCD d4, d5, d6, d7 a pines Arduino 5, 4, 3, 2

LiquidCrystal lcd ( 12 ,  11 ,  10 ,  5 ,  4 ,  3 ,  2 );  // Definir PINs LCD

// Crea el objeto BME280

// BME280_I2C bme; // I2C usando 0x77 por defecto

BME280_I2C bme ( 0x76 );   // I2C usando la dirección 0x76

int backLight = 13;

void setup()

{

pinMode(backLight, OUTPUT);

begin(9600);

digitalWrite(backLight, HIGH);

begin(16,2);

clear();

setCursor(0,0);

print("Temperatura Sensore");

setCursor(0,1);

print("XY Celsius");

if (!bme.begin()) { //Check if BME280 is connected and working

println("Could not find a valid BME280 sensor, check wiring!");

while (1);

}

setTempCal(-1);

}

void loop()

{

clear();

readSensor();

setCursor(0,0);

print("P:"); lcd.print(bme.getPressure_MB());

print(" H:"); lcd.print(bme.getHumidity());

setCursor(0,1);

print("T:"); lcd.print(bme.getTemperature_C()); lcd.print("C");

print(" T:"); lcd.print(bme.getTemperature_F()); lcd.println("F");

delay(1000);

}

Araña Robótica

Por otro lado, tenemos a una araña robot, un modelo muy diferente a muchos proyectos Arduino, sin embargo, su preparación es algo más complicada y es necesario contar con ciertos conocimientos. Los materiales que tendrás que usar son una placa Arduino Nano R3, un micro servomotor modelo sg90, compro baterías AA, un controlador de 5 volt Adafruit Trinket y un módulo LED modelo MAX7219.

Luego deberás entrar al entorno de programación IDE de Arduino y escribir estos códigos:

#include <LedControl.h>

#define PIN_EYES_DIN 12

#define PIN_EYES_CS 11

#define PIN_EYES_CLK 10

LedControl lc = LedControl(PIN_EYES_DIN, PIN_EYES_CLK, PIN_EYES_CS, 2);

// rotation

bool rotateMatrix0 = false; // rotate 0 matrix by 180 deg

bool rotateMatrix1 = false; // rotate 1 matrix by 180 deg

// define eye ball without pupil

byte eyeBall[8]={

B00111100,

B01111110,

B11111111,

B11111111,

B11111111,

B11111111,

B01111110,

B00111100

};

byte eyePupil = B11100111;

byte eyeCurrent[8];

int currentX;

int currentY;

int cntLoop = 0;

int cntEffect = 0;

#define MIN -2

#define MAX 2

#define DELAY_BLINK 40

#define EFFECT_ITERATION 4

void setup()

{

shutdown(0,false);

shutdown(1,false);

setIntensity(0,1);

setIntensity(1,1);

clearDisplay(0);

clearDisplay(1);

byte b = B10000000;

for (int c=0; c<=7; c++)

{

for (int r=0; r<=7; r++)

{

setRow(0, r, b);

setRow(1, r, b);

}

b = b >> 1;

delay(50);

}

b = B11111111;

for (int r=0; r<=7; r++)

{

setRow(0, r, b);

setRow(1, r, b);

}

delay(500);

clearDisplay(0);

clearDisplay(1);

delay(500);

randomSeed(analogRead(0));

displayEyes(0, 0);

delay(2000);

blinkEyes(true, false);

blinkEyes(false, true);

delay(1000);

}

void loop()

{

moveEyes(random(MIN, MAX + 1), random(MIN, MAX + 1), 50);

delay(random(5, 7) * 500);

if (random(0, 5) == 0)

{

delay(500);

blinkEyes();

delay(500);

}

if (EFFECT_ITERATION > 0)

{

cntLoop++;

if (cntLoop == EFFECT_ITERATION)

{

cntLoop = 0;

if (cntEffect > 6) cntEffect = 0;

switch(cntEffect)

{

case 0: // cross eyes

crossEyes();

delay(1000);

break;

case 1:

roundSpin(2);

delay(1000);

break;

case 2:

crazySpin(2);

delay(1000);

break;

case 3:

methEyes();

delay(1000);

break;

case 4:

lazyEye();

delay(1000);

break;

case 5:

blinkEyes(true, false);

blinkEyes(false, true);

delay(1000);

break;

case 6:

glowEyes(3);

delay(1000);

break;

default:

break;

}

cntEffect++;

}

}

}

void blinkEyes()

{

blinkEyes(true, true);

}

void blinkEyes(boolean blinkLeft, boolean blinkRight)

{

if (!blinkLeft && !blinkRight)

return;

for (int i=0; i<=3; i++)

{

if (blinkLeft)

{

setRow(0, i, 0);

setRow(0, 7-i, 0);

}

if (blinkRight)

{

setRow(1, i, 0);

setRow(1, 7-i, 0);

}

delay(DELAY_BLINK);

}

for (int i=3; i>=0; i--)

{

if (blinkLeft)

{

setRow(0, i, eyeCurrent[i]);

setRow(0, 7-i, eyeCurrent[7-i]);

}

if (blinkRight)

{

setRow(1, i, eyeCurrent[i]);

setRow(1, 7-i, eyeCurrent[7-i]);

}

delay(DELAY_BLINK);

}

}

void crazySpin(int times)

{

if (times == 0)

return;

moveEyes(0, 0, 50);

delay(500);

byte row = eyePupil;

for (int t=0; t<times; t++)

{

for (int i=0; i<5; i++)

{

row = row >> 1;

row = row | B10000000;

setRow(0, 3, row); setRow(1, 3, row);

setRow(0, 4, row); setRow(1, 4, row);

delay(50);

if (t == 0)

delay((5-i)*10); // increase delay on 1st scroll

}

for (int i=0; i<5; i++)

{

row = row >> 1;

if (i>=2)

row = row | B10000000;

setRow(0, 3, row); setRow(1, 3, row);

setRow(0, 4, row); setRow(1, 4, row);

delay(50);

if (t == (times-1))

delay((i+1)*10); // increase delay on last scroll

}

}

}

void crossEyes()

{

moveEyes(0, 0, 50);

delay(500);

byte pupilR = eyePupil;

byte pupilL = eyePupil;

for (int i=0; i<2; i++)

{

pupilR = pupilR >> 1;

pupilR = pupilR | B10000000;

pupilL = pupilL << 1;

pupilL = pupilL | B1;

setRow(0, 3, pupilR); setRow(1, 3, pupilL);

setRow(0, 4, pupilR); setRow(1, 4, pupilL);

delay(100);

}

delay(2000);

for (int i=0; i<2; i++)

{

pupilR = pupilR << 1;

pupilR = pupilR | B1;

pupilL = pupilL >> 1;

pupilL = pupilL | B10000000;

setRow(0, 3, pupilR); setRow(1, 3, pupilL);

setRow(0, 4, pupilR); setRow(1, 4, pupilL);

delay(100);

}

}

void displayEyes(int offsetX, int offsetY)

{

offsetX = getValidValue(offsetX);

offsetY = getValidValue(offsetY);

int row1 = 3 - offsetY;

int row2 = 4 - offsetY;

byte pupilRow = eyePupil;

if (offsetX > 0) {

for (int i=1; i<=offsetX; i++)

{

pupilRow = pupilRow >> 1;

pupilRow = pupilRow | B10000000;

}

}

else if (offsetX < 0) {

for (int i=-1; i>=offsetX; i--)

{

pupilRow = pupilRow << 1;

pupilRow = pupilRow | B1;

}

}

byte pupilRow1 = pupilRow & eyeBall[row1];

byte pupilRow2 = pupilRow & eyeBall[row2];

for(int r=0; r<8; r++)

{

if (r == row1)

{

setRow(0, r, pupilRow1);

setRow(1, r, pupilRow1);

eyeCurrent[r] = pupilRow1;

}

else if (r == row2)

{

setRow(0, r, pupilRow2);

setRow(1, r, pupilRow2);

eyeCurrent[r] = pupilRow2;

}

else

{

setRow(0, r, eyeBall[r]);

setRow(1, r, eyeBall[r]);

eyeCurrent[r] = eyeBall[r];

}

}

currentX = offsetX;

currentY = offsetY;

}

int getValidValue(int value)

{

if (value > MAX)

return MAX;

else if (value < MIN)

return MIN;

else

return value;

}

void glowEyes(int times)

{

for (int t=0; t<times; t++)

{

for (int i=2; i<=8; i++)

{

setIntensity(0,i);

setIntensity(1,i);

delay(50);

}

delay(250);

for (int i=7; i>=1; i--)

{

setIntensity(0,i);

setIntensity(1,i);

delay(25);

}

delay(150);

}

}

void methEyes()

{

moveEyes(0, 0, 50);

delay(500);

byte pupilR = eyePupil;

byte pupilL = eyePupil;

for (int i=0; i<2; i++)

{

pupilR = pupilR << 1;

pupilR = pupilR | B1;

pupilL = pupilL >> 1;

pupilL = pupilL | B10000000;

setRow(0, 3, pupilR); setRow(1, 3, pupilL);

setRow(0, 4, pupilR); setRow(1, 4, pupilL);

delay(100);

}

delay(2000);

for (int i=0; i<2; i++)

{

pupilR = pupilR >> 1;

pupilR = pupilR | B10000000;

pupilL = pupilL << 1;

pupilL = pupilL | B1;

setRow(0, 3, pupilR); setRow(1, 3, pupilL);

setRow(0, 4, pupilR); setRow(1, 4, pupilL);

delay(100);

}

}

void lazyEye()

{

moveEyes(0, 1, 50);

delay(500);

for (int i=0; i<3; i++)

{

setRow(1, i+2, eyeBall[i+2]);

setRow(1, i+3, eyeBall[i+3] & eyePupil);

setRow(1, i+4, eyeBall[i+4] & eyePupil);

delay(150);

}

delay(1000);

for (int i=0; i<3; i++)

{

setRow(1, 4-i, eyeBall[4-i] & eyePupil);

setRow(1, 5-i, eyeBall[5-i] & eyePupil);

setRow(1, 6-i, eyeBall[6-i]);

delay(25);

}

}

void roundSpin(int times)

{

if (times == 0)

return;

moveEyes(2, 0, 50);

delay(500);

for (int i=0; i<times; i++)

{

displayEyes(2, -1); delay(40); if (i==0) delay(40);

displayEyes(1, -2); delay(40); if (i==0) delay(30);

displayEyes(0, -2); delay(40); if (i==0) delay(20);

displayEyes(-1, -2); delay(40);if (i==0) delay(10);

displayEyes(-2, -1); delay(40);

displayEyes(-2, 0); delay(40);

displayEyes(-2, 1); delay(40);if (i==(times-1)) delay(10);

displayEyes(-1, 2); delay(40);if (i==(times-1)) delay(20);

displayEyes(0, 2); delay(40); if (i==(times-1)) delay(30);

displayEyes(1, 2); delay(40); if (i==(times-1)) delay(40);

displayEyes(2, 1); delay(40); if (i==(times-1)) delay(50);

displayEyes(2, 0); delay(40);

}

}

Detector de humo

Este es uno de los proyectos más importantes que puedes llevar a cabo porque, gracias a Arduino, puedes salvar tu vida y la de los tuyos de incendios. Entre sus funciones se encuentra la posibilidad de recibir una notificación ante un siniestro. Si lo deseas, puedes agregar un monitor para aprovechar al máximo esta idea.

Los materiales que vas a tener que adquirir no son caros, ya que necesitarás una placa de Arduino de la versión Nano R3, Mega2560 o ATMEGA2560. También deberás tener un sensor para medir la temperatura y humedad DHT11, un módulo para sensor de gas, un zumbador, una placa de pan PCB, resistencia de 1k Ohm, cables y una pantalla LCD.

En cuanto a los códigos de programación que tendrás que escribir en el IDE, los puede copiar a continuación:

#include<LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2);

int temp;

int humi;

int tol;

int j;

int H=50;

int T=25;

int B=1;

int flag=0;

int led=7;

int LED=9;

int BU=2;

int BUTTON=3;

int FMQ=13;

int fmq=10;

unsigned int loopCnt;

int chr[40] = {0};

unsigned long time;

#define pin 8

void setup()

{

pinMode(fmq,OUTPUT);

pinMode(FMQ,OUTPUT);

pinMode(LED,OUTPUT);

pinMode(led,OUTPUT);

begin(9600);

}

void loop()

{ HH();

TT();

keyScan();

bgn:

delay(200);

pinMode(pin,OUTPUT);

digitalWrite(pin,LOW);

delay(20);

digitalWrite(pin,HIGH);

delayMicroseconds(40);

digitalWrite(pin,LOW);

pinMode(pin,INPUT);

loopCnt=10000;

while(digitalRead(pin) != HIGH)

{

if(loopCnt-- == 0)

{

println("HIGH");

goto bgn;

}

}

loopCnt=30000;

while(digitalRead(pin) != LOW)

{

if(loopCnt-- == 0)

{

println("LOW");

goto bgn;

}

}

for(int i=0;i<40;i++)

{

while(digitalRead(pin) == LOW)

{}

time = micros();

while(digitalRead(pin) == HIGH)

{}

if (micros() - time >50)

{

chr[i]=1;

}else

{

chr[i]=0;

}

}

humi=chr[0]*128+chr[1]*64+chr[2]*32+chr[3]*16+chr[4]*8+chr[5]*4+chr[6]*2+chr[7];

temp=chr[16]*128+chr[17]*64+chr[18]*32+chr[19]*16+chr[20]*8+chr[21]*4+chr[22]*2+chr[23];

tol=chr[32]*128+chr[33]*64+chr[34]*32+chr[35]*16+chr[36]*8+chr[37]*4+chr[38]*2+chr[39];

print("temp:");

println(temp);

print("humi:");

println(humi);

print("tol:");

println(tol);

if(temp>T)

{

digitalWrite(LED,HIGH);

digitalWrite(FMQ,LOW);

}else{

digitalWrite(LED,LOW);

digitalWrite(FMQ,HIGH);

}

if(humi>H)

{

digitalWrite(led,HIGH);

digitalWrite(fmq,LOW);

}else{

digitalWrite(led,LOW);

digitalWrite(fmq,HIGH);

}

int val;

val=analogRead(0);

print("smo:");

println(val,DEC);

delay(100);

if(flag==0)

{

begin(16,2);

setCursor(0,0);

print("TEMP: C");

setCursor(9,0);

print("SMO:");

setCursor(0,1);

print("HUMI: %");

setCursor(9,1);

//lcd.print("BEP:");

setCursor(5,0);

print(temp);

setCursor(5,1);

print(humi);

setCursor(13,0);

print(val,DEC);

}

if(flag==1)

{

begin(16,2);

print("ALARM TEMP:");

setCursor(11,0);

print(T);

}

if(flag==2)

{

begin(16,2);

print("ALARM HUMI:");

setCursor(12,0);

print(H);

}

}

void keyScan()

{

if(analogRead(BUTTON)>600)

{

delay(20);

if(analogRead(BUTTON)>600)

{

flag++;

if(flag>=3)

flag=0;

while(analogRead(BUTTON)>600);

}

}

}

void HH()

{

if(analogRead(B)>600)

{

delay(20);

if(analogRead(B)>600)

{

H++;

if(H>=61)

H=40;

while(analogRead(B)>600);

}

}

}

void TT()

{

if(analogRead(BU)>600)

{

delay(20);

if(analogRead(BU)>600)

{

T++;

if(T>=31)

T=20;

while(analogRead(BU)>600);

}

}

}

Papelera de apertura automática

Es asombroso cómo un sensor ultrasónico puede ser el complemento crucial para una gran variedad de proyectos extraordinarios. Con la ayuda de una placa Arduino UNO, puedes crear un bote para tirar la basura, pero que se destaque por su la apertura automática de su tapa. Para esto, vas a necesitar Arduino Genuino y UNO, un servo motor, un sensor de movimientos, cables y demás conectores.

Cuando tengas todos los materiales, vas a tener que escribir en el IDE de Arduino:

#include <Servo.h>

Servo servo;

int trigPin = 5;

int echoPin = 6;

int servoPin = 7;

long duration,

dist,

verage;

long aver[3];

void setup()

{

attach(servoPin);

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

write(0);

delay(100);

detach();

}

void measure()

{

digitalWrite(10,HIGH);

digitalWrite(trigPin, LOW);

delayMicroseconds(5);

digitalWrite(trigPin, HIGH);

delayMicroseconds(15);

digitalWrite(trigPin, LOW);

pinMode(echoPin, INPUT);

duration = pulseIn(echoPin, HIGH);

dist = (duration/2) / 29.1;

}

void loop()

{

for (int i=0;i<=2;i++)

{

measure();

aver[i]=dist;

delay(10);

}

dist=(aver[0]+aver[1]+aver[2])/3;

if ( dist < 150 ) {

attach(servoPin);

delay(1);

write(90);

delay(3000);

write(0);

delay(300);

detach();

}

}

Monitor de piscina

Con la elaboración de este monitor puedes beneficiarte en gran medida, ya que podrás monitorear el estado de la piscina, mostrándote los datos en tiempo real. De esta manera tendrás en los niveles correctos el PH y sabrás cuando agregar cloro o alguicidas. También te servirá para mostrarte la temperatura del agua. En la construcción de este proyecto será necesario que tengas una placa de Arduino modelo Nano 33 IoT, una sonda ISE, una sonda EC integrada y un kit de conectores.

Por último, tendrás que abrir el entorno de programación de Arduino y comenzar a escribir estos códigos:

#include <ArduinoJson.h>

#include <ArduinoBLE.h>

#include <uFire_EC_JSON.h>

#include <uFire_pH_JSON.h>

#include <uFire_ORP_JSON.h>

BLEService uFire_Service("4805d2d0-af9f-42c1-b950-eae78304c408");

BLEStringCharacteristic tx_Characteristic("50fa7d80-440a-44d2-967a-ec7731ec736a", BLENotify, 20);

BLEStringCharacteristic rx_Characteristic("50fa7d80-440b-44d2-967b-ec7731ec736b", BLEWrite, 20);

uFire_EC_JSON ec;

uFire_pH_JSON ph;

uFire_ORP_JSON orp;

void rxCallback(BLEDevice central, BLECharacteristic characteristic) {

String rx_command = rx_Characteristic.value();

String json_out = ec.processJSON(rx_command);

if (json_out != "")

{

setValue(json_out);

return;

}

// comprobar el PH

json_out = ph.processJSON(rx_command);

if (json_out != "")

{

setValue(json_out);

return;

}

json_out = orp.processJSON(rx_command);

if (json_out != "")

{

setValue(json_out);

return;

}

}

void setup() {

begin(new uFire_EC);

begin(new ISE_pH);

begin(new ISE_ORP(0x3e));

begin();

begin();

setLocalName("uFire BLE");

setAdvertisedService(uFire_Service);

addCharacteristic(tx_Characteristic);

addCharacteristic(rx_Characteristic);

addService(uFire_Service);

setEventHandler(BLEWritten, rxCallback);

advertise();

}

void loop() {

poll();

}

Espejo caleidoscopio infinito

Este es otro de los proyectos para pasar el tiempo y para practicar los conocimientos aprendidos en Arduino. La creación de este espejo produce una ilusión infinita en constante cambio a medida que se mueve su dirección, creando un efecto asombroso para el que está visualizando. Vas a necesitar un Arduino 101, leds direccionales, tubo termo retráctil, pilas AA, espejo cuadrado, núcleo de espuma, pines de puente y conectores varios.

Después, tendrás que ingresar estos comandos de programación en el IDE:

#include "CurieIMU.h"

#include <Adafruit_NeoPixel.h>

#define PIN 6 //// ¿A qué pin están conectados los NeoPixels?

Tira de Adafruit_NeoPixel =  Adafruit_NeoPixel ( 54 ,  PIN ,  NEO_GRB  +  NEO_KHZ800 );

int tr  =  0 ;

int tg  =  0 ;

int tb  =  0 ;

int r  =  0 ;

int g = 0;

int b = 0;

int rawX = 0;

int rawY = 0;

//int rawZ = 0;

float angle = 0.0;

void setup() {

begin();

setAccelerometerRange(2);

begin();

show();

}

void loop() {

int rawX = CurieIMU.readAccelerometer(X_AXIS);

int rawY = CurieIMU.readAccelerometer(Y_AXIS);

int rawZ = CurieIMU.readAccelerometer(Z_AXIS);

angle = atan2(rawX, rawY); // the funtion atan2() converts x and y forces into an angle in radians.

if (abs(angle) > 2.5) { // digital pins are down

/// turn lights off in this position

tr = 0;

tg = 0;

tb = 0;

runlights();

}

if ((angle > 1.5) && (angle < 2.5)) {

tr = 100;

tg = 100;

tb = 100;

runlights();

}

else if ((angle < 1.5) && (angle > 0.5)) {

tr = 100;

tg = 0;

tb = 0;

runlights();

}

else if ((angle < 0.5) && (angle > -0.5)) {

//make lights green in this position

tr = 0;

tg = 100;

tb = 0;

runlights();

}

else if ((angle < -1.5) && (angle > -2.5)) {

//make lights blue in this position

tr = 0;

tg = 0;

tb = 100;

runlights();

}

else if ((angle < -0.5) && (angle > -1.5)) {

theaterChase();

}

else {

tr = 0;

tg = 0;

tb = 0;

runlights();

}

}

void runlights() {

/// color smoothing.

if (tr > r + 1) {

r++;

}

if (tg > g + 1) {

g++;

}

if (tb > b + 1) {

b++;

}

if (tr < r) {

r--;

}

if (tg < g) {

g--;

}

if (tb < b) {

b--;

}

//turn all the LEDS to the current r, g, b values.

for (int i = 0; i < strip.numPixels(); i++) {

setPixelColor(i, r, g, b);

}

show();

delay(10);

}

void rainbowCycle(uint8_t wait) {

uint16_t i, j;

for(j=0; j<256*5; j++) {

for(i=0; i< strip.numPixels(); i++) {

setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));

}

show();

delay(wait);

}

}

void theaterChase(){ for (int j = 0; j < 3; j++) { //3cycles of chasing

for (int q = 0; q < 3; q++) {

for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {

setPixelColor(i + q, r, g, b);

}

show();

delay(50);

for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {

setPixelColor(i + q, 0);

}

}

}

}

uint32_t Wheel(byte WheelPos) {

WheelPos = 255 - WheelPos;

if(WheelPos < 85) {

return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);

}

if(WheelPos < 170) {

WheelPos -= 85;

return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);

}

WheelPos -= 170;

return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);

}

Panel de control para el ordenador

Este proyecto se basa en programar la placa Arduino en un panel de control para el PC, de modo, que pueda ejecutar diferentes tipos de comandos en el equipo. Aunque, elaborarlo puede ser un poco complejo y puede llevar algo de tiempo, es un proyecto muy efectivo que puede facilitar el uso de tu dispositivo. Si estás interesado en este plan electrónico vas a necesitar la versión UNO de Arduino, una protoboard genérica, un zumbador y conectores.

Para finalizar, tendrás que usar estos códigos:

#include <Wire.h>

#include <PC42.h>

#include <EEPROM.h>

#define TONE_ERR Si1         // 59 Hz

#define TONE_ALARM Do6

#define MAX_SECONDS 9999

#define EEPROM_ADDR_SECONDS 4

typedef struct {

int total_time;

int countdown;

int count_millis;

long millis;

long millis_old;

struct {

unsigned state:3;

unsigned alarm:3;

};

} tempo_t;

tempo_t tempo;

enum {INIT_STOP, STOP, INIT_COUNTDOWN, COUNTDOWN, INIT_ALARM, ALARM};

enum {OFF, ON };

void setup() {

begin();

tempo_init();

}

void loop() {

// Dispatcher

switch(tempo.state) {

case INIT_STOP:

ledBegin();

ledWrite(1, HIGH);

power_off();

state = STOP;

break;

case STOP:

dispNum(tempo.countdown);

tempo_stop();

break;

case INIT_COUNTDOWN:

if (tempo.countdown > 0) {

ledBegin();

ledWrite(4, HIGH);

millis_old = millis();

state = COUNTDOWN;

}

else {

state = INIT_STOP;

}

break;

case COUNTDOWN:

tempo_countdown();

break;

case INIT_ALARM:

power_off();

ledBegin();

ledWrite(3, HIGH);

millis = millis();

alarm = 0;

state = ALARM;

break;

case ALARM:

alarm();

break;

default:

state = INIT_STOP;

}

}

void tempo_stop(void) {

char keys;

dispDots(0);

keys = pc.keyCount(KEY_DOWN);

countdown -= keys;

if (tempo.countdown < 0)

countdown += MAX_SECONDS + 1;

keys = pc.keyCount(KEY_UP);

countdown += keys;

if (tempo.countdown > MAX_SECONDS)

countdown -= MAX_SECONDS + 1;

if (pc.keyPressed(KEY_UP) && pc.keyPressed(KEY_DOWN)) {

countdown = tempo.total_time;

count_millis = 0;

}

if (pc.keyEvents(KEY_RIGHT, KEY_PRESSED_TIME2)) {

total_time = tempo.countdown;

dispWrite(0,0,0,0);

eeprom_write16(EEPROM_ADDR_SECONDS, tempo.total_time);

delay(100);

}

if (pc.keyEvents(KEY_ENTER, KEY_PRESSED_TIME1)) {

state = INIT_COUNTDOWN;

}

dispNum(tempo.countdown);

}

void tempo_countdown(void) {

power_on();

millis = millis();

count_millis += tempo.millis - tempo.millis_old;

millis_old = tempo.millis;

while (tempo.count_millis >= 1000) {

countdown--;

dispNum(tempo.countdown);

count_millis -= 1000;

if (tempo.countdown == 0) break;

}

if (tempo.count_millis < 500)

dispDots(0);

else

dispDots(1);

if (tempo.countdown == 0) {

power_off();

state = INIT_ALARM;

}

if (pc.keyEvents(KEY_ENTER, KEY_PRESSED_TIME1)) {

state = INIT_STOP;

}

}

void alarm(void) {

dispWrite(DD_E, DD_n, DD_d, DD_SP);

switch(tempo.alarm) {

case 0:

alarm_sound();

alarm = 1;

break;

case 1:

if (millis() > tempo.millis + 1000) {

alarm_sound();

millis += 1000;

alarm = 2;

}

break;

case 2:

if (millis() > tempo.millis + 4000) {

millis += 4000;

buzzPlay(TONE_ALARM, 16);

buzzPlay(0, 16);

}

break;

}

if (pc.keyEvents(KEY_ENTER, KEY_PRESSED_TIME1)) {

buzzBegin();

countdown = tempo.total_time;

count_millis = 0;

state = INIT_STOP;

}

}

int eeprom_read16(int addr) {

return (EEPROM.read(addr + 1) << 8) | EEPROM.read(addr);

}

int eeprom_write16(int addr, int data) {

write(EEPROM_ADDR_SECONDS, tempo.total_time);

write(EEPROM_ADDR_SECONDS+1, tempo.total_time>>8);

}

void tempo_init(void) {

total_time = eeprom_read16(EEPROM_ADDR_SECONDS);

state = INIT_STOP;

alarm = OFF;

millis = 0;

millis_old = 0;

countdown = tempo.total_time;

count_millis = 0;

}

void alarm_sound(void) {

buzzPlay(TONE_ALARM, 62);

buzzPlay(0, 62);

buzzPlay(TONE_ALARM, 62);

buzzPlay(0, 62);

buzzPlay(TONE_ALARM, 62);

buzzPlay(0, 62);

buzzPlay(TONE_ALARM, 62);

buzzPlay(0, 62);

}

void power_on(void) {

// Desactivar la salida de potencia

pinMode(10, OUTPUT);

digitalWrite(10, HIGH);

}

// Para apagar la fuente de alimentación

void power_off(void) {

// Desactivar la salida de potencia

digitalWrite(10, LOW);

pinMode(10, INPUT);

}