Ciabatta arduino pro

La Ciabatta arduino pro è un progetto che nase in collaborazione con Daniele Tartaglia:

ciabatta arduino pro bluetooth

Daniele è un maker appassionato arduino ed anche uno youtuber molto seguito per l’alta qualità dei suoi tutorial e dei progetti che presenta.

Come nasce la Ciabatta arduino Pro v.2

La ciabatta arduino pro v.2 nasce dopo una telefonata con Daniele in cui mi ha raccontato che in molti appassionati richiedevano lo sviluppo di una ciabatta controllabile da cellulare dopo la presentazione della prima versione.

Il mio contributo in questa versione è minimo, mi limito a fornirti un codice alternativo, leggermente ottimizzato, correggedo il problema di dover staccare il modulo bluetooth ogni volta che devi uplodare il nuovo sketch arduino.

Prima di passare allo sketch è necessario modificare i collegamenti del modulo bluetooth spostando i collegamenti TX ed RX da 0 e 1 verso 7 ed 8 in modo che il modulo bluetooth possa comunicare con la scheda senza intralciare la comunicazione seriale:

ciabatta_arduino_pro_schema_bt

Gli altri collegamenti che Daniele ha realizzato puoi lasciarli come descritto nel suo video.

Lo sketch che ti propongo è il seguente:

/*
Ciabatta Bluetooth ver.2 
 
@author:  Daniele Tartaglia & Mauro Alfieri
@site: www.labdomotic.com & www.mauroalfieri.it
@youtube: https://www.youtube.com/user/edstarink
          https://www.youtube.com/user/doctoralma77
@created: March 2017
 
@Licence: CC Attribution Noncommercial Share Alike
@link:    https://creativecommons.org/licenses/by-nc-sa/3.0/it/
*/
 
#include <SoftwareSerial.h>
#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>
 
/*********************************************************************/
 
#define BT_TX_PIN  7
#define BT_RX_PIN  8
 
/*********************************************************************/
 
SoftwareSerial mySerial(BT_TX_PIN, BT_RX_PIN);
RTC_DS1307 RTC;
LiquidCrystal_I2C lcd(0x3F,16,2);
 
/*********************************************************************/
 
char lettera;
char buffer[16];
 
byte rele1=2;
byte rele2=3;
byte rele3=4;
byte rele4=5;
 
int previousSec = 0;
 
uint8_t SPENTO[8] = {0x0E, 0x11, 0x11, 0x11, 0x0A, 0x0E, 0x0E, 0x04,};
uint8_t ACCESO[8] = {0x0E, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x04,};
 
/*********************************************************************/
 
void setup() {
    Serial.begin(9600);
    mySerial.begin(9600);
    Wire.begin();
    RTC.begin();
    lcd.init();
    lcd.backlight(); 
     
    pinMode(rele1, OUTPUT);
    pinMode(rele2, OUTPUT);
    pinMode(rele3, OUTPUT);
    pinMode(rele4, OUTPUT);
     
    digitalWrite(rele1, HIGH);
    digitalWrite(rele2, HIGH);
    digitalWrite(rele3, HIGH);
    digitalWrite(rele4, HIGH);
     
    if (! RTC.isrunning()) {
      Serial.println("RTC is NOT running!");
      RTC.adjust(DateTime(__DATE__, __TIME__));
    }
     
    lcd.createChar( 0,SPENTO );
    lcd.createChar( 1,ACCESO );
    lcd.setCursor ( 0,0 );
    lcd.print("Ciabatta BT v.2");
    delay(2000);
    lcd.clear();
    lcd.setCursor( 12,0 );
    lcd.write(0);
    lcd.write(0);
    lcd.write(0);
    lcd.write(0);
}
 
/*********************************************************************/
  
void loop() {
  DateTime now = RTC.now();
     
  if(now.second() != previousSec) {
        lcd.setCursor( 0,0 );
        sprintf(buffer,"%02d:%02d:%02d",now.hour(),now.minute(),now.second());
        lcd.print( buffer );
        previousSec = now.second();
    }
     
    if(mySerial.available()) { 
        lettera = mySerial.read(); 
         
        switch (lettera) {
        case 'A':
            digitalWrite(rele1, LOW); 
            Serial.println("relay 1 on");
            viewSocket( 1,true );
        break;
         
        case 'S':
            digitalWrite(rele1, HIGH); 
            Serial.println("relay 1 off");
            viewSocket( 1,false );
        break;
         
        case 'Q':
            digitalWrite(rele2, LOW);
            Serial.println("relay 2 on");
            viewSocket( 2,true );
        break;
         
        case 'W':
            digitalWrite(rele2, HIGH);
            Serial.println("relay 2 off");
            viewSocket( 2,false );
        break;
         
        case 'E':
            digitalWrite(rele3, LOW);
            Serial.println("relay 3 on");
            viewSocket( 3,true );
        break;
         
        case 'R':
            digitalWrite(rele3, HIGH);
            Serial.println("relay 3 off");
            viewSocket( 3,false );
        break;
         
        case 'T':
            digitalWrite(rele4, LOW);
            Serial.println("relay 4 on");
            viewSocket( 4,true );
        break;
         
        case 'Y':
            digitalWrite(rele4, HIGH);
            Serial.println("relay 4 off");
            viewSocket( 4,false );
        break;
        }
    }   
}
 
void viewSocket(byte num, boolean status) {
  lcd.setCursor( ( 11+num ),0 );
  if ( status ) { 
     lcd.write(1); 
     lcd.setCursor ( 0,1 );
     lcd.print("Acceso rele "); 
  } else { 
    lcd.write(0);
    lcd.setCursor ( 0,1 );
    lcd.print("Spento rele ");
  }
  lcd.setCursor ( 12,1 );
  lcd.print(num);
}

passando alla descrizione linea per linea parti dalle

linee 14-17: in cui includi tutte le librerie necessarie al funzionamento della ciabatta arduino pro. In particolare la Wire, l’RTC e la LiquidCrystal_i2C servono per i rispettivi moduli, mentre al SoftwareSerial ti serve per comunicare con il modulo BT;

linee 21-22: definisci due pin Tx ed Rx a cui avrai collegato il modulo HC-06 utilizzato per la realizzazione della ciabatta arduino pro v.2;

linea 26: crea l’istanza dell’oggetto SoftwareSerial che userai per comunicare con il modulo bluetooth;

linea 27: crea l’istanza dell’oggetto RTC che ti serve per comunicare con l’RTC;

linea 28: crea l’istanza dell’oggetto LiquidCrystal che ti serve per inviare i messaggi sul display;

linee 32-38: crea le variabili di buffer, per scrivere sul display, e dei pin a cui sono connessi i relé;

linea 40: definisci la variabile globale di tipo int che userai per tener traccia del passare del tempo per aggiornare l’ora sul display;

linee 42-43: definisci due “custom character” ossia due caratteri disegnati da te, uno rappresenta una lampadina accesa ed uno quella spenta;

linee 48-52: inizializza tutte le istanze verso Seriale, mySerial, Rtc e Lcd;

linea 53: invia il comando di accensione della retroilluminazione del display;

linee 55-63: imposta i pin connessi ai rele come OUTPUT e porta a HIGH le rispettive uscite;

linee 65-68: servono a impostare l’orario dell’RTC la prima volta che lo colleghi ad arduino;

linee 70-71: definisci i due caratteri speciali, disegnati da te alle linee 40-41, come indici 0 ed 1 da usare nello sketch;

linee 73-75: scrivi sulla prima linea del display il testo “Ciabatta BT v.2” e attendi 2 secondi prima di pulire il display con il metodo clear();

linee 76-80: imposta il cursore nella posizione 12, della prima linea, e disegna i 4 caratteri personalizzati;

ciabatta

linea 86: richiedi all’RTC la data e l’ora corrente;

linea 88: verifica che il secondo corrente “now.second()” sia diverso da quello precedentemente visualizzato e memorizzato nella variabile previousSec;

linea 89-91: quando il tempo trascorso tra l’ultimo aggiornamento dell’orario è differente esegui l’aggiornamento dell’orario sul display. In questo modo ottieni solo gli aggiornamenti continui del display al cambio di ogni secondo;

linea 92: assegna il secondo corrente, ossia quello appena visualizzato alla variabile previousSec;

linea 95: quando arriva un carattere sul buffer seriale bluetooth, quindi dal cellulare, esegui le linee successive;

linea 96: leggi la prima lettera presente nel buffer seriale;

linee 98-103: se la lettera ricevuta è “A” allora porta l’usicta corrispondente al rele 1 a LOW, scrivi sul monitor seriale “relay 1 on” e richiama la funzione viewSocket() passandole il numero di relay e lo stato: in questo caso true ( acceso )

linee 105-145: esegui le medesime operazioni viste per il passaggio 100-104 per ciascuna delle lettere ricevute dal seriale bluetooth della ciabatta arduino pro;

linea 150: definisci la funzione viewSocket() con i due parametri attesi: 

  • num: il numero di relè coinvolto
  • status: lo stato del relè: acceso/spento ( true/false)

linea 151: calcola la posizione X del cursore come (11+num) ossia 12 per il relè 1, 13 per il 2, ecc… e posiziona il cursore;

linea 152: se “status” è true procedi con la visualizzazione della luce accesa e del messaggio sulla seconda linea;

linea 153: essendo il relay acceso ( status = true ) visualizza la lampadina accesa ( carattere speciale 1 );

linea 154: posizionati sulla seconda riga carattere 0;

linea 155: scrivi la frase “Acceso rele “;

linee 157-159: esegui le stesse operazioni delle linee 153-155 ma con simbolo “0” e scrivendo “Spento rele “;

linee 161-162: posizionati al carattere 12 della seconda riga e scrivi il valore di num ( 1,2,3 o 4 );

lo sketch è lungo ma semplice in quanto non presenta passaggi o parti complesse proprio per consentirti le modifiche che desideri.

Il video di Daniele su come realizzare la ciabatta arduino pro v.2

Buona visione.

Prima di inserire un commento, per favore, leggi il regolamento

Permanent link to this article: https://www.mauroalfieri.it/elettronica/ciabatta-arduino-pro.html

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.