/*
 * Firmware 1.0 per Ricevitore Remoto Tektron - Progetto PSE-KT150
 * Autore: Stefano Bianchini
 * Azienda: SB-LAB (www.sb-lab.eu)
 * Licenza: GNU General Public License version 2 (GPL-2.0)
 *
 * Descrizione:
 * Questo firmware controlla le funzioni di un amplificatore a valvole KT150 single-ended parallelo,
 * ricostruito utilizzando il telaio di un amplificatore Tektron demolito. Il programma accetta input dal
 * telecomando infrarossi originale Tektron. Gestisce la fase di accensione dell'amplificatore impostando
 * un periodo di muto pre-riscaldamento, controlla il cambio dei canali e l'aggiustamento del volume tramite
 * gli input del telecomando e visualizza il canale attualmente selezionato su un tubo Nixie originariamente
 * integrato nell'amplificatore Tektron. Il programma include una funzione per prevenire l'avvelenamento del
 * catodo del tubo Nixie.
 *
 * Description:
 * This firmware controls the functions of a KT150 single-ended parallel valve amplifier,
 * reconstructed using the chassis of a Tektron remolito amplifier. The program accepts input from the
 * original Tektron infrared remote control. It manages the amplifier's power-up phase by setting a
 * pre-heating mute period, controls channel changes and volume adjustments via remote control inputs, and
 * displays the currently selected channel on a Nixie tube originally integrated into the Tektron amplifier.
 * The program includes a function to prevent cathode poisoning of the Nixie tube.
 * 
 * Nota sulla Licenza / License Notice:
 * Questo software è distribuito con la Licenza Pubblica Generale GNU versione 2 (GPL-2.0).
 * Ciò significa che sei libero di utilizzare, modificare e distribuire questo software in base ai termini
 * della GPL-2.0. Ogni modifica apportata al codice deve essere resa pubblica e deve includere una nota
 * indicante le modifiche effettuate. Ogni distribuzione del codice deve includere questa nota sulla licenza
 * e preservare i riferimenti all'autore originale.
 *
 * This software is distributed under the GNU General Public License version 2 (GPL-2.0).
 * This means that you are free to use, modify, and distribute this software under the terms of the GPL-2.0.
 * Any modifications made to the code must be made public and include a note indicating the changes made.
 * Any distribution of the code must include this license notice and preserve the references to the original author.
 *
 * Contattami / Contact Me:
 * Per eventuali domande o miglioramenti al codice, puoi contattarmi all'indirizzo:
 * https://www.sb-lab.eu/mandami-una-e-mail/
 */

#include <Arduino.h>
/* compilare in presenza della libreria IRRemote 4.20 */
#include <IRremote.hpp>

/* pin associato al ricevitore infrarosso */
#define IR_RECEIVE_PIN 2

/* Adatta il ricevitore IR, un valore di 20 è consigliato per il ricevitore recuperato dal tektron, valore diversi causano ricezione di dati casuali */
#define MARK_EXCESS_MICROS 20
/* definisco le stringhe che rappresentano i tasti */
#define tasto_meno 0xF6093A00
#define tasto_piu 0xEA153A00
#define tasto_on_off 0xF20D3A00
#define ripeti 0
/* definisco i pin dei rele' degli ingressi */
#define rel1 3
#define rel2 4
#define rel3 5

/* pin che controllano il demultiplexer MC14067b */
#define nix_A 9     /* pin 10 MC14067b */
#define nix_B 10    /* pin 11 MC14067b */
#define nix_C 11    /* pin 14 MC14067b */
#define nix_D 12    /* pin 13 MC14067b */
#define nix_EN 14   /* pin 15 MC14067b */

/* pin che controllano il driver motore L293D */
#define motor_up 8
#define motor_down 7

/* led integrato nel pulsante di accensione */
#define power_led 6

/* codici telecomando */
unsigned long value;
unsigned long old_value;

/* memoria canali*/
unsigned char canale = 1;

/* variabili per timer non bloccante usato per il controllo fluido del motore */
unsigned char vol = 0;
unsigned int timer = 0;
/* costante per fludita' motore del volume */
#define nbdelay 12288

/* impostazioni del timer per la funzione disossida */
unsigned long ultimoRichiamo = 0;
unsigned long intervallo = 60000;  /* Intervallo di 1 minuti */

/* impostazione del timer mitigazione */
unsigned long ultimoRichiamo2 = 0;
unsigned long intervallo2 = 3000;  /* Intervallo di 3 secondi */

void setup()
{
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(power_led, OUTPUT);
    pinMode(rel1, OUTPUT);
    pinMode(rel2, OUTPUT);
    pinMode(rel3, OUTPUT);
    pinMode(motor_up, OUTPUT);
    pinMode(motor_down, OUTPUT);
    pinMode(nix_A, OUTPUT);
    pinMode(nix_B, OUTPUT);
    pinMode(nix_C, OUTPUT);
    pinMode(nix_D, OUTPUT);
    pinMode(nix_EN, OUTPUT);
    /* Abilita il lampeggio del led integrato che indica la ricezione di qualcosa, utile per debug */
    IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
    /* accende il led nel pulsante power */
    digitalWrite(power_led, HIGH);
    /* nixia spenta */
    digitalWrite(nix_EN, HIGH);
}

/* funzione che abbassa il volume quando si esce da un canale */
int fade_out()
{
  digitalWrite(motor_down, HIGH);
  /* durante l'uscita dal canale lampeggia il numero sulla nixia */
  for (char i = 0; i < 10; i++)
    {
      digitalWrite(nix_EN, HIGH);
      delay(500);
      digitalWrite(nix_EN, LOW);
      delay(500);
    }
  digitalWrite(motor_down, LOW);
}

/* funzione che rialza il volume quando si entra in un nuovo canale */
int fade_in()
{
  digitalWrite(motor_up, HIGH);
  delay(2000);
  digitalWrite(motor_up, LOW);
}

int cambia_canale()
{
  if(canale > 3) { canale = 1; }
  if(canale == 1) { fade_out(); digitalWrite(rel1, HIGH); digitalWrite(rel2, LOW); digitalWrite(rel3, LOW); scrivi_nixia(canale); fade_in(); }
  if(canale == 2) { fade_out(); digitalWrite(rel1, LOW); digitalWrite(rel2, HIGH); digitalWrite(rel3, LOW); scrivi_nixia(canale); fade_in(); }
  if(canale == 3) { fade_out(); digitalWrite(rel1, LOW); digitalWrite(rel2, LOW); digitalWrite(rel3, HIGH); scrivi_nixia(canale); fade_in(); }
  canale ++;
  ir_mon();
  delay(250);
}

/* Slampeggia il led power */
int ir_mon()
{
  digitalWrite(power_led, LOW);
  delay(50);
  digitalWrite(power_led, HIGH);
}

int motore(char tasto)
{
  if (tasto == '+' && vol == 0) /* Tasto Vol + */
    {
      ir_mon();
      vol = 1;
    }
  if (tasto == '+' && vol == 1) /* Tasto Vol + con pot in marcia */
    {
      ir_mon();
      timer = 0;
    }
  if (tasto == '-' && vol == 0) /* Tasto Vol - */
    {
      ir_mon();
      vol = 2;
    }
  if (tasto == '-' && vol == 2) /* Tasto Vol - con pot in marcia */
    {
      ir_mon();
      timer = 0;
    } 
}

/* questa funzione accetta in ingresso un valore da 0 a 16 e imposta i 4 bit all'ingresso del demultiplexer */
int scrivi_nixia(unsigned char cifra)
{
  digitalWrite(nix_A, (cifra & 0b0001) ? HIGH : LOW);
  digitalWrite(nix_B, (cifra & 0b0010) ? HIGH : LOW);
  digitalWrite(nix_C, (cifra & 0b0100) ? HIGH : LOW);
  digitalWrite(nix_D, (cifra & 0b1000) ? HIGH : LOW);
}

/* visto che la nixia per la maggiorparte del tempo visualzzera' sempre e solo i numeri 1-2-3 e questo potrebbe causare avvelenamento dei catodi
 * con la compromissione della nixia stessa, questa funzione richiamata ciclicamente fa una scansione
 * di tutte le cifre della nixia per evitarne il deterioramento precoce. */
int disossida()
{
  for (unsigned char i = 0; i < 10; i++) { scrivi_nixia(i); delay(125); }
  /* alla fine della scansione ripristina la cifra corretta che corrisponde al canale correntemente attivato */
  scrivi_nixia(canale - 1);
}

void loop()
{
  /* procedure di partenza */
  /* all'accensione gli ingressi sono tutti e 3 disattivati faccio lampeggiare lo zero sulla nixia per 40 secondi in attesa del riscaldamento
   * mentre lampeggia abbasso anche il volume a zero per evitare uragani alla partenza */
  scrivi_nixia(0);
  for (char i = 0; i < 40; i++)
    {
      digitalWrite(nix_EN, HIGH);
      delay(500);
      digitalWrite(nix_EN, LOW);
      delay(500);
    }
  digitalWrite(nix_EN, LOW);
  canale = 1;
  cambia_canale();
  /* l'amplificatore e' avviato, inizio un ciclo infinito dove leggo gli input del telecomando */
  for(;;)
  {
    /* Questa e' la funzione non bloccante che attiva ciclicamente la funzione per disossidare la nixia */
    unsigned long tempoCorrente = millis();
    /* Verifica se è passato un minuto dall'ultimo richiamo */
    if (tempoCorrente - ultimoRichiamo >= intervallo)
      {
        /* Richiama la funzione disossida */
        disossida();
        /* Aggiorna il tempo dell'ultimo richiamo */
        ultimoRichiamo = tempoCorrente;
      }
   /* Nota sul telecomando Tektron:
    * Il telecomando invia ripetutamente comandi zero ("0" ossia ripetizione) dopo l'invio del comando effettivo.
    * Questo comportamento, sebbene non ottimale, è una caratteristica intrinseca del telecomando Tektron.
    * Il problema principale sorge quando si preme un tasto e, per qualsiasi motivo, il primo impulso
    * non viene ricevuto correttamente, ma successivamente vengono ricevuti i comandi di ripetizione.
    * Questo può causare un comportamento indesiderato, poiché il programma interpreta erroneamente
    * gli zeri come la ripetizione dell'ultimo comando ricevuto correttamente anche se diverso dal tasto effettivamente premuto.
    * Per mitigare questo problema, è stato implementato un timeout di 10 secondi nel programma
    * che interrompe qualsiasi azione in corso se non viene ricevuto alcun comando durante tale periodo.
    * È importante notare che questa mitigazione potrebbe non essere completamente efficace
    * se vengono premuti tasti diversi molto velocemente, perche' finche' non scadono i 3 secondi la variabile old_value non viene azzerata
    * e quindi il problema potrebbe presentarsi, questa mitigazione interrompe anche la corsa del potenziometro del volume in corsa */
    
    /* codice della mitigazione*/
    unsigned long tempoCorrente2 = millis();
    /* Verifica se è passato un minuto dall'ultimo richiamo */
    if (tempoCorrente2 - ultimoRichiamo2 >= intervallo2)
      {
        old_value = 0;
        /* Aggiorna il tempo dell'ultimo richiamo */
        ultimoRichiamo2 = tempoCorrente2;
      }
    /* fine del codice della mitigazione */
    
    if (IrReceiver.available())
      {
        if (IrReceiver.decode())
        {
            /* memorizza il valore RAW nel buffer value */
            value = IrReceiver.decodedIRData.decodedRawData;
            /*  il telecomando manda il codice pulsante solo al primo impulso, dopo continua a inviare degli zero che significano "ripetizione dello stesso
             *  tasto", questa funzione che ricopia il registro value in old_value serve per richiamare l'ultima routines richiamata in caso il codice ricevuto
             *  sia zero */
            if(value == tasto_meno)
              { 
                /* memorizza value in old_value */
                old_value = value;
              }
            if(value == tasto_piu)
              {
                /* memorizza value in old_value */
                old_value = value;
              }
            /* utilizzo il tasto on/off del telecomando per cambiare i canali */
            if(value == tasto_on_off)
              {
                /* memorizza value in old_value */
                old_value = value;
              }
            /* richiamo la funzione legata al tasto premuto memorizzato, gestisco i segnali di ripetizione e discrimino eventuali segnali errati */
            if ((old_value == tasto_meno && value == ripeti) || (old_value == tasto_meno && value == tasto_meno))
              {
                motore('-');
              }
            if((old_value == tasto_piu && value == ripeti) || (old_value == tasto_piu && value == tasto_piu))
              {
                motore('+');
              }
            if(old_value == tasto_on_off && value == tasto_on_off)
              {
                cambia_canale();
              }
            /* prepara il ricevitore per un nuovo ciclo */
            IrReceiver.resume();
        }
    }
  /* funzione per rendere fluido l'andamento del volume con timer non bloccante */
  if(vol == 1 && timer < nbdelay)
    {
      digitalWrite(motor_up, HIGH);
      timer ++;
    }
  if(vol == 2 && timer < nbdelay)
    {
      digitalWrite(motor_down, HIGH);
      timer ++;
    }
  if(timer >= nbdelay)
    {
      digitalWrite(motor_up, LOW);
      digitalWrite(motor_down, LOW);
      vol = 0;
      timer = 0;
    }
  /* Fine funzione timer non bloccante */
  }
}