Settaggio orologio

International Italiano Software
1

Ciao,
l'aurduino che ho messo in piedi gestisce l'apertura temporizzata di varie mangiatoie
Chiaramente il tutto si basa sull'ora e per questo ho inserito una batteria tampone nel caso venga tolta la corrente per mantenere data e ora..
Il problema è che ho trovato la situazione come da foto (valori a casaccio e tutto bloccato)
Ho ripristinato 'manualmente' resettando data e ora da specifica funzione del softwatre.
A parte che non mi risulta sia andata via la corrente, ma ho provato a spegnere il tutto per più di 4 ore e una volta riacceso data e ora sono risultate corrette (pensavo che la batteria non tenesse).
Quindi mi domandavo se qualcuno può aver idea di cosa sia successo e soprattutto se la cosa sia risolvibile
Grazie mille

PS come si inserisce una foto ? :thinking:

2

ci dovrebbe essere un pulsante "carica" vicino a quello dei tag per inserire il codice...

3

Errore
Errore600×800 63.8 KB

4

Data Astrale Sab.03-Mar-2099 52.36.106.
Che e Star Treck. :crazy_face:

Se hai trovato tutto bloccato, quasi certamente è colpa della cattiva gestione degli array.

Ciao.

5

Se effettivamente fosse un problema di array e non essendo io proprio un mago della programmazione .. :pensive:
Ci sarebbe qualche buon'anima che darebbe un occhio al sorgente se lo posto ? :blush:
Grazie mille

6

Solo come curiosita', le mangiatoie sono azionate da motori o elettromagneti ? ... tutta la parte degli azionamenti e' ben filtrata e non introduce disturbi verso Arduino ? (che potrebbe essere andato in tilt anche per quelli :wink:)

1 Like
7

Oltre al programma anche lo schema

8

i motori sono:

  • 2 motori elettrici da 220 v. (motori che alzano e abbassano una tapparella)
  • 2 pistoncinio a 12 volt (attualmente non ancora collegati) per apertura botole
    Come si filtra per evitare che entrino disturbi verso Arduino ?
    Grazie

Non so esattamente cosa si intenda in concreto per schema ..
In soldoni ci sono:

  • 4 relè che azionano i 4 motori
  • 4 interruttori (con relatvi 4 led) che rendono 'attiva' o meno la programmazione
  • 4 pulsanti per l'apertura 'manuale' delle mangiatoie
    (per i 2 motori a 220 v. doppi pulsanti visto che c'è salita e discesa della tapparella)
  • scheda mp3, per attivare in anticipo rispetto all'apertura delle mangiatoie, una suoneria di avviso apertura
9

Programma ..


//
// arduino maxi
//
// 


// INDIRIZZI I2C:
// 50  -> DISPLAY
// 68  -> OROLOGIO

//includo la libreria per la
//comunicazione su bus I2C
#include <Wire.h>

//includo libreria eeprom
#include <EEPROM.h>

#include <LiquidCrystal.h>

#define BUTTON    A0
#define BACKLIGHT 10

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

//

#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"

SoftwareSerial aa(12, 13); // RX, TX ok Arduino MAXI
DFRobotDFPlayerMini Mp3;
 
//--------------------------------------------------------
//variabili
//--------------------------------------------------------

byte EE_S1_HH_ON     = 0;
byte EE_S1_MM_ON     = 0;
int  S1_HH_ON        = 0;
int  S1_MM_ON        = 0;

byte EE_S2_HH_ON     = 0;
byte EE_S2_MM_ON     = 0;
int  S2_HH_ON        = 0;
int  S2_MM_ON        = 0;

byte EE_M1_HH_ON     = 0;
byte EE_M1_MM_ON     = 0;
int  M1_HH_ON        = 0;
int  M1_MM_ON        = 0;

byte EE_M2_HH_ON     = 0;
byte EE_M2_MM_ON     = 0;
int  M2_HH_ON        = 0;
int  M2_MM_ON        = 0;

//-------------

byte EE_S1S2_TIME_ON = 0;
int  S1S2_TIME_ON    = 0;

byte EE_lumlcd       = 1;
int  lumlcd          = 1;


int ds_ora = 0;
int ds_min = 0;
int ds_sec = 0;
int ds_gse = 0;
int ds_gme = 0;
int ds_mes = 0;
int ds_ann = 0;

                            
int pin_M1       = 17;       
int pin_M2       = 16;       
int pin_S1_UP    = 15;       
int pin_S2_UP    = 14;       

int pin_led_S1   = 53;
int pin_led_S2   = 51;
int pin_led_M1   = 49;
int pin_led_M2   = 47;

int funzione     = 0;
char funzione_hhmm = 'H';

int funz_ss      = 0;  // 
int funz_hh      = 0;
int funz_mm      = 0;
int funz_gg      = 1;
int funz_me      = 1;
int funz_aa      = 20;
int funz_manuale = 0;
int funz_lumlcd  = 0;

int oradatadisp  = 0;

int beep_inizio_S1 = 0;
int beep_inizio_S2 = 0;

int beep_inizio_M1 = 0;
int beep_inizio_M2 = 0;

int pulsanteA2   = 0;
int pulsanteA1   = 0;

int P_LEFT      = 0;
int P_RIGHT     = 0;
int P_UP        = 0;
int P_DOWN      = 0;
int P_SELECT    = 0;

int pulsante_LEFT   = 0;
int pulsante_RIGHT  = 0;
int pulsante_UP     = 0;
int pulsante_DOWN   = 0;
int pulsante_SELECT = 0;

int I_M1       = 0;
int I_M2       = 0;
int I_S1       = 0;
int I_S2       = 0;

long lumlcdpwm = 0;

int S1_OK = 0;
int S2_OK = 0;
int M1_OK = 0;
int M2_OK = 0;

int video = 0;
int old_ds_sec = 0;
int flash = 0;

//----------------------------------------------------------
// Conversione normali numeri decimali in binario decimale
//----------------------------------------------------------

byte decToBcd(byte val)
{
  return ( (val / 10 * 16) + (val % 10) );
}

//----------------------------------------------------------
// Conversione decimale binario a normali numeri decimali
//----------------------------------------------------------

byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}

//----------------------------------------------------------
// Calcolo secondi dalle 00:00:00
//----------------------------------------------------------

long totsecondi()
{
  return ((ds_ora * 3600) + (ds_min * 60) + ds_sec );
}

//----------------------------------------------------------
// Calcolo secondi dalle 00:00:00
//----------------------------------------------------------

long totminuti()
{
  return ((ds_ora * 60) + ds_min);
}

//----------------------------------------------------------
// Calcolo secondi dalle 00:00:00 + un GG
//----------------------------------------------------------

long totminuti_piu_1G()
{
  return ((ds_ora * 60) + ds_min + 1440);
}

//----------------------------------------------------------
//----------------------------------------------------------
//----  V O I D     S E T U P                           ----
//----------------------------------------------------------
//----------------------------------------------------------

void setup()
{
  Serial.begin(9600);
  aa.begin(9600);
  // inizializza scheda Mp3 
  Serial.println();
  //Serial.println(F("DFRobot DFPlayer Mini Demo"));
  //Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));


   if (!Mp3.begin(aa)) {  //Use softwareSerial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while(true);
   }
  // Serial.println(F("DFPlayer Mini online."));
   Mp3.volume(30); 

  // Serial.println(F("volume"));
//   Mp3.play(2);

  // Serial.println(F("comando play 1")); 
  //-------------------------------------------------------
  //definizione pin out
  //-------------------------------------------------------

  pinMode(pin_S1_UP , OUTPUT);
  pinMode(pin_S2_UP , OUTPUT);
  pinMode(pin_M1    , OUTPUT);
  pinMode(pin_M2    , OUTPUT);

  pinMode(pin_led_S1, OUTPUT);
  pinMode(pin_led_S2, OUTPUT);
  pinMode(pin_led_M1, OUTPUT);
  pinMode(pin_led_M2, OUTPUT);

    //definizione tipo LCD
  lcd.begin(16, 2);

 // //definizione protocollo trasmissione
 // Serial.begin(9600); 

  pinMode(A4, INPUT);
  pinMode(A3, INPUT);
  pinMode(A2, INPUT);
  pinMode(A1, INPUT);

 
  //copio dati accensioni durata

  EE_S1_HH_ON      = EEPROM.read(0);                   // orario apertura S1 HH
 // EE_S1_HH_ON      = 0;  
  S1_HH_ON         = EE_S1_HH_ON;

  EE_S1_MM_ON      = EEPROM.read(10);                  // orario apertura S1 MM
 // EE_S1_MM_ON      = 0;                               
  S1_MM_ON         = EE_S1_MM_ON;

  EE_S2_HH_ON      = EEPROM.read(1);                   // orario apertura S2
 // EE_S2_HH_ON      = 0;  
  S2_HH_ON         = EE_S2_HH_ON;

  EE_S2_MM_ON      = EEPROM.read(11);                  // orario apertura S2
 //  EE_S2_MM_ON      = 0; 
  S2_MM_ON         = EE_S2_MM_ON;

  EE_M1_HH_ON      = EEPROM.read(2);                   // orario apertura M1
  //  EE_M1_HH_ON      = 0; 
  M1_HH_ON         = EE_M1_HH_ON;

  EE_M1_MM_ON      = EEPROM.read(12);                  // orario apertura M1
  //   EE_M1_MM_ON      = 0;
  M1_MM_ON         = EE_M1_MM_ON;

  EE_M2_HH_ON      = EEPROM.read(3);                   // orario apertura M2
  //  EE_M2_HH_ON      = 0; 
  M2_HH_ON         = EE_M2_HH_ON;

  EE_M2_MM_ON      = EEPROM.read(13);                  // orario apertura M2
  //   EE_M2_MM_ON      = 0;
  M2_MM_ON         = EE_M2_MM_ON;


  EE_S1S2_TIME_ON  = EEPROM.read(4);                  // tempo sollevamento saraccinesche
  //   EE_S1S2_TIME_ON  = 13;
  S1S2_TIME_ON     = EE_S1S2_TIME_ON;

  EE_lumlcd        = EEPROM.read(6);                  // luminosità display
  //   EE_lumlcd = 5;
  lumlcd           = EE_lumlcd;

  //--------------------------------------------------------
  //impostazione orario
  //--------------------------------------------------------

  //inizializzo la libreria (reset timer)

  Wire.begin();

   /*
  ds_ora = 23;
  ds_min = 59;
  ds_sec = 0;
  ds_gse = 1;
  ds_gme = 20;
  ds_mes = 04;
  ds_ann = 23;

  //attivo la comunicazione con il DS1307
  //l'indirizzo dell'RTC è 0x68
  Wire.beginTransmission(0x68);
  //il primo byte stabilisce il registro
  //iniziale da scivere
  Wire.write((byte)0x00);
  //specifico il tempo e la data
  Wire.write(decToBcd(ds_sec));              //1° byte SECONDI da 0x00 a 0x59
  Wire.write(decToBcd(ds_min));              //2° byte MINUTI da 0x00 a 0x59
  Wire.write((byte)0x80 | decToBcd(ds_ora)); //3° byte ORE da 0x00 a 0x24
  Wire.write(decToBcd(ds_gse));              //4° byte GIORNO della settimana da 0x01 a 0x07
  Wire.write(decToBcd(ds_gme));              //5° byte GIORNO del mese da 0x00 a 0x31
  Wire.write(decToBcd(ds_mes));              //6° byte MESE da 0x00 a 0x12
  Wire.write(decToBcd(ds_ann));              //7° byte ANNO 0x00 a 0x99
  Wire.endTransmission();
   */

  //--------------------------------------------------------
  // lettura DS1307 fuori ciclo
  // inizializza la trasmissione partendo dall'indirizzo 0x00
  //--------------------------------------------------------

  Wire.beginTransmission(0x68);
  Wire.write((byte)0x00);
  Wire.endTransmission();

  //richiedo 7 byte dal dispositivo con indirizzo 0x68

  Wire.requestFrom(0x68, 7);

  //recupero i 7 byte relativi ai corrispondenti registri

  ds_sec = bcdToDec(Wire.read());
  ds_min = bcdToDec(Wire.read());
  ds_ora = bcdToDec(Wire.read());
  ds_gse = bcdToDec(Wire.read());
  ds_gme = bcdToDec(Wire.read());
  ds_mes = bcdToDec(Wire.read());
  ds_ann = bcdToDec(Wire.read());

  //----- fine lettura DS1307
}

//----------------------------------------------------------
//----------------------------------------------------------
//----  V O I D     L O O P                             ----
//----------------------------------------------------------
//----------------------------------------------------------

void loop()
{
  //--------------------------------------------------------
  // FLASH
  //--------------------------------------------------------

  flash++;
  if (flash > 70)
  {
    flash = 0;
  }
  //--------------------------------------------------------
  // lettura DS1307
  // inizializza la trasmissione partendo dall'indirizzo 0x00
  //--------------------------------------------------------

  Wire.beginTransmission(0x68);
  Wire.write((byte)0x00);
  Wire.endTransmission();

  //richiedo 7 byte dal dispositivo con indirizzo 0x68

  Wire.requestFrom(0x68, 7);

  //recupero i 7 byte relativi ai corrispondenti registri

  ds_sec = bcdToDec(Wire.read());
  ds_min = bcdToDec(Wire.read());
  ds_ora = bcdToDec(Wire.read());
  ds_gse = bcdToDec(Wire.read());
  ds_gme = bcdToDec(Wire.read());
  ds_mes = bcdToDec(Wire.read());
  ds_ann = bcdToDec(Wire.read());

  //----- fine lettura DS1307

  //--------------------------------------------------------
  // gestione luminosità display
  //--------------------------------------------------------

  lumlcdpwm = lumlcd * 25;
  analogWrite(BACKLIGHT, lumlcdpwm);

  //--------------------------------------------------------
  // gestione Tasti
  //--------------------------------------------------------

  //Serial.print("lettura tasti display");

  P_LEFT   = 0;
  P_RIGHT  = 0;
  P_UP     = 0;
  P_DOWN   = 0;
  P_SELECT = 0;

  if ((analogRead(BUTTON) >= 0  ) && (analogRead(BUTTON) < 50))
  {
    P_RIGHT  = 1;
  }
  if ((analogRead(BUTTON) >= 50 ) && (analogRead(BUTTON) < 200))
  {
    P_UP     = 1;
  }
  if ((analogRead(BUTTON) >= 200) && (analogRead(BUTTON) < 350))
  {
    P_DOWN   = 1;
  }
  if ((analogRead(BUTTON) >= 350) && (analogRead(BUTTON) < 595))
  {
    P_LEFT   = 1;
  }
  if ((analogRead(BUTTON) >= 595) && (analogRead(BUTTON) < 765))
  {
    P_SELECT = 1;
  }

  // pin interruttori
  // A4
  // A3
  // A2
  // A1
  //  gestione led
  // S1 -->> A2 

  if (digitalRead(A2) == HIGH)
  { I_S1 = 1;
    digitalWrite(pin_led_S1, LOW);
  }
  else
  { I_S1 = 0;
    digitalWrite(pin_led_S1, HIGH);
  }

  // S2 -->> A3

  if (digitalRead(A3) == HIGH)
  { I_S2 = 1;
    digitalWrite(pin_led_S2, LOW);
  }
  else
  { I_S2 = 0;
    digitalWrite(pin_led_S2, HIGH);
  }

  // M1 -->> A5
  
  if (digitalRead(A5) == HIGH)
  { I_M1 = 1;
    digitalWrite(pin_led_M1, LOW);
  }
  else
  { I_M1 = 0;
    digitalWrite(pin_led_M1, HIGH);
  }

  // M2 -->> A4

  if (digitalRead(A4) == HIGH)
  { I_M2 = 1;
    digitalWrite(pin_led_M2, LOW);
  }
  else
  { I_M2 = 0;
    digitalWrite(pin_led_M2, HIGH);
  }

  //---------------------------------------------
  //-- gestione pulsanti                       --
  //-- pulsante A0 scelta funzione             --
  //-- pulsante A1 set ++                      --
  //-- pulsante A2 set --                      --
  //-- pulsante A3 ok impostazione             --
  //---------------------------------------------
  //---------------------------------------------
  //-- gestione pulsanti
  //  P_LEFT   scelta --
  //  P_RIGHT  scelta ++
  //  P_UP     set ++
  //  P_DOWN   set --
  //  P_SELECT ok imposta
  //---------------------------------------------


  //-------------------------------------
  //-- pulsante RIGHT                  --
  //-------------------------------------

  //--> Posizionamento
  if (P_RIGHT == 1)
  { if (pulsante_RIGHT == 0)
    { funzione++;
      //Serial.print(funzione);
      if (funzione == 5)
      {
        funz_hh = ds_ora;
      }

      funz_ss     = S1S2_TIME_ON;
      funz_mm     = ds_min;
      funz_gg     = ds_gme;
      funz_me     = ds_mes;
      funz_aa     = ds_ann;
      funz_lumlcd = lumlcd;

      //-> pulizia campo da 'H' (per non incidere su incremento/dedcremento MINUTI)
      funzione_hhmm = ' ';

      if (funzione == 1)
      { funzione_hhmm = 'H';
        funz_hh = S1_HH_ON;
        funz_mm = S1_MM_ON;
      }

      if (funzione == 2)
      { funzione_hhmm = 'H';
        funz_hh = S2_HH_ON;
        funz_mm = S2_MM_ON;
      }

      if (funzione == 3)
      { funzione_hhmm = 'H';
        funz_hh = M1_HH_ON;
        funz_mm = M1_MM_ON;
      }
      if (funzione == 4)
      { funzione_hhmm = 'H';
        funz_hh = M2_HH_ON;
        funz_mm = M2_MM_ON;
      }
    }
    pulsante_RIGHT = 1;

    if (funzione == 15)
    {
      funzione = 0;
    }
  }
  else
  {
    pulsante_RIGHT = 0;
  }

  //-------------------------------------
  //-- pulsante LEFT                   --
  //-------------------------------------

  //--> Posizionamento
  if (P_LEFT == 1)
  { if (pulsante_LEFT == 0)
    { funzione--;
      if (funzione == 5)
      {
        funz_hh = ds_ora;
      }

      funz_ss  = S1S2_TIME_ON;
      funz_mm  = ds_min;
      funz_gg  = ds_gme;
      funz_me  = ds_mes;
      funz_aa  = ds_ann;
      funz_lumlcd = lumlcd;

      //-> pulizia campo da 'H' (per non incidere su incremento/dedcremento MINUTI)
      funzione_hhmm = ' ';

      if (funzione == 1)
      { funzione_hhmm = 'H';
        funz_hh = S1_HH_ON;
        funz_mm = S1_MM_ON;
      }

      if (funzione == 2)
      { funzione_hhmm = 'H';
        funz_hh = S2_HH_ON;
        funz_mm = S2_MM_ON;
      }

      if (funzione == 3)
      { funzione_hhmm = 'H';
        funz_hh = M1_HH_ON;
        funz_mm = M1_MM_ON;
      }

      if (funzione == 4)
      { funzione_hhmm = 'H';
        funz_hh = M2_HH_ON;
        funz_mm = M2_MM_ON;
      }
    }
    pulsante_LEFT = 1;

    if (funzione < 0)
    {
      funzione = 15;
    }
  }
  else
  {
    pulsante_LEFT = 0;
  }

  //-------------------------------------
  //-- pulsante UP                     --
  //-------------------------------------

  if (P_UP == 1)
  { if (pulsante_UP == 0)
    {
      //Serial.print(funzione_hhmm);

      funz_ss++;
      funz_hh++;
      // 'H' solo nel caso di variazione H dell'orario 4 motori (non cambio i M)
      if (funzione_hhmm != 'H')
      {
        funz_mm++;
      }
      funz_gg++;
      funz_me++;
      funz_aa++;
      funz_lumlcd++;

      pulsante_UP = 1;

      if (funz_ss == 100)
      {
        funz_ss = 0;
      }

      if (funz_hh == 24)
      {
        funz_hh = 0;
      }

      if (funz_mm == 60)
      {
        funz_mm = 0;
      }

      if (funz_gg == 32)
      {
        funz_gg = 1;
      }

      if (funz_me == 13)
      {
        funz_me = 1;
      }

      if (funz_aa == 100)
      {
        funz_aa = 20;
      }

      if (funz_lumlcd  > 10)
      {
        funz_lumlcd = 0;
      }
    }
  }
  else
  {
    pulsante_UP = 0;
  }

  //-------------------------------------
  //-- pulsante DOWN                   --
  //-------------------------------------

  if (P_DOWN == 1)
  { if (pulsante_DOWN == 0)
    {
      //Serial.print(funzione_hhmm);
      funz_ss--;
      funz_hh--;
      // 'H' solo nel caso di variazione H dell'orario 4 motori (non cambio i M)
      if (funzione_hhmm != 'H')
      {
        funz_mm--;
      }
      funz_gg--;
      funz_me--;
      funz_aa--;
      funz_lumlcd--;

      pulsante_DOWN = 1;

      if (funz_ss < 0)
      {
        funz_ss = 99;
      }

      if (funz_hh < 0)
      {
        funz_hh = 23;
      }

      if (funz_mm < 0)
      {
        funz_mm = 59;
      }

      if (funz_gg < 1)
      {
        funz_gg = 31;
      }

      if (funz_me < 1)
      {
        funz_me = 12;
      }

      if (funz_aa < 16)
      {
        funz_aa = 99;
      }

      if (funz_lumlcd  < 1)
      {
        funz_lumlcd = 10;
      }
    }
  }
  else
  {
    pulsante_DOWN = 0;
  }

  //-------------------------------------
  //-- pulsante SELECT                 --
  //-------------------------------------


  if (P_SELECT == 1 )
  { if (pulsante_SELECT == 0)
    { pulsante_SELECT = 1;

      //-------------------------------------
      // imposta scelte effettuate
      //----------------------------------------------

      //----------------------------------------------
      //-- imposto S1  on
      //----------------------------------------------
      if (funzione == 1)
      { if (funzione_hhmm == 'H')
        { S1_HH_ON        = funz_hh;
          funzione_hhmm   = 'M';
        }
        else
        { S1_MM_ON        = funz_mm;
          funzione_hhmm   = 'H';
          funzione        = 0;
        }

        EE_S1_HH_ON  = S1_HH_ON ;
        EEPROM.write(0, EE_S1_HH_ON );
        EE_S1_MM_ON  = S1_MM_ON ;
        EEPROM.write(10, EE_S1_MM_ON );
      }

      //----------------------------------------------
      //-- imposto S2 on
      //----------------------------------------------
      if (funzione == 2)
      { if (funzione_hhmm == 'H')
        { S2_HH_ON        = funz_hh;
          funzione_hhmm   = 'M';
        }
        else
        { S2_MM_ON        = funz_mm;
          funzione_hhmm   = 'H';
          funzione        = 0;
        }

        EE_S2_HH_ON  = S2_HH_ON ;
        EEPROM.write(1, EE_S2_HH_ON );
        EE_S2_MM_ON  = S2_MM_ON ;
        EEPROM.write(11, EE_S2_MM_ON );
      }

      //----------------------------------------------
      //-- imposto M1 on
      //----------------------------------------------

      if (funzione == 3)
      { if (funzione_hhmm == 'H')
        { M1_HH_ON        = funz_hh;
          funzione_hhmm   = 'M';
        }
        else
        { M1_MM_ON        = funz_mm;
          funzione_hhmm   = 'H';
          funzione        = 0;
        }

        EE_M1_HH_ON  = M1_HH_ON ;
        EEPROM.write(2, EE_M1_HH_ON );
        EE_M1_MM_ON  = M1_MM_ON ;
        EEPROM.write(12, EE_M1_MM_ON );
      }
      //----------------------------------------------
      //-- imposto M2 on
      //----------------------------------------------

      if (funzione == 4)
      { if (funzione_hhmm == 'H')
        { M2_HH_ON        = funz_hh;
          funzione_hhmm   = 'M';
        }
        else
        { M2_MM_ON        = funz_mm;
          funzione_hhmm   = 'H';
          funzione        = 0;
        }

        EE_M2_HH_ON  = M2_HH_ON ;
        EEPROM.write(3, EE_M2_HH_ON );
        EE_M2_MM_ON  = M2_MM_ON ;
        EEPROM.write(13, EE_M2_MM_ON );
      }

      //----------------------------------------------
      //-- imposto Orologio
      //----------------------------------------------

      if (funzione == 5 || funzione == 6 || funzione == 7 || funzione == 8 || funzione == 9)
      { if (funzione == 5)
        {
          ds_ora = funz_hh;
        }
        if (funzione == 6)
        {
          ds_min = funz_mm;
        }
        if (funzione == 7)
        {
          ds_gme = funz_gg;
        }
        if (funzione == 8)
        {
          ds_mes = funz_me;
        }
        if (funzione == 9)
        {
          ds_ann = funz_aa;
        }

        //inizializzo la libreria OROLOGIO
        Wire.begin();
        //attivo la comunicazione con il DS1307
        //l'indirizzo dell'RTC è 0x68
        Wire.beginTransmission(0x68);
        //il primo byte stabilisce il registro
        //iniziale da scivere
        Wire.write((byte)0x00);
        //specifico il tempo e la data
        Wire.write(decToBcd(ds_sec));              //1° byte SECONDI da 0x00 a 0x59
        Wire.write(decToBcd(ds_min));              //2° byte MINUTI da 0x00 a 0x59
        Wire.write((byte)0x80 | decToBcd(ds_ora)); //3° byte ORE da 0x00 a 0x24
        Wire.write(decToBcd(ds_gse));              //4° byte GIORNO della settimana da 0x01 a 0x07
        Wire.write(decToBcd(ds_gme));              //5° byte GIORNO del mese da 0x00 a 0x31
        Wire.write(decToBcd(ds_mes));              //6° byte MESE da 0x00 a 0x12
        Wire.write(decToBcd(ds_ann));              //7° byte ANNO 0x00 a 0x99
        Wire.endTransmission();

        funzione = 0;
      }

      //----------------------------------------------
      //-- imposto S1S2 TIME on
      //----------------------------------------------

      if (funzione == 10)
      { S1S2_TIME_ON     = funz_ss;
        EE_S1S2_TIME_ON  = funz_ss;
        EEPROM.write(4, S1S2_TIME_ON);
        funzione    = 0;
      }

      //----------------------------------------------
      //-- imposto luminosità display
      //----------------------------------------------
      if (funzione == 11)
      { lumlcd      = funz_lumlcd;
        EE_lumlcd   = funz_lumlcd;
        EEPROM.write(6, lumlcd);
        funzione    = 0;
      }

      //----------------------------------------------
      //-- Reset orologio
      //----------------------------------------------
      if (funzione == 12)
      {
        ds_ora = 20;
        ds_min = 30;
        ds_sec = 0;
        ds_gse = 1;
        ds_gme = 15;
        ds_mes = 06;
        ds_ann = 23;

        //attivo la comunicazione con il DS1307
        //l'indirizzo dell'RTC è 0x68
        Wire.beginTransmission(0x68);
        //il primo byte stabilisce il registro
        //iniziale da scivere
        Wire.write((byte)0x00);
        //specifico il tempo e la data
        Wire.write(decToBcd(ds_sec));              //1° byte SECONDI da 0x00 a 0x59
        Wire.write(decToBcd(ds_min));              //2° byte MINUTI da 0x00 a 0x59
        Wire.write((byte)0x80 | decToBcd(ds_ora)); //3° byte ORE da 0x00 a 0x24
        Wire.write(decToBcd(ds_gse));              //4° byte GIORNO della settimana da 0x01 a 0x07
        Wire.write(decToBcd(ds_gme));              //5° byte GIORNO del mese da 0x00 a 0x31
        Wire.write(decToBcd(ds_mes));              //6° byte MESE da 0x00 a 0x12
        Wire.write(decToBcd(ds_ann));              //7° byte ANNO 0x00 a 0x99
        Wire.endTransmission();
      }

      //----------------------------------------------
      //-- Test suoneria 'S' // 
      //----------------------------------------------
      if (funzione == 13)
      {
         Mp3.play(2);
      }

      //----------------------------------------------
      //-- Test suoneria 'M'
      //----------------------------------------------
      if (funzione == 14)
      {
          Mp3.play(1);
      }

    }
  }
  else
  {
    pulsante_SELECT = 0;
  }


  //---------------------------------------------
  //-- gestione LCD                     --------- 
  //---------------------------------------------

  if (funzione == 0)
  {
    lcd_funzione_0();
  }

  // --> 4 MOTORI
  if (funzione == 1)
  { lcd.setCursor(0, 0);
    lcd.print("Set S1 ON       ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (funzione_hhmm == 'H')
    { if (flash < 40)
      {
        lcdnumero00(funz_hh);
      }
      else
      {
        lcd.print("  ");
      }
      lcd.print(":");
      lcdnumero00(S1_MM_ON);
    }
    else
    { lcdnumero00(S1_HH_ON);
      lcd.print(":");
      if (flash < 40)
      {
        lcdnumero00(funz_mm);
      }
      else
      {
        lcd.print("  ");
      }
    }

    lcd.print("        ");
  }


  if (funzione == 2)
  { lcd.setCursor(0, 0);
    lcd.print("Set S2 ON       ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (funzione_hhmm == 'H')
    { if (flash < 40)
      {
        lcdnumero00(funz_hh);
      }
      else
      {
        lcd.print("  ");
      }
      lcd.print(":");
      lcdnumero00(S2_MM_ON);
    }
    else
    { lcdnumero00(S2_HH_ON);
      lcd.print(":");
      if (flash < 40)
      {
        lcdnumero00(funz_mm);
      }
      else
      {
        lcd.print("  ");
      }
    }
    lcd.print("        ");
  }

  if (funzione == 3)
  { lcd.setCursor(0, 0);
    lcd.print("Set M1 ON       ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (funzione_hhmm == 'H')
    { if (flash < 40)
      {
        lcdnumero00(funz_hh);
      }
      else
      {
        lcd.print("  ");
      }
      lcd.print(":");
      lcdnumero00(M1_MM_ON);
    }
    else
    { lcdnumero00(M1_HH_ON);
      lcd.print(":");
      if (flash < 40)
      {
        lcdnumero00(funz_mm);
      }
      else
      {
        lcd.print("  ");
      }
    }
    lcd.print("        ");
  }

  if (funzione == 4)
  { lcd.setCursor(0, 0);
    lcd.print("Set M2 ON       ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (funzione_hhmm == 'H')
    { if (flash < 40)
      {
        lcdnumero00(funz_hh);
      }
      else
      {
        lcd.print("  ");
      }
      lcd.print(":");
      lcdnumero00(M2_MM_ON);
    }
    else
    { lcdnumero00(M2_HH_ON);
      lcd.print(":");
      if (flash < 40)
      {
        lcdnumero00(funz_mm);
      }
      else
      {
        lcd.print("  ");
      }
    }
    lcd.print("        ");
  }

  // --> DATI DI SISTEMA  
  if (funzione == 5)
  { lcd.setCursor(0, 0);
    lcd.print("Set ora orologio");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_hh);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(ds_ora);
    lcd.print("     ");
  }

  if (funzione == 6)
  { lcd.setCursor(0, 0);
    lcd.print("Set min orologio");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_mm);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(ds_min);
    lcd.print("     ");
  }

  if (funzione == 7)
  { lcd.setCursor(0, 0);
    lcd.print("Set Giorno      ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_gg);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(ds_gme);
    lcd.print("     ");
  }

  if (funzione == 8)
  { lcd.setCursor(0, 0);
    lcd.print("Set Mese        ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_me);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(ds_mes);
    lcd.print("     ");
  }

  if (funzione == 9) // 
  { lcd.setCursor(0, 0);
    lcd.print("Set Anno        ");
    lcd.setCursor(0, 1);
    // lcd.print(" 20");
    if (flash < 40)
    {
      lcd.print(" 20");
      lcdnumero00(funz_aa);
    }
    else
    {
      lcd.print("     ");
    }
    lcd.print(" --> ");
    lcd.print("20");
    lcdnumero00(ds_ann);
    lcd.print(" ");
  }

  if (funzione == 10)
  { lcd.setCursor(0, 0);
    lcd.print("Set second S1 S2");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_ss);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(S1S2_TIME_ON);
    lcd.print("    ");
  }

  if (funzione == 11)
  { lcd.setCursor(0, 0);
    lcd.print("Set luminosita  ");
    lcd.setCursor(0, 1);
    lcd.print("   ");
    if (flash < 40)
    {
      lcdnumero00(funz_lumlcd);
    }
    else
    {
      lcd.print("  ");
    }
    lcd.print(" --> ");
    lcdnumero00(lumlcd);
    lcd.print("     ");
  }

  if (funzione == 12)
  { lcd.setCursor(0, 0);
    lcd.print("Reset Orologio  ");
    lcd.setCursor(0, 1);
    lcd.print("                ");
  }

  if (funzione == 13)
  { lcd.setCursor(0, 0);
    lcd.print("Test Suoner. 'S'");
    lcd.setCursor(0, 1);
    lcd.print("                ");
  }

  if (funzione == 14)
  { lcd.setCursor(0, 0);
    lcd.print("Test Suoner. 'M'");
    lcd.setCursor(0, 1);
    lcd.print("                ");
  }

  gestione_rele();
}

//---------------------------------------------
//-- GESTIONE RELE'                   ---------
//---------------------------------------------

void gestione_rele()
{
  if ((ds_ora == S1_HH_ON) && (I_S1 == 1))
  { if (ds_min == S1_MM_ON)
    {
      if  (beep_inizio_S1 == 0)
      {
        beep_S1();
      }

      if ((ds_sec > 10) && (ds_sec <= (S1S2_TIME_ON + 10)))
      {
        digitalWrite(pin_S1_UP, HIGH);
      }
      else
      {
        digitalWrite(pin_S1_UP, LOW);
      }
    }
  }
  else
  { digitalWrite(pin_S1_UP, LOW);
    beep_inizio_S1 = 0;
  }

  if ((ds_ora == S2_HH_ON) && (I_S2 == 1))
  { if (ds_min == S2_MM_ON)
    {
      if  (beep_inizio_S2 == 0)
      {
        beep_S2();
      }

      if ((ds_sec > 10) && (ds_sec <= (S1S2_TIME_ON + 10)))
      {
        digitalWrite(pin_S2_UP, HIGH);
      }
      else
      {
        digitalWrite(pin_S2_UP, LOW);
      }
    }
  }
  else
  { digitalWrite(pin_S2_UP, LOW);
    beep_inizio_S2 = 0;
  }


  if ((ds_ora == M1_HH_ON) && (I_M1 == 1))
  { if (ds_min == M1_MM_ON)
    {
      if  (beep_inizio_M1 == 0)
      {
        beep_M1();
      }

      if ((ds_sec > 10) && (ds_sec <= 12))
      {
        digitalWrite(pin_M1, HIGH);
      }
      else
      {
        digitalWrite(pin_M1, LOW);
      }
    }
  }
  else
  { digitalWrite(pin_M1, LOW);
    beep_inizio_M1 = 0;
  }

  if ((ds_ora == M2_HH_ON) && (I_M2 == 1))
  { if (ds_min == M2_MM_ON)
    {
      if  (beep_inizio_M2 == 0)
      {
        beep_M2();
      }

      if ((ds_sec > 10) && (ds_sec <= 12))
      {
        digitalWrite(pin_M2, HIGH);
      }
      else
      {
        digitalWrite(pin_M2, LOW);
      }
    }
  }
  else
  { digitalWrite(pin_M2, LOW);
    beep_inizio_M2 = 0;
  }
}

//----------------------------------------------------
// display a riposo
//----------------------------------------------------

void lcd_funzione_0()
{

  // ora_data(); 

  // gestione intermittenza ora /stato saracinesc

  intermittenza();
  if (oradatadisp == 1) {
    ora_data();
  }
  else if (oradatadisp == 2) {
    // ---> ORARIO APERTURE SARACINESCHE
    lcd.setCursor(0, 0);
    lcd.print( "S1 -> ");
    if ( I_S1 == 1 )
    {
      lcd.print( "ON  ");
    }
    else
    {
      lcd.print( "OFF ");
    }
    lcdnumero00(S1_HH_ON);
    lcd.print(":");
    lcdnumero00(S1_MM_ON);
    lcd.print(" ");

    lcd.setCursor(0, 1);
    lcd.print( "S2 -> ");
    if ( I_S2 == 1 )
    {
      lcd.print( "ON  ");
    }
    else
    {
      lcd.print( "OFF ");
    }
    lcdnumero00(S2_HH_ON);
    lcd.print(":");
    lcdnumero00(S2_MM_ON);
    lcd.print(" ");
  }
  else {
    // ---> ORARIO APERTURE MANGIATOIE
    lcd.setCursor(0, 0);
    lcd.print( "M1 -> ");
    if ( I_M1 == 1 )
    {
      lcd.print( "ON  ");
    }
    else
    {
      lcd.print( "OFF ");
    }
    lcdnumero00(M1_HH_ON);
    lcd.print(":");
    lcdnumero00(M1_MM_ON);
    lcd.print(" ");

    lcd.setCursor(0, 1);
    lcd.print( "M2 -> ");
    if ( I_M2 == 1 )
    {
      lcd.print( "ON  ");
    }
    else
    {
      lcd.print( "OFF ");
    }
    lcdnumero00(M2_HH_ON);
    lcd.print(":");
    lcdnumero00(M2_MM_ON);
    lcd.print(" ");
  }

}

//----------------------------------------------------
//  numero 00 lcd
//----------------------------------------------------

void lcdnumero00(int lcdnumero)
{
  if (lcdnumero < 10)
  {
    lcd.print("0");
  }

  lcd.print(lcdnumero, DEC);
}


//------------------------------------
// -- intermittenza
//------------------------------------
void intermittenza()
{
  // 1   9   -> 1    8 s
  // 9  15   -> 2    6 s
  // 15 21   -> 3    6 s

  // 21 29   -> 1    8 s
  // 29 35   -> 2    6 s
  // 35 41   -> 3    6 s

  // 41 49   -> 1    8 s
  // 49 55   -> 2    6 s
  // 55 61   -> 3    6 s

  if (((ds_sec >= 1 ) && (ds_sec <  9)) ||
      ((ds_sec >= 21) && (ds_sec < 29)) ||
      ((ds_sec >= 41) && (ds_sec < 49))
     )
  {
    oradatadisp = 1;
  }
  else if (((ds_sec >= 9 ) && (ds_sec < 15)) ||
           ((ds_sec >= 29) && (ds_sec < 35)) ||
           ((ds_sec >= 49) && (ds_sec < 55))
          )
  {
    oradatadisp = 2;
  }
  else if (((ds_sec >= 15) && (ds_sec < 21)) ||
           ((ds_sec >= 35) && (ds_sec < 41)) ||
           ((ds_sec >= 55) && (ds_sec < 61))
          )
  {
    oradatadisp = 3;
  }
  else
  {
    oradatadisp = 1;
  }
}

//------------------------------------
// -- intermittenza
//------------------------------------
void ora_data()

{
  // -> Riga 1
  lcd.setCursor(0, 0);
  giorno_lcd();
  lcd.print(" ");
  lcdnumero00(ds_gme);
  lcd.print("-");
  mese_lcd();
  lcd.print("-");
  lcd.print("20");
  lcdnumero00(ds_ann);
  lcd.print("     ");

  // -> Riga 2
  lcd.setCursor(0, 1);

  lcdnumero00(ds_ora);
  lcd.print(":");
  lcdnumero00(ds_min);
  lcd.print(":");
  lcdnumero00(ds_sec);
  lcd.print("        ");
}

//------------------------------------
// gestione giorno settimana lcd // 
//------------------------------------
void giorno_lcd()
{
  //Serial.print(ds_gse);

  if (ds_gse == 01)
  {
    lcd.print("Dom.");
  }
  if (ds_gse == 02)
  {
    lcd.print("Lun.");
  }
  if (ds_gse == 03)
  {
    lcd.print("Mar.");
  }
  if (ds_gse == 04)
  {
    lcd.print("Mer.");
  }
  if (ds_gse == 05)
  {
    lcd.print("Gio.");
  }
  if (ds_gse == 06)
  {
    lcd.print("Ven.");
  }
  if (ds_gse == 07)
  {
    lcd.print("Sab.");
  }
}


//------------------------------------
// gestione mese lcd
//------------------------------------
void mese_lcd()
{
  if (ds_mes == 1)
  {
    lcd.print("Gen");
  }
  if (ds_mes == 2)
  {
    lcd.print("Feb");
  }
  if (ds_mes == 3)
  {
    lcd.print("Mar");
  }
  if (ds_mes == 4)
  {
    lcd.print("Apr");
  }
  if (ds_mes == 5)
  {
    lcd.print("Mag");
  }
  if (ds_mes == 6)
  {
    lcd.print("Giu");
  }
  if (ds_mes == 7)
  {
    lcd.print("Lug");
  }
  if (ds_mes == 8)
  {
    lcd.print("Ago");
  }
  if (ds_mes == 9)
  {
    lcd.print("Set");
  }
  if (ds_mes == 10)
  {
    lcd.print("Ott");
  }
  if (ds_mes == 11)
  {
    lcd.print("Nov");
  }
  if (ds_mes == 12)
  {
    lcd.print("Dic");
  }
}

//------------------------------------
// suono S1
//------------------------------------
void beep_S1()
{
  //Serial.println(F("beep_S1"));
  Mp3.play(2);
  beep_inizio_S1 = 1;
}

//------------------------------------
// suono S2
//------------------------------------
void beep_S2()
{
  //Serial.println(F("beep_S2"));
  Mp3.play(2);
  beep_inizio_S2 = 1;
}

//------------------------------------
// suono M1
//------------------------------------
void beep_M1()
{
  //Serial.println(F("beep_M1"));
  Mp3.play(1);
  beep_inizio_M1 = 1;
}

//------------------------------------
// suono M2
//------------------------------------
void beep_M2()
{
  //Serial.println(F("beep_M2"));
  Mp3.play(1);
  beep_inizio_M2 = 1;
}
10

Ci risiamo ..
questo giro si è bloccato ad una delle 3 videate ad intermittenza

errore_2
errore_2600×800 54.6 KB

12

Violazione del punto15 (e suoi sottopunti) del REGOLAMENTO. Sapete benissimo che qui NON si parla di nulla e NON si chiede aiuto su nulla che opera oltre la bassissima tensione.

Discussione chiusa.

Guglielmo