Richiesta di aiuto agli Arduinauti.

Per risparmiare 54€ a bilanciatore ho provato a collegarlo a rotazione sui diversi banchi, con durata di inserimento di 2/3 gg. e il risultato č molto accettabile, contro 216€ di spesa.

Sito del produttore LINK


Bilanciatore con gruppi di 5 relay per ogni banco a rotazione, 2/3gg. a banco e rimangono con differenze di 0.05/0.08V ottimo.

Non serve il modulo RTC sarebbe sufficiente che un pulsante incrementasse e uno decrementasse di 86400000 millisecondi pari a 24 ore, non serve una precisione millimetrica.

Funzionamento:
Accende il primo gruppo relay, dopo 2 gg. spegne il gruppo realy e dopo 5 secondi accende il successivo che rimane eccitato per 2 gg. e cosě via all'infinito.

E' d'obbligo un minimo di display, i relay sono i soliti, i gruppi di 5 relay hanno il comando in parallelo, un'uscita per ogni gruppo, servono 4, 5 o 6 uscite, HIGH e LOW.

Un grazie anticipato, pronto per la sperimentazione perché ora scambio a mano ogni 2 gg.

Immagine Allegata: EQ.jpg
 

CITAZIONE

Secondo me, per quello che deve far lui, non serve l'RTC.

Se va via l'alimentazione (e con tutte le batterie che ha a disposizione mi sembra abbastanza difficile lasciare a piedi un semplice arduino...) e il ciclo riparte dal primo banco cosa mai succederŕ ??? Assolutamente nulla, che il primo banco sarŕ riequalizzato un po' prima e l'ultimo un po' dopo.

Ma non stiamo parlando di processi critici, semplice equalizzazione, quindi se tarda di qualche giorno non cambia nulla.

Claudio ma tu conosci arduino o sei a digiuno ?

Elix

Se spegni l'arduino, al successivo riavvio riparte dall'ultima ora memorizzata, quindi al massimo rimane un po' indietro. Funziona cosě bene che ho intenzione di non usare piů i modulini hardware e lasciare tutto al software e quando carichi il codice salva pure la data corrente in formato unixtime, quindi all'avvio data ed ora sono giŕ aggiornate. Per me l'unico problema pratico č nelle mancanza del circuito per la gestione della sonda termica che nell'RTC č giŕ incluso e quella sonda la uso per avviare una ventola di raffreddamento delle schede. Quindi dovrei costruire una piccola scheda per la ST oppure aggiungerla al circuito del pcb.

Elix scopiazzo qua e la e a volte riesco a mettere insieme le cose, mi basterebbe un contatore che mette alto il livello di una porta per tot. millisecondi, terminato il conteggio la mette bassa, attende 5000 milli e poi alza il livello della seconda e cosě via a rotazione, l'RTC l'ho ma non serve non penso di avere problemi di alimentazione e se si spegne riparte da capo amen.
Come se fossero 4/5/6 timer che a turno alzano il livello di una porta anche senza display e pulsantini di regolazione, l'importante č 5 secondi fra un banco e l'altro per lasciar resettare il bilanciatore, per iniziare va benissimo, poi se č efficace si implementa mano a mano.

Questo temporizza 4 uscite con il tempo di attesa per l'accensione della successiva, cosě va giŕ alla grande, evito il manuale, mi piacerebbe poter aggiungere un tastino che a ogni pressione aggiunge un giorno e uno che lo sottrae e magari con un display che ci informa del settaggio, tipo "HAI SETTATO 2 GIORNI" non serve che conti nulla, sarebbe il TOP.

int rele1 = 8;
int rele2 = 9;
int rele3 = 10;
int rele4 = 11;
 
void setup() {
  pinMode( rele1, OUTPUT );
  pinMode( rele2, OUTPUT );
  pinMode( rele3, OUTPUT );
  pinMode( rele4, OUTPUT );
   
  digitalWrite( rele1, LOW );
  digitalWrite( rele2, LOW );
  digitalWrite( rele3, LOW );
  digitalWrite( rele4, LOW );
}
 
void loop() {  
    digitalWrite( rele4, LOW ); //tempo di accensione per 24 ore 86400000
    delay( 2000 );              //tempo di attesa
    digitalWrite( rele1, HIGH );
    delay( 1000 );
    digitalWrite( rele1, LOW );
    delay( 2000 );
    digitalWrite( rele2, HIGH );
    delay( 1000 );
    digitalWrite( rele2, LOW );
    delay( 2000 );
    digitalWrite( rele3, HIGH );
    delay( 1000 );
    digitalWrite( rele3, LOW );
    delay( 2000 );
    digitalWrite( rele4, HIGH );
    delay( 1000 );
}

Di seguito il codice di sopra scritto in forma piů scalabile alle future modifiche:

int NumRele = 4;                                 // Numero di relč da gestire (da 1 a 8)
int i;
int Rele[8] = {4, 5, 6, 7, 8, 9, 10, 11};        // Pin di uscita dei relč

 
void setup()
{
  for (i = 0; i < NumRele; i++)                  
  {
    pinMode(Rele[i], OUTPUT);                    // Assegno le uscite
    digitalWrite(Rele[i], LOW);                  // Spengo i relč
  }
}
 
void loop()
{
  for (i = 0; i < NumRele; i++)
  {
    digitalWrite(Rele[i], HIGH);                 // Accendo il relč
    PausaOre(24);                                // Faccio una pausa di "n" ore
    
    digitalWrite(Rele[i], LOW);                  // Spengo il relč
    PausaSecondi(10);                            // Faccio una pausa di 10 secondi
  }
}

void PausaSecondi(int Secondi)
{
  delay(Secondi * 1000);
}

void PausaOre(int Ore)
{
  delay(Ore * 3600000);
}

MIIII il mio sembra scritto alle elementari!!!!!!

#include <LiquidCrystal_I2C.h>  
LiquidCrystal_I2C lcd(0x27, 16, 2);

int NumRele = 4;                                 // Numero di relč da gestire (da 1 a 8)
int i;
int Rele[8] = {4, 5, 6, 7, 8, 9, 10, 11};        // Pin di uscita dei relč

 
void setup()
{
  lcd.begin();
  lcd.backlight();
  lcd.clear();
  
  for (i = 0; i < NumRele; i++)                  
  {
    pinMode(Rele[i], OUTPUT);                    // Assegno le uscite
    digitalWrite(Rele[i], LOW);                  // Spengo i relč
  }
}
 
void loop()
{
  for (i = 0; i < NumRele; i++)
  {
    digitalWrite(Rele[i], HIGH);                 // Accendo il relč
    stampalcd();
    PausaOre(24);                                // Faccio una pausa di "n" ore
    
    digitalWrite(Rele[i], LOW);                  // Spengo il relč
    PausaSecondi(10);                            // Faccio una pausa di 10 secondi
  }

  
}

void PausaSecondi(int Secondi)
{
  delay(Secondi * 1000);
}

void PausaOre(int Ore)
{
  delay(Ore * 3600000);
}

void stampalcd(){
  lcd.home();
  lcd.noBlink();
  lcd.setCursor(0,0);
  lcd.print( "Rele' in uso: "); lcd.print(Rele[i]);
}

Grazie Calcola, e se usassimo questo display, che uscite potremmo usare??

Immagine Allegata: Oled.jpg
 

le stesse dell'altro sono tutti e due I2C, la libreria č diversa. Quello piů piccolo č un OLED, migliore del due righe 16 colonne.

//#include <LiquidCrystal_I2C.h>  
//LiquidCrystal_I2C lcd(0x27, 16, 2);
#include <MicroLCD.h>
LCD_SSD1306 lcd;

int NumRele = 4;                                 // Numero di relč da gestire (da 1 a 8)
int i;
int Rele[8] = {4, 5, 6, 7, 8, 9, 10, 11};        // Pin di uscita dei relč

 
void setup()
{
  //lcd.begin();
  //lcd.backlight();
  //lcd.clear();
   lcd.begin();  // apro LCD
  lcd.clear();  // cancello LCD
  
  for (i = 0; i < NumRele; i++)                  
  {
    pinMode(Rele[i], OUTPUT);                    // Assegno le uscite
    digitalWrite(Rele[i], LOW);                  // Spengo i relč
  }
}
 
void loop()
{
  for (i = 0; i < NumRele; i++)
  {
    digitalWrite(Rele[i], HIGH);                 // Accendo il relč
    stampalcd();
    PausaOre(24);                                // Faccio una pausa di "n" ore
    
    digitalWrite(Rele[i], LOW);                  // Spengo il relč
    PausaSecondi(10);                            // Faccio una pausa di 10 secondi
  }

  
}

void PausaSecondi(int Secondi)
{
  delay(Secondi * 1000);
}

void PausaOre(int Ore)
{
  delay(Ore * 3600000);
}

void stampalcd(){
  //lcd.home();
  //lcd.noBlink();
  lcd.setCursor(0,0);
  lcd.print( "Rele' in uso: "); lcd.print(Rele[i]);
}

Non piace la libreria MicroLCD.h al NANO

Questo il codice che dovrebbe fare ciň che chiede Claudio:

#include <MicroLCD.h>
LCD_SSD1306 lcd;


int NumRele = 4;                                                      // Numero di relč da gestire (da 1 a 8)
int Up = 2;                                                           // Pulsante per aumentare le ore
int Down = 3;                                                         // Pulsante per diminuire le ore
int Rele[8] = {4, 5, 6, 7, 8, 9, 10, 11};                             // Pin di uscita dei relč
unsigned long T_Equalizzazione = 24;                                  // Tempo di equalizzazione in ore per ogni banco
unsigned long T_Pausa = 10;                                           // Tempo di pausa, in secondi, per lo switch tra un banco e il successivo

 
void setup()
{
  lcd.begin();                                                        // Apro LCD
  lcd.clear();                                                        // Cancello LCD

  pinMode(Up, INPUT_PULLUP);                                          // Assegna l'ingresso Up
  pinMode(Down, INPUT_PULLUP);                                        // Assegno l'ingresso Dowm
  
  for (int i = 0; i < NumRele; i++)                  
  {
    pinMode(Rele[i], OUTPUT);                                         // Assegno le uscite
    digitalWrite(Rele[i], LOW);                                       // Spengo i relč
  }
}


void loop()
{
  boolean CicloOn = false;                                            // Dichiaro le variabili
  boolean CicloPausa = false;
  int ReleON = 1;
  unsigned long T_Start, T_Stop, T_Attuale, DeltaEqMillis, DeltaPausaMillis;

  T_Attuale = millis();                                               // Memorizzo il valore di millis() in una variabile per evitare problemi quando arriva al max e riparte da 0
  
  if (CicloOn == false)                                               // Avvio la fase di equalizzazione
  {
    T_Start = T_Attuale;                                              // Memorizzo quando sono partito
    digitalWrite(Rele[ReleON-1], HIGH);                               // Attivo il relč
    CicloOn = true;
    DeltaEqMillis = 0;
    DeltaPausaMillis = 0;
  }
  else
  {
    if (CicloPausa == false)
    {
      if (T_Attuale + DeltaEqMillis - T_Start > T_Equalizzazione * 3600000)           // Attendo il tempo impostato di equalizzazione
      {
        T_Stop = T_Attuale;                                           // Memorizzo l'inizio della pausa
        digitalWrite(Rele[ReleON-1], LOW);                            // Disattivo il relč
        CicloPausa = true;
      }
    }
    else
    {
      if (T_Attuale + DeltaPausaMillis - T_Stop > T_Pausa * 1000)                        // Attendo il tempo impostato di pausa
      {
        CicloOn = false;                                              // Reinizializzo le variabili per poter ripartire col banco successivo
        CicloPausa = false;
        if (ReleON == NumRele)
        {
          ReleON = 1;
        }
        else
        {
          ReleON++;
        }
      }
    }
  }

  if(T_Start > T_Attuale)                                             // se millis si resetta (dopo circa 50 gg)
  {
    DeltaEqMillis = 4294967295 - T_Start;
    T_Start = 0;
  }

  if(T_Stop > T_Attuale)                                              // se millis si resetta (dopo circa 50 gg)
  {
    DeltaPausaMillis = 4294967295 - T_Stop;
    T_Stop = 0;
  }

 
  if ((digitalRead(Up) == LOW) && (T_Equalizzazione < 98))            // Se non sto a 98 aumento le ore
  {
    T_Equalizzazione++;
    delay(200);
  }
  else if ((digitalRead(Down) == LOW) && (T_Equalizzazione > 1))      // Se non sto a 1 diminuisco le ore
  {
    T_Equalizzazione--;
    delay(200);
  }
  
  StampaLCD(ReleON, T_Equalizzazione, T_Attuale - T_Start);
  
}


void StampaLCD(int ReleON, int T_Eq, long T_Rest)
{
  lcd.setCursor(0,0);                                                 // Prima Riga, scrivo quale banco sto equalizzando
  lcd.print("Relč in uso: ");
  lcd.print(ReleON);

  lcd.setCursor(1,0);                                                 // Seconda Riga, scrivo il tempo di equalizzazione impostato
  lcd.print("Tempo Eq.: ");
  lcd.print(T_Eq);
  lcd.print(" Ore");

  lcd.setCursor(2,0);                                                 // Terza Riga, scrivo il tempo restante alla commutazione
  lcd.print("T. Restante: ");
  
  T_Rest = T_Rest / 60000;
  
  if (T_Rest < 60)
  {
    lcd.print(T_Rest);
    lcd.print(" Min");
  }
  else
  {
    lcd.print(T_Rest / 60);
    lcd.print(" Ore");
  }
}

Niente da fare, l'ho aggiunta a mano, ma non gli piace, ho provato anche con UNO e MEGA ma non gli piace.
Quel display lo uso giŕ come display remoto WiFi per il mio inverter ma usa questa libreria, non MicroLCD.h

#include SPI.h
#include Wire.h
#include Adafruit_GFX.h
#include adafruit_SSD1306.h

#include Fonts/FreeSans9pt7b.h
#include Fonts/FreeSansBold9pt7b.h

#define OLED_RESET LED_BUILTIN //4
Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2