Controllo del TV con Arduino con Led Infrarossi

Da qualche tempo mi sono trasferito in Grosseto e sono venuto ad abitare in una piccola mansarda nel Parco della Maremma. La mansardina è piccola ed essenziale, ma riesce sempre a nascondere alcune cose fondamentali, come per esempio il Telecomando del TV. Quando lo cerchi non lo trovi mai!
Mosso dall'esigenza di poter controllare la TV senza doversi sempre preoccupare della localizzazione dello scettro dei tempi moderni (leggi telecomando TV) mi sono messo alla ricerca tra i componenti sparsi nei miei cassetti freschi di trasloco (sigh!).
Ho trovato un sensore di gesture che non avevo ancora mai testato. Quale migliore occasione di farci amicizia!??
Il sensore in questione è APDS 9960 che riesce a discriminare ben 6 movimenti diversi, destra,
sinistra, alto, basso, vicino e lontano, sufficienti per poter regolare il volume, l'avanzamento dei programmi, la selezione del canale più ascoltato ed il Mute per escludere velocemente l' ascolto.

Quindi definite le specifiche del progetto sono passato alla ricerca di qualche tutorial in rete per capire meglio utilizzo del sensore, ho trovato questo https://learn.sparkfun.com/tutorials/apds-9960-rgb-and-gesture-sensor-hookup-guide/all  che è molto interessante e mi ha messo in condizione di poter fare subito i primi test.
Caricata la libreria specifica del sensore basta far girare il firmware di test che nella finestra seriale della IDE di Arduino possiamo già vedere riconosciuti i movimenti di UP DOWN LEFT RIGHT NEAR  e FAR.

Ho preso integralmente il firmware di test che fa proprio al mio caso e sono passato a fare dei test sulla parte Infrarossi. Qui ho già una discreta esperienza fatta durante alcuni altri progetti conclusi negli scorsi anni, quindi sono subito andato a scaricarmi la libreria IRremote direttamente dal repository della IDE di Arduino.
Nei file di esempio c'è già tutto quello che serve per poter facilmente cambiare canale ed agire sul volume del tuo televisore.
Ho montato un circuito di test per registrare il codice Infrarosso che trasmette il mio telecomando, collegando un ricevitore IR

Attraverso la lettura dei codici trasmessi dal mio telecomando ed intercettati dal sensore IR qui in foto, ho potuto registrare i codici dei 6 comandi necessari al progetto.
Ho quindi montato il  Led trasmettitore Infrarossi per controllare la correttezza dei comandi inviati al TV dal mio circuito e quando tutto finalmente funziona, mi sono dedicato a montare tutto il software assieme per ottenere la prima versione del progetto funzionante.

Guardando il risultato però non ero ancora completamente soddisfatto, perchè, anche se non sono amante delle lucine messe dappertutto, non avere nessun riscontro delle operazioni effettuate e del corretto riconoscimento del gesture, mi sembrava troppo scarno, allora mi sono deciso a mettere la mano adi nuovo nel cassetto per vedere come abbellire il mio telecomando.
Ho deciso quindi di aggiungere un display 1602 con il suo circuito I2C per evitare di non cablare in modo parallelo  il display stesso.
Naturalmente l'appetito vien mangiando, con un diusplay a disposizione è un peccato non vedere l'ora esatta, viene da sè che diventa indispensabile inserimento nel progetto di una RTC per fornire l'ora esatta al sistema e poterla quindi avere a disposizione sul display a cristalli liquidi.
Anche con l'RTC ho già fatto amicizia durante una serie di altri progetti, quindi sono partito avvantaggiato!!, nei file di esempio della libreria RTClib ci sono tutti ritagli software che sono necessari per poter programmare l'ora esatta (una tantum) e interrogare la RTC per visualizzare sul display l'ora sul display ad ogni loop del firmware.

Per quanto riguarda il firmware per la gestione del display ho utilizzato questa guida, molto utile per l'uso congiunto della interfaccia I2C con il display a cristalli liquidi 1602...https://www.instructables.com/id/Using-PCF8574-backpacks-with-LCD-modules-and-Ardui/

quindi ho istallato la seguente libreria  https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads

Questo e' il risultato del primo prototipo completo montato sulla scrivania. Nel pomeriggio (forse) provvedero' alla posa in una scatolina per mettere in uso il sistema completo. (vedremo, di solito alla catola non ci arrivo mai, ma passo subito al prossimo progetto!! vedrfemo... e vedrete, forse)

Sotto alle foto il firmware funzionante

   





















codice:
*****************************************************

//sistema di trasmissione  dei codici IR della mia TV gestito da sensore di movimento
//sono registrati alcuni movimenti che corrispondono a comendi TV definiti
//dal basso all'alto == Aumenta Volume ++   funzione alzaVolume     2FD58A7
//dal'alto al basso == Abbassa Volume --    funzione abbassaVolume  2FD7887
// da destra a sinistra == Programmi --     funzione Programmameno  2FDD827
//da sinistra a destra == Programmi ++      funzione Programmapiu   2FDF807
//da vicino a lontano veloce                funzione VolumeNO       2FD08F7
//da lontano a vicino veloce                funzione Canale 48  2FD20DF  +  2FD10EF
// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
//Sensore APDS9960 connesso ad SDA SCL 3,3Volts GND e PIN 2 interrupt
//IR LED connesso a PWM pin 3.

#include
#include "RTClib.h"
#include  
#include

LiquidCrystal_I2C  lcd(0x26,2,1,0,4,5,6,7);  // set the LCD address to 0x27 for a 16 chars and 2 line display

#include
#include
#include
IRsend irsend;
// Pins
#define APDS9960_INT    2 // Needs to be an interrupt pin
// Global Variables
SparkFun_APDS9960 apds = SparkFun_APDS9960();
int isr_flag = 0;
RTC_DS1307 rtc;

void setup() {
   lcd.begin (16,2); // for 16 x 2 LCD module
   lcd.setBacklightPin(3,POSITIVE);
   lcd.setBacklight(HIGH);
   lcd.backlight();
   // Set interrupt pin as input
  pinMode(APDS9960_INT, INPUT);

  // Initialize Serial port
  //Serial.begin(9600);
    // Initialize interrupt service routine
  attachInterrupt(0, interruptRoutine, FALLING);

  // Initialize APDS-9960 (configure I2C and initial values)
  if ( apds.init() ) {
    lcd.print(F("9960 init complete"));
        delay(1000);

  } else {
    lcd.print("Some went wrong");
        delay(1000);

  }
   lcd.clear();
  // Start running the APDS-9960 gesture sensor engine
  if ( apds.enableGestureSensor(true) ) {
    lcd.print("Gest now running");
        delay(1000);

  } else {
    lcd.print("Int APDS wrong");
        delay(1000);

  }
   lcd.clear();

      if (! rtc.begin()) {
    lcd.print("NON TROVO RTC");
    while (1);
  }
  lcd.clear();
  if (! rtc.isrunning()) {
    lcd.print("RTC NOT run!");
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    delay(1500);
    }else{lcd.clear(); lcd.print("RTC is OK");delay(1500);}
    lcd.clear();
    lcd.home (); // set cursor to 0,0
    lcd.print(" TecnoGeppetto");
    delay(1000);
    lcd.setCursor(1,1);
    lcd.print("telecomando TV");
//****************************************************************
    //per rimettere l'ora se rtc ha perso qualche colpo!!
   // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
//****************************************************************

   
}

void loop() {
  if( isr_flag == 1 ) {
    detachInterrupt(0);
    handleGesture();
    isr_flag = 0;
    attachInterrupt(0, interruptRoutine, FALLING);
  }
 
   DateTime now = rtc.now();
   lcd.setCursor(0,0);
   lcd.print("ORARIO: ");
   lcd.print(now.hour());
   lcd.print(":");
   lcd.print(now.minute());
   lcd.print(":");
   lcd.print(now.second());
}



void alzaVolume(){
//Qui inserire il RAW del Volume ++  2FD58A7
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FD58A7, 32);
    delay(40);
  }

}

void abbassaVolume(){
//Qui inserire il RAW del Volume --  2FD7887
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FD7887, 32);
    delay(40);
  }

}


void Programmapiu(){
//Qui inserire il RAW del Programmi ++  2FDD827
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FDD827, 32);
    delay(40);
  }

}

void Programmameno(){
//Qui inserire il RAW del Programmi --  2FDF807
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FDF807, 32);
    delay(40);
  }

}


void VolumeNO(){
//Qui inserire il RAW del VolumeNO  .. 2FD08F7
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FD08F7, 32);
    delay(40);
  }

}


void Canale48(){
//Qui inserire il RAW del Canale48 :  2FD20DF  +  2FD10EF
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FD20DF, 32);
    delay(40);
  }
for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0x2FD10EF, 32);
    delay(40);
  } 

}
void interruptRoutine() {
  isr_flag = 1;
}

void handleGesture() {
    if ( apds.isGestureAvailable() ) {
    switch ( apds.readGesture() ) {
      case DIR_UP:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= Vol +");
       alzaVolume();
        break;
      case DIR_DOWN:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= Vol -");
        abbassaVolume();
        break;
      case DIR_LEFT:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= Prog -");
      Programmameno();
        break;
      case DIR_RIGHT:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= Prog +");
      Programmapiu();
        break;
      case DIR_NEAR:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= NO Vol");
      VolumeNO();
        break;
      case DIR_FAR:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= C 48");
      Canale48();
        break;
      default:
      lcd.clear();
      lcd.setCursor(0,1);
      lcd.print("LastCom= NONE !");
    }
  }
}

RTC e Beaglebone Black

 

Beh, e' un po' che non aggiorno piu' il sito, ma  questo non significa che sono rimasto fermo senza fare nulla, anzi!
In questo periodo ho messo le mani su tanti progetti nuovi, dei quali, uno per volta, vi rendero' partecipi.
Per oggi parliamo di aggiungere la RTC alla Beaglebone.
Verso le 11,30 di oggi, come sempre durante i sabati degli ultimi mesi, ero in chat su Skype con il mio compagno di avventura Simone e stavamo procedendo sul nostro progetto piu' importante di questo periodo che utilizza la Beaglebone Black come "cervello".
Durante la stesura del progetto, ci siamo accorti che poteva verificarsi la possibilita' che, in assenza di rete,  ci fosse un reboot del sistema, che avrebbe prodotto,  senza un adeguato circuito di mantenimento dell'ora, la perdita del date-time ed il suo reset alla data di sistema (alla data cioe' di quando e' stato generato il sistema).
 Questo ovviamente non va bene e deve essere corretto.
Da qui la scelta di montare una scheda RTC sul nostro sistema per far si che l'ora e la data di sistema venga mantenuta anche a sistema spento o fuori linea.
RTC, acronimo di Real Time Clock, e' una scheda con pochissimi componenti che utilizza un semplice integrato il DS1307     che funziona come orologio di sistema, ed al quale la macchina si riferisce per mantenere l'ora di sistema aggiornata al boot.
Quindi mi sono messo a rovistare nei cassetti ed ho tirato fuori la scheda RTC che sapevo di avere, quella della foto qui sopra.
 Il primo problema da risolvere per il collegamento della RTC in questione con la Beaglebone Black e' stato in ordine ai livelli di tensione in gioco, in quanto la Beaglebone Black lavora a 3 volt mentre la RTC che ho a disposizione e' fatta per lavorare a 5 volt. Non sarebbe un problema grave di per se, in quanto i livelli alto - basso sarebbero comunque compatibili, infatti lo stato "alto" sui pin SCL e SDA viene ottenuto con un a tensione che va da 2,2 a Vcc+0,3 Volts, quindi si potrebbe provare,  se non fossero previste le resistenze di pull-up  che mantengono lo stato delle porte sempre a 5Volts, la cui costanza pregiudicherebbe il funzionamento e potrebbe anche far danni irreparabili sulla nostra Beaglebone. Quindi altra ricerca frenetica nel fondo dei cassetti per individuare delle schedine che non ho mai utilizzato, ma che so' di avere.... vediamo..... ah, eccole,  ecco due bei  convertitori di livello. Queste schede sono proprio quelle che fanno al caso mio, servono per poter utilizzare, come nel mio caso, schede che funzionano a 5Volts con altre che invece hanno 3 volts come tensione di riferimento. Proprio quello che ci vuole.
Allora, montato il circuito con i jumper da test, ecco come si presenta la mia costruzione odierna:

A questo punto non resta che vedere se funziona.
Spento scollegato dalla alimentazione la Beaglebone Black, sono passato a cablare i cavi di alimentazione delle due schede collegate, i 5v per la la RTC e i 3v3 di alimentazione della scheda convertitore di livello, il GND e' in comune ( le tensioni sono tutte disponibili sulla GPIO della Beaglebone, come riportato sullo schema qui di fianco).

I segnali SDA ed SCL invece si trovano sui piedini numero 19-SCL e 20-SDA della GPIO. Appena collegato e alimentato il tutto sono andato a vedere se la BeagleBone "vede" la RTC e se riesce a ricevere i dati di date e time corretti facendo cosi:

Il comando per "vedere" se la periferica I2C comunica correttamente col sistema e'

i2cdetect -y -r 1

Tale comando che va dato con i poteri di root, fa parte di un pacchetto chiamato i2c-tools che in Arch linux (che e' il sistema che sto utilizzando in questo momento sulla BBB ) si istalla cosi:
pacman -S i2c-tools
Questo funziona in Arch, mentre in debian potrebbe gia' essere residente o, comunque, se previsto si potra' istallare con apt-get che e' il relativo gestore di pacchetti. Ma mi sto allontanando dal discorso iniziale, e torno subito in carreggiata.
Con il comando di cui sopra si ottiene uno specchietto dove all'indirizzo 68 si dovrebbe trovare la nostra periferica. Se si verifica questa situazione, la RTC comunica regolarmente con la BBB.

 A questo punto :
hwclock --debug   e' il cmando per vedere come il sistema recepisce l'ora dalla RTC, come si puo' vedere nella foto a fianco l'ora impostata in origine e' dell'anno 2000.

a questo punto con il comando      /usr/bin/ntpdate -b -s -u pool.ntp.org si aggiorna l'ora di sistema attraverso la lettura del server NTP

E poi  con     hwclock -w -f /dev/rtc0   si ottiene la scrittura dell'ora ricevuta dal server NTP nella eprom della RTC

Richiedendo quindi la lettura dell'ora all' hardware collegato, si ottiene adesso la corretta impostazione del date-time anche nella nostra RTC.