[SirNino]

Ciao a tutti, ho creato una centralina con cui sto gestendo la mia vasca, pubblico questo articolo nella speranza che possa essere utile a qualcun altro e semplicemente per avere qualche consiglio/critica/miglioria.

COSA FA LA CENTRALINA:

- Gestione riscaldatore
- Gestione refrigeratore
- Osmoregolatore
- Gestione luce diurna
- Gestione luce notturna

IN LAVORAZIONE:

qua elencherò via via le nuove integrazioni e progetti che sto portando avanti


MATERILE:

- Arduino Mega2560
- Shield 8 rele 5V
- Alimentatore 5V
- Alimentatore 12V
- Scatola elettrica 8 fori Gewiss
- 8 biprese Gewiss
- 2 Sensori di temperatura basati su integrato DS1307
- Galleggiante

Tutto il resto è opzionale: bredboard, scatola per contenere il tutto, prese jack, ecc. io li ho usati perché avendo la centralina a vista preferivo che avesse un'immagine più gradevole.

Questo lo sketch, non è commentato perché è un copia/incolla del mio; nei prossimi giorni editerò il tutto coi commenti ma per il momento se volete chiarimenti chiedete.

//  ELENCO LIBRERIE UTILIZZATE - HO INSERITO GIA' ANCHE LIBRERIE CHE USERO' IN FUTURO

#include <OneWire.h>
#include <DallasTemperature.h> // GESTIONE DELLE TEMPERATURE
#include <DS1307.h> 
#include <OneWire.h>
#include <Wire.h>
#include <Time.h>
#include <TimeAlarms.h>  //  GESTIONE DEI TIMER
//#include <U8glib.h>  // GESTIONE DEL DISPLAY GRAFICO
#include <EEPROM.h>  //  GESTIONE DELLE MEMORIE - SALVIAMO ALCUNI DATI NELLE MEMORIE INTERNE DI ARDUINO PER RITROVARLI IN CASO DI SPEGNIMENTO O RIAVVIO

// INIZIALIZZAZIONE DI TUTTE LE VARIABILI

String strTempCentr = "";
char chrTempCentr[21];
String strTempVasca = "";
char chrTempVasca[21];
const int Riscaldatore = 22;
const int PompaFiltro = 23;
const int PompaOsmo = 24;
const int Luce = 25;
const int Refrigeratore = 26;
const int LuceNotte = 27;
const int VentolaPlafo = 28;
const int VentolaCentr = 29;
const int Galleggiante = 30;
boolean boolLuce = false;
boolean boolLuceNotte = false;
boolean boolRefrig = false;
boolean boolRiscaldatore = false;
boolean boolPrimoCiclo = true;


int ORAdiurnaON;
int MINdiurnaON;
int ORAdiurnaOFF;
int MINdiurnaOFF;
int ORAnotte1ON;
int MINnotte1ON;
int ORAnotte1OFF;
int MINnotte1OFF;
int ORAnotte2ON;
int MINnotte2ON;
int ORAnotte2OFF;
int MINnotte2OFF;

//  IDENTIFICHIAMO TUTTE LE ALLOCAZIONI DI MEMORIE EDIL LORO UTILIZZO

const int EEP_TempPlafo = 1;
const int EEP_TempCentr = 2;
const int EEP_TempVasca = 3;
const int EEP_deltaPlafo = 4;
const int EEP_deltaCentr = 5;
const int EEP_deltaVasca = 6;
const int EEP_ORAdiurnaON = 7;
const int EEP_MINdiurnaON = 8;
const int EEP_ORAnotte1ON = 9;
const int EEP_MINnotte1ON = 10;
const int EEP_ORAnotte2ON = 11;
const int EEP_MINnotte2ON = 12;
const int EEP_ORAdiurnaOFF = 13;
const int EEP_MINdiurnaOFF = 14;
const int EEP_ORAnotte1OFF = 15;
const int EEP_MINnotte1OFF = 16;
const int EEP_ORAnotte2OFF = 17;
const int EEP_MINnotte2OFF = 18;

//  CARICHIAMO DALLE MEMORIE IL LORO VALORE PRECEDENTEMENTE SALVATO E IMPOSTIAMOLO NELLA RELATIVA VARIABILE

int intTempVasca = (EEPROM.read(EEP_TempVasca) + 1);
int intTempCentr = EEPROM.read(EEP_TempCentr);
int intTempPlafo = EEPROM.read(EEP_TempPlafo);
int DeltaTempVasca = EEPROM.read(EEP_deltaVasca);
int DeltaTempPlafo = EEPROM.read(EEP_deltaPlafo);
int DeltaTempCentr = EEPROM.read(EEP_deltaCentr);
int diurnaON[2] = {EEPROM.read(EEP_ORAdiurnaON), EEPROM.read(EEP_MINdiurnaON)};
int diurnaOFF[2] = {EEPROM.read(EEP_ORAdiurnaOFF), EEPROM.read(EEP_MINdiurnaOFF)};
int notte1ON[2] = {EEPROM.read(EEP_ORAnotte1ON), EEPROM.read(EEP_MINnotte1ON)};
int notte1OFF[2] = {EEPROM.read(EEP_ORAnotte1OFF), EEPROM.read(EEP_MINnotte1OFF)};
/*
    IO USO SOLO UN'ACCENSIONE ED UNO SPEGNIMENTO DELLA LUCE NOTTURNA

int notte2ON[2] = {EEPROM.read(EEP_ORAnotte2ON), EEPROM.read(EEP_MINnotte2ON)};
int notte2OFF[2] = {EEPROM.read(EEP_ORAnotte2OFF), EEPROM.read(EEP_MINnotte2OFF)};

   SE SI VUOLE USARE UNA SECONDA ACCENSIONE DELLA LUCE NOTTURNA BASTA S-COMMENTARE QUESTE DUE RIGHE
*/

//  LE PROSSIME VARIABILI SONO DEDICATE ALL'RTC - LE USEREMO PIU' AVANTI

int rtc[7];
int intMin;
int intOre;
int intsec;
int intGg;
int intMese;
int intAnno;

char ora[9] = "";
char giorno[3];
char anno[5];
char mese[4];

long delayTemp;
long lungDelayTemp = 5;  //  INDICARE IN SECONDI - QUESTA VARIABILE OGNI QUANTO VIENE VERIFICATA LA TEMPERATURA IN VASCA IN CENTRALINA E DELLA PLAFO
long sviluppoDelayTemp;

#define ONE_WIRE_BUS 4  // INDICO SU CHE PIN HO COLLEGATO LE 3 SONDE DI TEMPERATURA

OneWire oneWire(ONE_WIRE_BUS);  // Setup a oneWire instance to communicate with any OneWire devices

DallasTemperature sensors(&oneWire);  // Pass our oneWire reference to Dallas Temperature.

//IDENTIFICO GLI INDIRIZZI DELLE SONDE DI TEMPERATURA

DeviceAddress TempCentr = { 0x28, 0x36, 0xD2, 0x32, 0x04, 0x00, 0x00, 0x4D };
DeviceAddress TempVasca = { 0x28, 0x5F, 0x04, 0x51, 0x05, 0x00, 0x00, 0x69 };
DeviceAddress TempPlafo = { 0x28, 0xAE, 0x5D, 0x5C, 0x06, 0x00, 0x00, 0x33 };



void setup(void)
{

//  IMPOSTIAMO TUTTI I PIN
  pinMode(Riscaldatore, OUTPUT);
  pinMode(PompaFiltro, OUTPUT);
  pinMode(PompaOsmo, OUTPUT);
  pinMode(Luce, OUTPUT);
  pinMode(Refrigeratore, OUTPUT);
  pinMode(LuceNotte, OUTPUT);
  pinMode(VentolaPlafo, OUTPUT);
  pinMode(VentolaCentr, OUTPUT);
  pinMode(Galleggiante, INPUT);
  sviluppoDelayTemp = lungDelayTemp * 1000;
  delayTemp = sviluppoDelayTemp;
  boolPrimoCiclo = true;

  Serial.begin(9600);  //INIZIALIZZIAMO LA SERIALE


  sensors.begin();   // Start up the library

  // set the resolution to 10 bit
  sensors.setResolution(TempCentr, 10);
  sensors.setResolution(TempPlafo, 10);
  sensors.setResolution(TempVasca, 10);

  //  IMPOSTIAMO LO STATO INIZIALE DI TUTTE LE USCITE - VISTO IL COLLEGAMENTO FATTO LOW = ACCESO - HIGH = SPENTO

  digitalWrite(Riscaldatore, HIGH);
  digitalWrite(PompaFiltro, LOW);
  digitalWrite(PompaOsmo, HIGH);
  digitalWrite(Luce, HIGH);
  digitalWrite(Refrigeratore, HIGH);
  digitalWrite(LuceNotte, HIGH);
  digitalWrite(VentolaPlafo, HIGH);
  digitalWrite(VentolaCentr, HIGH);


  setTime(11, 05, 00, 19, 11, 15);  //IMPOSTIAMOL'ORARIO CORRENTE PRIMA DI CARICARE LO SKETCH

  //  STAMPIAMO L'ORARIO SULLA SERIALE

  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.println();

  //  IMPOSTIAMO I TIMER

  Alarm.alarmRepeat(diurnaON[0], diurnaON[1], 00, LUCEon);
  Alarm.alarmRepeat(diurnaOFF[0], diurnaOFF[1], 00, LUCEoff);
  Alarm.alarmRepeat(notte1ON[0], notte1ON[1], 00, NOTTEon);
  Alarm.alarmRepeat(notte1OFF[0], notte1OFF[1], 00, NOTTEoff);

 

}

void printDigits(int digits)
{
  Serial.print(":");
  if (digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

void printTemperature(DeviceAddress deviceAddress)
{
 //  LEGGIAMO LE TEMPERATURESULLA BASE DEGLI INDIRIZZI DELLE SONDE IMPOSTATI PRIMA

  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00) {
    Serial.print("Errore di lettura...");
  } else {
    Serial.print("C: ");
    Serial.print(tempC);
  }
}

void loop(void)
{

  Alarm.delay(1);


  if (millis() >= delayTemp) {
    Serial.print("Lettura Temperature...\n\r");
    sensors.requestTemperatures();
    delay(800);

    Serial.print("Temperatura centralina: ");
    printTemperature(TempCentr);
    Serial.print("\n\r");
    Serial.print("Temperatura plafo: ");
    printTemperature(TempPlafo);
    Serial.print("\n\r");
    Serial.print("Temperatura vasca: ");
    printTemperature(TempVasca);
    Serial.print("\n\r\n\r");

    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.println();
    delayTemp = millis() + sviluppoDelayTemp;

  }

  //  VERIFICHIAMO LE TEMPERATURE E REAGIAMO DI CONSEGUENZA

  if (sensors.getTempC(TempCentr) >= (intTempCentr + DeltaTempCentr)) {
    digitalWrite(VentolaCentr, LOW);
  }
  if (sensors.getTempC(TempCentr) < (intTempCentr - DeltaTempCentr)) {
    digitalWrite(VentolaCentr, HIGH);
  }


  if (sensors.getTempC(TempPlafo) >= (intTempPlafo + DeltaTempPlafo)) {
    digitalWrite(VentolaPlafo, LOW);
  }
  if (sensors.getTempC(TempPlafo) < (intTempPlafo - DeltaTempPlafo)) {
    digitalWrite(VentolaPlafo, HIGH);
  }


  if (sensors.getTempC(TempVasca) >= (intTempVasca + DeltaTempVasca)) {
    digitalWrite(Refrigeratore, LOW);
    digitalWrite(Riscaldatore, HIGH);
    boolRefrig = true;
    boolRiscaldatore = false;
  }
  if (sensors.getTempC(TempVasca) <= (intTempVasca - DeltaTempVasca)) {
    digitalWrite(Refrigeratore, HIGH);
    digitalWrite(Riscaldatore, LOW);
    boolRefrig = false;
    boolRiscaldatore = true;
  }
  if (sensors.getTempC(TempVasca) <= intTempVasca) {
    digitalWrite(Refrigeratore, HIGH);
    boolRefrig = false;
  }
  if (sensors.getTempC(TempVasca) >= intTempVasca) {
    digitalWrite(Riscaldatore, HIGH);
    boolRiscaldatore = false;
  }

  //  VERIFICHIAMO LO STATO DEL GALLEGGIANTE E REAGIAMO DICONSEGUENZA

  if (digitalRead(Galleggiante) == HIGH) {
    digitalWrite(PompaOsmo, LOW);
  }
  if (digitalRead(Galleggiante) == LOW) {
    digitalWrite(PompaOsmo, HIGH);
  }


}


void LUCEon() { //  ACCENSIONE LUCE DIURNA
  digitalWrite(Luce, LOW);
  Serial.println("Accensione Luce diurna");
  digitalWrite(LuceNotte, LOW);
  Serial.println("Accensione Luce notturna");
  boolLuce = true;
}

void LUCEoff() {  //  SPEGNIMENTO LUCE DIURNA
  digitalWrite(Luce, HIGH);
  Serial.println("Spegnimento Luce diurna");
  //digitalWrite(LuceNotte, HIGH);
  Serial.println("Spegnimento Luce notturna");
  boolLuce = false;
}

void NOTTEon() {  //  ACCENSIONELUCE NOTTURNA
  digitalWrite(LuceNotte, LOW);
  Serial.println("Accensione Luce notturna");
  boolLuceNotte = true;
}

void NOTTEoff() {  //  SPEGNIMENTO LUCE NOTTURNA
  digitalWrite(LuceNotte, HIGH);
  Serial.println("Spegnimento Luce notturna");
  boolLuceNotte = false;

}

Al momento del caricamento dovrete impostare l'ora e la data corretta modificando questa riga nel setup()

  setTime(11, 05, 00, 19, 11, 15);

Qualche occhio più critico potrebbe aver notato che non ho elencato ne usato RTC per la gestione dell'orario questa sarà una delle prime correzioni/completamenti che apporterò; purtroppo ho avuto un problema col mio RTC quindi ho ripiegato su una soluzione diversa Che comunque sta andando da settimane perfettamente.

Nei prossimi post vi proporrò anche qualche foto della centralina in costruzione.

Per il momento aspetto commenti e consigli.

Ciao

Gaetano

[malù]

Bel lavoro Gaetano.........quando sarà finito, se viene bene, si potrebbe anche farne un bell'articolo

[SirNino]

Originariamente inviata da malù

Bel lavoro Gaetano.........quando sarà finito, se viene bene, si potrebbe anche farne un bell'articolo

Molto volentieri, stavo anche pensando di fare una serie di mini tutorial (tipo costruire e programmare una centralina passo passo con le varie spiegazioni dei diversi metodi e possibili applicazioni pratiche).

EDIT: editato e commentato tutto il listato del primo post, se ci fosse ancora qualcosa di non chiaro chiedete pure

[framicola]

sai programmare anche il logo?