// STATIE DE EPURARE CU BAZINE IBC
/* ^
. _______________________________________________|__________________
. | ___________________|_______________ |
. | | | | |
| | __|_____|__ | __|_____|__ | | | |
| | | | | | | | | | | | | | |
| BAZIN 0 | | BAZIN 1 | | | | BAZIN 2 | | |
| | | | | | | | | |
| NU ARE POMPE | | POMPE | | | | POMPE | | |
| | | | | | EVACUARE EXT. | | |
| | | AERARE EVACUARE B2 | | AERARE RECIRCULARE B1/B0 |
|______________________| |______________________| |__________________________|
*/
/********* ATENTIE !!! **********/
// Pinul A0 este senzorul de nivel din BAZIN 1
// Pinul A1 este senzorul de nivel din BAZIN 2
// Pinul A2 este senzorul de prea plin BAZIN 2
// Pinul A3 este este pompa de evacuare in exrterior
// Pinul A4 este pompa de evacuare in BAZIN 2 dupa ce s-a evacuat in exterior BAZIN 2 si se utilizeaza si la recirculare
// Pinul A5 este pompa de evacuare in BAZIN 0 si se utilizeaza doar la recirculare
// Pinul D2 este pompa de aerare BAZIN 1
// Pinul D3 este pompa de aerare Bazin 2
// BAZIN 0 - separator grasimi si fermentare anaeroba
// BAZIN 1 si BAZIN 2 fermentare aeroba si au nevoie de casa bacteriilor (un grilaj de plastic + resturi teava PPR)
// BAZIN 0 descarca gravitational in BAZIN 1
// prea plinul in BAZIN 1 se realizeaza hidraulic
// legatura intre bazine este facuta pe principiul vaselor comunicante
// daca nu functioneaza pompele de evacuare, evacuarea exterioara se face natural cu
// conditia ca iesirea in exterior sa fie mai jos decat intrarea canalizarii in BAZIN 1
// rezultand o fosa septica clasica
// pompele pentru setarile de mai jos au aproximativ 100 litri / minut la 1m inaltime adica 6 mc/h, valoarea reala se determina experimental
// daca pompele sunt au debite diferite timpii de pornire evacuare si recirculare sunt diferiti
// trebuind modificate variabilele raportEVACUARE si raportRECIRCULARE
// pompa standard la care se raporteaza timpii de functionare este de 6 mc/h
// cantitatea maxima evacuata este stabilita prin plutitorii de nivel minim care intrerup pompele fara comanda din partea controlerului
// ATENTIE ! - daca se opreste curentul sau apare o resetare fizica controlerul revine la valorile de initializare
#include <LiquidCrystal.h>
//#include <MsTimer2.h>
//#include <SerialTransfer.h>
#include <util/atomic.h>
#define rs 12
#define en 11
#define d4 10
#define d5 9
#define d6 8
#define d7 7 //const byte rs = 12, en = 11, d4 = 10, d5 = 9, d6 = 8, d7 = 7;
LiquidCrystal lcd (rs, en, d4, d5, d6, d7);
//Stabilire pini butoane
#define butonPinSETUP 6 //const byte butonPinSETUP = 6;// Pin digital 6
#define butonPinTimpPLUS 5 // const byte butonPinTimpPLUS = 5;// Pin digital 5
#define butonPinTimpMINUS 4 // const byte butonPinTimpMINUS = 4;// Pin digital 4
// Pin Buzzer
#define buzzerPin 13 // Pin digital 13
// Variabile Meniu
int Meniu = -1; // valoarea -1 indica faptul ca nu ne aflam in meniu
int subMeniuAERARE = -1;
int subMeniuEVACUARE = -1;
int subMeniuRECIRCULARE = -1;
int subMeniuBazin_1_AERARE = -1;
int subMeniuBazin_2_AERARE = -1;
// variabile pentru intreruperile TIMER care pornesc pompele
// aceasta structura este operata in interiorul functiei call_ISR_Timer()
struct Timer_Releu // aceasta structura este un constructor pentru a putea fi initializata ca mai jos
{
Timer_Releu ( unsigned int op, unsigned int cl, bool ss) :
OP {op}, CL {cl}, SS {ss} {}
unsigned int OP = 0; //" OPEN "timpul in secunde pt. care RELEUL este normal deschis NO
unsigned int CL = 0; //" CLOSE "timpul in in secunde pt. care RELEUL este normal inchis NC
bool SS = false; //" START - STOP " - 0 opreste , 1 porneste un eveniment (actioneaza un releu)
//dupa actiunea STOP/START trebuie reinitializati timpii OP, CL, LP
};
// Variabila pentru intreruperea ISR() Timp necesara pentru a masura timpul scurs de la pornire
unsigned long volatile Durata = 0;//masoara timpul fara precizie de cand a fost pornit conroler-ul
//aproximativ 136 de ani dupa care trebuie resetata
bool volatile flag_Timer1 = false;//variabila care arata ca a aparut intreruperea Timer1
unsigned long volatile timp_VACANTA = 0;// variabila care masoara timpul pentru a verifica daca a avut loc
// evacuarea in exterior in 48 de ore care reprezinta doua cicluri
// complete de epurare prin care se determina faptul ca
// statia nu este folosita, nu are aport de apa pt epurare
// Variabile care stocheaza pinul care a generat intreruperea ISR()
// pentru pinii IMPUT_PULLUP setati pe GND care genereaza inreruperea
// pinul A0 plutitor Bazin 1 - adica bazinul 1 sa umplut si incepe etapa de evacuare in exterior apa epurata din bazin 2
// pinul A1 plutitor Bazin 2 - adica opreste evacuarea din bazin 1 in bazinul 2
// pinul A2 plutitor prea plin - cota de avarie bazin 2 si porneste evacuarea 50 litri si
// poate emite o avarie pe afisaj pompa evacuare bazin 2 stricata
bool nivel_B1_Pin_A0 = false; //plutitor nivel BAZIN 1 declanseaza evacuarea
bool nivel_B2_Pin_A1 = false; //plutitor nivel BAZIN 2 opreste umplerea bazinului 2
bool prea_plin_B2_Pin_A2 = false; //plutitor prea plin BAZIN 2 evacueaza 100 litri in exterior
#define intarziere_Plutitor 15//intarziere masurata in secunde generata pentru a adauga un surplus de apa de 25 litri
// astfel incat plutitorul sa stea inundat
bool surplus_Evacuare = false; // stabileste daca a fost eliminata apa in surplus la evacuare
// fata de limit de nivel - acest surplus exita intodeauna minim 25 litri
// pentru stabilitatea contactului plutitorului sau daca in timpul linistirii
// functioneaza prea plinul hidraulic si creste nivelul
byte intarziere_Pin_A0 = 0; // aceaste intarzieri sunt necesare pentru ca sa fie preluata
byte intarziere_Pin_A1 = 0; // distanta de contact a plutitorilor, eliminarea semnalelor
byte intarziere_Pin_A2 = 0; // false si a semnalelor accidentale datorita efectului de val
// intarzierea este de aproximativ 15 sec. sau 25 litri,
// evenimentele declansate de plutitori apar dupa expirarea
// acestei perioade cu conditia ca plutitorul sa fie in contact
// Variabile pompe
unsigned int Bazin_1_Aerare = 60; // implicit 90 de secunde
unsigned int Bazin_1_Linistire = 60; // implicit 900 de secunde
unsigned int Bazin_2_Aerare = 60; // implicit 90 de secunde
unsigned int Bazin_2_Linistire = 60; // implicit 900 de secunde
unsigned int PornireEvacuare = 20; // implicit 180 de secunde maxim 240 secunde / max 400 litri - pompa trebuie sa aiba un debit = 6 mc/h
unsigned int LinistireEvacuare = 9; // implicit 900 de secunde - este folosita pentru Evacuare si Recirculare
unsigned int PornireRecirculare = 60; // implicit 60 de secunde - recircula 100 litri la debitul pompelor de 6 mc/h
unsigned int AsteptareRecirculare = 1;// implicit 3 ore - max 18 ore in secunde min 21600 - max 64800
unsigned int PornireEvacuareInBazin2 = PornireEvacuare + intarziere_Plutitor; //maxim 240 secunde / max 400 litri - pompa trebuie sa aiba un debit = 6 mc/h
unsigned int LinistireREC = LinistireEvacuare; //timpul de linistire inainte de Recirculare
const byte EvacuarePreaPlin = 10;//initializare 30 sec - 50 de litri pt. pompa 6 mc/h si reprezinta timpul necesar
//evacuarii unei parti din prea plin pana cand se finalizeaza etapa de evacure
//volum de prea plin Bazin 2 = 100 litri
unsigned int ORA_Recirculare = 0; // este utilizata pentru recirculare, masoara o ora pentru a decrementa Recirculare.CL
// initializez variabilele pentru relee
struct Timer_Releu AerareB1 = {Bazin_1_Aerare, Bazin_1_Linistire, true };
struct Timer_Releu AerareB2 = {Bazin_2_Aerare, Bazin_2_Linistire, true };
struct Timer_Releu Recirculare = {PornireRecirculare, AsteptareRecirculare , true };
struct Timer_Releu Evacuare = {PornireEvacuare, LinistireEvacuare, false };
// Structura pentru afisarea ETAPEI / STARII pe LCD si transmitere date wireles prin HC-12
struct __attribute__((packed)) LCD20x4 // Aceasta structura contine textul afisat pe
{ // fiecare linie a afisajului LCD20x4
char Line0[21]; // Aceasta structura va fi transmisa wireles
char Line1[21]; // catre controlerul SLAVE prin HC-12 433 MHz
char Line2[21];
char Line3[21];
unsigned int Alarma[4] = {0, 0, 0, 0};// stocheaza nr. de aparitii a alarmelor si numara pana la max. 65535 de aparatii
} LCD;
byte alarma = 0; // stabileste tipul de alarma si ia valori
// 1 si 2 pt prea plin BAZIN 2
// 3 cand plutitorul de maxim din BAZIN 2 este blocat sau pompa
// de evacuare in exterior este arsa
// 4 senzor nivel defect sau murdar si nu cupleaza in Bazin 2 sau pompa de
// evacuare in Bazin 2 este arsa
// alarma de tipul 3 si 4 este permanenta si se elimina prin resetare alarma
// chiar daca senzorii de nivel revin la normal si practic pompele nu sunt arse
// resetarea alarmei se realizeaza prin resetare fizica a microcontroleru-lui
// momentan microcontrolerul nu poate determina daca o anumita pompa este arsa fizic
// alarmele se bazeaza doar pe starea senzorilor de nivel
byte timpAfisareAlarma = 0; // afisaza alarma timp de 10 sec la aparitia acesteia dupa care o reseteza
// pentru a nu bloca afisajul afisindu-se STAREA in care se afla statia in continuare
/*********************** FUNCTII PENTRU INTRERUPERILE ISR() *********************************/
/************ FUNCTIE CARE AFISEAZA ALTERNANT STARE/ALARM IN CAZUL APARITIEI ALARMEI *************/
inline String STARE_ALARMA ()
{
// in cazul aparitiei unei alarme se va afisa alternant STARE/ALARM
// si activez led si buzzer pe pin D13 (PB5) care sa atentioneze ca
// a aparut cel putin o alarma
unsigned long tmp = 0;
static bool stare_Alarma = false;
for (byte i = 0; i <= 3; i++) { tmp += LCD.Alarma[i]; }
if (tmp == 0 ) {PORTB &= ~_BV(PB5); return("STARE");}
else if (tmp != 0 && stare_Alarma == false) {stare_Alarma = true; PORTB &= ~_BV(PB5); return ("STARE");}
else if (tmp != 0 && stare_Alarma == true) {stare_Alarma = false; PORTB |= _BV(PB5); return ("ALARM");}
} //End STARE_ALARMA
/************************* FUNCTIE AFISARE STARE CICLU **************************************/
// Acesta functie afiseaza etapa in care se afla statia de epurare
void StareCiclu ( byte etapa = 0)
{
String tmp = "";
tmp = STARE_ALARMA();
if (Meniu != -1) return;
if (timpAfisareAlarma == 10 && alarma > 2 ) // afisez alarma tip 3 si 4 timp de 10 sec. de la apariția acesteia dupa care se reseteaza
{ // evenimentele privind nr aparitiei alarmelor sun stocate in variabila Alarma[0-3]
alarma = 0; timpAfisareAlarma = 0;
}
else if (alarma > 2) {timpAfisareAlarma++; }
if ( alarma ) etapa = 4;
switch (etapa)
{
case 1: //EVACUARE
//if ( alarma ) break;
tmp += " << EVACUARE >>";
strcpy(LCD.Line0 , tmp.c_str());
tmp = String(Evacuare.CL) +" ";
if(Evacuare.CL > 0) tmp = ("> Linistire " + tmp.substring(0,5) + "sec"); else tmp = (" Linistire " + tmp.substring(0,5) + "sec");
strcpy(LCD.Line1, tmp.c_str());
tmp = String(Evacuare.OP) +" ";
if(Evacuare.OP > 0 && Evacuare.CL == 0) tmp = ("> Evacuare " + tmp.substring(0,5) + "sec"); else tmp = (" Evacuare " + tmp.substring(0,5) + "sec");
strcpy(LCD.Line2, tmp.c_str());
tmp = String(PornireEvacuareInBazin2) +" ";
if(PornireEvacuareInBazin2 > 0 && Evacuare.OP == 0) tmp = ("> Umplere " + tmp.substring(0,5) + "sec"); else tmp = (" Umplere " + tmp.substring(0,5) + "sec");
strcpy(LCD.Line3, tmp.c_str());
break;
case 2: //RECIRCULARE
//if ( alarma ) break;
tmp += " << RECIRCUL >>";
strcpy(LCD.Line0 , tmp.c_str());
tmp = String(LinistireREC) + " " ;
if(LinistireREC > 0) tmp = ("> Linistire " + tmp.substring(0,5) + "sec"); else tmp = (" Linistire " + tmp.substring(0,5) + "sec");
strcpy(LCD.Line1, tmp.c_str());
tmp = String(Recirculare.OP) +" ";
if(Recirculare.OP > 0 && LinistireREC == 0) tmp = ("> Amestec " + tmp.substring(0,5) + "sec"); else tmp = (" Amestec " + tmp.substring(0,5) + "sec");
strcpy(LCD.Line2, tmp.c_str());
strcpy(LCD.Line3, " --------- ---- ---");
break;
case 3: //AERARE
//if ( alarma ) break;
tmp += " << PASIV >>";
strcpy(LCD.Line0 , tmp.c_str());
strcpy(LCD.Line1 , " Bazin 1 Bazin 2");
tmp = String(AerareB1.OP) + " ";
tmp = ("AER " + tmp.substring(0,4) + "sec " );
strcpy(LCD.Line2 , tmp.c_str());
tmp = String(AerareB2.OP) + " ";
tmp = tmp.substring(0,4) + "sec";
strcat(LCD.Line2 , tmp.c_str());
tmp = String(AerareB1.CL) + " ";
tmp = ("LIN " + tmp.substring(0,4) + "sec ");
strcpy(LCD.Line3 , tmp.c_str());
tmp = String(AerareB2.CL) + " ";
tmp = (tmp.substring(0,4) + "sec");
strcat(LCD.Line3 , tmp.c_str());
break;
case 4: // ALARME
switch (alarma)
{
case 1: //PREA PLIN BAZIN 2
strcpy(LCD.Line0 , "** ALARM PREAPLIN **");
strcpy(LCD.Line1 , " Verifica evacuarea.");
strcpy(LCD.Line2 , " Debit mare, peste ");
strcpy(LCD.Line3 , " 20 litri / min. ");
break;
case 2: //PREA PLIN BAZIN 2
strcpy(LCD.Line0 , "** ALARM PREAPLIN **");
strcpy(LCD.Line1 , "Pompa Evac.P2.2 arsa");
strcpy(LCD.Line2 , "sau plutitor prea - ");
strcpy(LCD.Line3 , "plin BAZIN 2 blocat.");
break;
case 3: //EVACUARE
strcpy(LCD.Line0 , "** ALARM EVACUARE **");
strcpy(LCD.Line1 , "Pompa de evacuare in");
strcpy(LCD.Line2 , "exterior P2.2 arsa. ");
strcpy(LCD.Line3 , "Senzor nivel blocat.");
break;
case 4: //EVACUARE
strcpy(LCD.Line0 , "* ALARM UMPLERE B2 *");
strcpy(LCD.Line1 , "Senzorii de nivel ");
strcpy(LCD.Line2 , "defecti sau murdari/");
strcpy(LCD.Line3 , "P1.2 umplere B2 arsa");
break;
}
break;
}
lcd.setCursor (0,0); lcd.print((char*)LCD.Line0);
lcd.setCursor (0,1); lcd.print((char*)LCD.Line1);
lcd.setCursor (0,2); lcd.print((char*)LCD.Line2);
lcd.setCursor (0,3); lcd.print((char*)LCD.Line3);
}// end StareCiclu
/******************** FUNCTIE INITIALIZARE CICLU ***********************/
inline void Initializare_Ciclu ()
{
//oprim toate pompele
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
PORTD &= ~_BV(PD2); // opreste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
PORTD &= ~_BV(PD3); // opreste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
// reseteaza intarzierea
intarziere_Pin_A0 = 0;
intarziere_Pin_A1 = 0;
//reinitializez toate variabilele pentru o etapa de epurare noua
AerareB1 = {Bazin_1_Aerare, Bazin_1_Linistire, true };
AerareB2 = {Bazin_2_Aerare, Bazin_2_Linistire, true };
Recirculare = {PornireRecirculare, AsteptareRecirculare , true };
Evacuare = {PornireEvacuare, LinistireEvacuare, false};
PornireEvacuareInBazin2 = PornireEvacuare + intarziere_Plutitor;
ORA_Recirculare = 0; //daca apare evenimentul evacuare si recircularea nu s-a efectuat
LinistireREC = LinistireEvacuare;
}
/************************* FUNCTIE TRATARE EVENIMENTE ISR() PINI IN ISR() TIMER **************************/
inline void call_ISR_Timer (void)
{
// se pastreaza ordinea if-urilor pt functionare corecta:
// 1. prea plin
// 2. evacuare
// 3. recirculare
// 4. aerare
// aceasta functie este chemata de ISR() Timer la fiecare secunda.
// durata de rulare a functiei trebuie sa fie de maxim 10 milisecunde
// in prezent rularea dureaza sub 2 milisecunde
// cel mai mult timp este consumat de functia de afisare aproximativ o milisecunda
static byte TIMP_Evacuare_PreaPlin = 0;//este utilizata pentru evacuare prea plin BAZIN 2
static bool tmp_ETAPA[3] = {false,false,false};// stocheaza temporar Start-Stop pt fiecare etapa
static byte tmp_ALARMA =0; // stocheaza temporar alarma aparuta inainte de alarma preaplin si
// este folosita strict pentru afisare
byte vacanta = 1; // reduce timpul de aerare si creste timpul de linistire aerare pt economie de energie
// recircula o data la 24 de ore 100 litri din bazin 2 in bazin 0 pentru eliminarea
// mirosurilor, denitrificare si defosforizare
/**** PREA PLIN BAZIN 2 ****/
/* 1) acest eveniment apare atunci cand plutitorul de nivel din BAZIN 1 nu este cuplat si
plutitorul de prea plin cupleaza, adica BAZIN 1 sa umplut si nu porneste evacuarea,
transferul de apa in BAZIN 2 facanduse hidraulic pana cand se ajunge la nivelul de prea plin
din BAZIN 2 fiind necesara evacuarea
2) cand plutitorului de nivel BAZIN 1 declanseaza procesul de evacuare dar pompa de evacuare
in exterior nu porneste sau este arsa si comunicarea intre bazine se realizeaza hidraulic
pana cand se atinge nivelul de prea plin din BAZIN 2
*/
if (((PINC & (1 << PC2)) != 0) && (TIMP_Evacuare_PreaPlin >= EvacuarePreaPlin))//evacuare preaplin are o cantitate fixa de apa de evacuat
{
prea_plin_B2_Pin_A2 = false;
TIMP_Evacuare_PreaPlin = 0;
// restabilesc starea dinainte de prea plin deoarece plutitorul a reveni la normal
PORTC &= ~_BV(PC3); //opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
(tmp_ALARMA > 2) ? alarma = tmp_ALARMA : alarma = 0;
AerareB1.SS = tmp_ETAPA[0]; AerareB2.SS = tmp_ETAPA[1]; Recirculare.SS = tmp_ETAPA[2]; // refac strarea initiala aparatiei prea plin
// pornim pompele corespunzatoare etapei intrerupte de prea plin
if((Evacuare.SS == true ) && (Evacuare.CL == 0)) PORTC |= _BV(PC3); else PORTC &= ~_BV(PC3); //opreste / porneste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
if ((Recirculare.SS == true ) && (LinistireREC == 0))
{
PORTC |= _BV(PC4); // porneste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC |= _BV(PC5); // porneste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
}
if ((AerareB1.SS == true) && (AerareB1.OP |= 0) && (AerareB1.CL == Bazin_1_Linistire)) PORTD |= _BV(PD2); // porneste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
if ((AerareB2.SS == true) && (AerareB2.OP |= 0) && (AerareB2.CL == Bazin_2_Linistire)) PORTD |= _BV(PD3); // porneste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
}
if (((PINC & (1 << PC2)) == 0) && (TIMP_Evacuare_PreaPlin == 0)) prea_plin_B2_Pin_A2 = true;// pin A2 este pentru prea plin din Bazin 2
// se seteaza prea_plin_B2_Pin_A2 = false in
// functia call_ISR_Timer dupa ce s-a tratat
// evenimentul adica, evacueaza in exterior 50 litri
if (prea_plin_B2_Pin_A2 && (TIMP_Evacuare_PreaPlin == 0))
{
tmp_ALARMA = alarma;
tmp_ETAPA[0] = AerareB1.SS; tmp_ETAPA[1] = AerareB2.SS; tmp_ETAPA[2] = Recirculare.SS;
AerareB1.SS = false; AerareB2.SS = false; Recirculare.SS = false;
PORTC |= _BV(PC3); // porneste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
PORTD &= ~_BV(PD2); // opreste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
PORTD &= ~_BV(PD3); // opreste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
TIMP_Evacuare_PreaPlin++; alarma = 1;
LCD.Alarma[0]<65535 ? LCD.Alarma[0] += 1 : LCD.Alarma[0] = 65535;
StareCiclu (4);// afisez starea prea plin BAZIN 2
return;
}
else if (prea_plin_B2_Pin_A2 && (TIMP_Evacuare_PreaPlin < EvacuarePreaPlin)) // evacueaza in exterior parte din prea plin
{
TIMP_Evacuare_PreaPlin++;
StareCiclu (4);// afisez starea prea plin BAZIN 2 numai cand nu ma aflu in SETUP, altfel da eroare afisajul
return;
}
else if (prea_plin_B2_Pin_A2 && (TIMP_Evacuare_PreaPlin >= EvacuarePreaPlin)) // a evacuat in exterior prea plinul
{
if ((PINC & (1 << PC2)) == 0 && TIMP_Evacuare_PreaPlin < PornireEvacuare) // verifica pe pinul A2 daca contactul auxiliar este ON
{ // daca contactul este activ debitul este asa de mare incat
if (TIMP_Evacuare_PreaPlin == EvacuarePreaPlin) alarma = 2; // pompa de evacuare in exterior nu face fata
TIMP_Evacuare_PreaPlin++;// pompa de evacuare este arsa sau plutitorul
// prea-plin blocat si functioneaza ca o fosa septica
// pompa de evacuare se opreste in cazul plutitorului blocat cand
// este depasit timpul de evacuare intr-un ciclu normal si
// revine la ciclul normal cand se deblocheaza
StareCiclu (4);// afisez starea prea-plin BAZIN 2 numai cand nu ma aflu in SETUP, altfel da eroare afisajul
if (TIMP_Evacuare_PreaPlin == PornireEvacuare )
{
PORTC &= ~_BV(PC3); //opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
LCD.Alarma[1]<65535 ? LCD.Alarma[1] += 1 : LCD.Alarma[1] = 65535;
TIMP_Evacuare_PreaPlin++;
// restabilesc starea dinainte de prea plin deoarece plutitorul plutitorul nu revine la normal
// si a fost consumat timpul de pornire evacuare insemna ca
(tmp_ALARMA > 2) ? alarma = tmp_ALARMA : alarma = 0;
AerareB1.SS = tmp_ETAPA[0]; AerareB2.SS = tmp_ETAPA[1]; Recirculare.SS = tmp_ETAPA[2]; // refac strarea initiala aparatiei prea plin
// pornim pompele corespunzatoare etapei intrerupte de prea plin
if((Evacuare.SS == true ) && (Evacuare.CL == 0)) PORTC |= _BV(PC3); else PORTC &= ~_BV(PC3); //opreste / porneste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
if ((Recirculare.SS == true ) && (LinistireREC == 0))
{
PORTC |= _BV(PC4); // porneste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC |= _BV(PC5); // porneste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
}
if ((AerareB1.SS == true) && (AerareB1.OP |= 0) && (AerareB1.CL == Bazin_1_Linistire)) PORTD |= _BV(PD2); // porneste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
if ((AerareB2.SS == true) && (AerareB2.OP |= 0) && (AerareB2.CL == Bazin_2_Linistire)) PORTD |= _BV(PD3); // porneste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
}
return;
}
} // end Prea Plin
/**** EVACUARE ****/
//if ( alarma == 3 || alarma == 4) goto Evita_Evacuarea;// daca pompele de evacuare sunt arse sau senzorii de nivel din
// Bazin 1 si Bazin 2 sunt blocati cuplat numai realizeaza
// procesul de evacuare si functioneaza hidraulic ca
// vase comunicante - fosa septica simpla
// functioneaza doar recircularea si aerarea
// Verifica pozitia plutitorului de nivel din Bazin 2
if ((PINC & (1 << PC1)) == 0)
{nivel_B2_Pin_A1 = true;}
else
{
nivel_B2_Pin_A1 = false;
if (surplus_Evacuare) Evacuare.OP = PornireEvacuare;// daca exista surplus de apa in aparut in timpul linistirii
// prin prea plin reinitializeaza timpul de evacuare dupa
// eliminarea surplusului pentru a se pastra timpii de epurare
}
/******* Eliminare semnale false plutitorul de nivel Bazin 1 - Pin A0 *********/
//produce intarzierea pt. eliminarea semnalelor false
if (((PINC & (1 << PC0)) == 0) && (intarziere_Pin_A0 >= 0) && (intarziere_Pin_A0 < intarziere_Plutitor))// daca plutitorul din Bazin 1 este cuplat "intarziere_Plutitor secunde"
{ // se executa evacuarea
nivel_B1_Pin_A0 = true;
Evacuare.SS = true;
intarziere_Pin_A0++;// se produce o intarziere de "intarziere_Plutitor secunde" necesara pentru ca plutitorul sa fie inundat
goto Evita_Evacuarea;// evita codul de evacuare
}
else if (((PINC & (1 << PC0)) != 0) && (intarziere_Pin_A0 < intarziere_Plutitor))//daca plutitorul din Bazin 1 nu este cuplat "intarziere_Plutitor secunde"
{ // nu se executa evacuarea
nivel_B1_Pin_A0 = false;
Evacuare.SS = false;
intarziere_Pin_A0 = 0;
goto Evita_Evacuarea;// evita codul de evacuare
}
/****************************************************************************/
if (nivel_B1_Pin_A0 && Evacuare.SS )//eveniment pin A0 - Bazinul 1 sa umplut, opreste aerarea si
{ //recircularea pornind evacuarea,
//daca pompa de evacuare in BAZIN 1 sau BAZIN 2 s-a ars,
//functioneza ca vase comunicante
StareCiclu (1);// afisez starea pentru evacuare cand nu avem alarme in evacuare
//aici incepe procesul de linistire, evacuare in exterior si umplere Bazin 2
if (Evacuare.SS == true && Evacuare.CL == LinistireEvacuare)// verifica daca evacuarea a aparut in timpul
{ //linistirii aerare sau recirculare
AerareB1.SS = false; AerareB2.SS = false; Recirculare.SS = false; Evacuare.CL--;
if ( (AerareB2.OP == 0) && (Recirculare.CL != 0) )// cilul de evacuare a aparut in perioada linistirii aerarii
{
if (LinistireEvacuare >= (Bazin_2_Linistire - AerareB2.CL))//recupereaza timpul de linistire trecut
{ // in timpul aerarii
Evacuare.CL = LinistireEvacuare - (Bazin_2_Linistire - AerareB2.CL);// continua linistirea pentru diferenta de timp trecut
}
else Evacuare.CL = 0;// timpul de linistire s-a epuizat si se poate realiza evacuarea
}
else if ((Recirculare.CL == 0) && (LinistireREC != 0)) Evacuare.CL = LinistireREC;// ciclul de evacuare a aparut in perioada linistirii
// pentru recirculare si continua pentru diferenta de timp
// timpul de linistire pentru recirculare este identic cu
// timpul de linistire pentru evacuare
//oprim toate pompele
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
PORTD &= ~_BV(PD2); // opreste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
PORTD &= ~_BV(PD3); // opreste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
return;
}
else if ((Evacuare.SS == true) && (Evacuare.CL <= LinistireEvacuare))// incepe perioada de linistire
{
// aici incepe procesul de linistire
if ( Evacuare.CL != 0 ) // releul pe pinul A3 este Normal Close pt. perioada CL
{
Evacuare.CL--;
if ((Evacuare.CL == 0) && (Evacuare.OP == PornireEvacuare) && nivel_B1_Pin_A0 && !nivel_B2_Pin_A1)
{
Evacuare.OP = 0;// sare peste etapa de evacuare in exterior daca plutitorul din Bazin 2 nu este la nivel
return; // prin aceasta se realizeaza echilibrarea volumetrica a statiei de epurare
}
return;
}
//aici incepe evauarea in exterior
if((Evacuare.CL == 0) && (Evacuare.OP == PornireEvacuare) && nivel_B2_Pin_A1)// sa terminat linistirea si incepe evacuarea
{
PORTC |= _BV(PC3);// porneste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
Evacuare.OP--;
return;
}
else if ((Evacuare.OP != 0) && nivel_B2_Pin_A1)// daca apa de evacuat este mai sus de plutiorul de nivel din BAZIN 2, adica in timpul
{ // linistirii pt. evacuare sa depasit prea plinul hidraulic din BAZIN 1, elimina
Evacuare.OP--; // surplusul si revine la PornireEvacuare in cadrul ISR pin A1 cand se modifica starea plutiorului
surplus_Evacuare = true;
if (Evacuare.OP == 0) // pompa evacuare in exterior defecta sau senzor de nivel BAZIN 2 blocat ON(cuplat)
{
alarma = 3; // declansez ALARMA
LCD.Alarma[2]<65535 ? LCD.Alarma[2] += 1 : LCD.Alarma[2] = 65535;
StareCiclu (4); // afisez starea cand s-a declansat alarma
Initializare_Ciclu();
return;
}
}
else if ((Evacuare.OP != 0) && !nivel_B2_Pin_A1)// a fost eliminat surplusul de apa si evacueaza cantitatea de apa epurata
{
Evacuare.OP--;
surplus_Evacuare = false;
return;
}
//aici incepe umplerea bazinului 2
if (Evacuare.CL == 0 && Evacuare.OP == 0 )// s-a epuizat linistirea si evacuarea
{
if ((PornireEvacuareInBazin2 == PornireEvacuare + intarziere_Plutitor) && !nivel_B2_Pin_A1)// se umple Bazinul 2 dupa ce a fost evacuat in exterior
{ // daca senzorul de nivel din Bazinul 2-pin A1 nu este decuplat
// nu porneste pompa de umplere, transferul se realizeaza hidraulic
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC |= _BV(PC4); // porneste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PornireEvacuareInBazin2--;
return;
}
else if ((PornireEvacuareInBazin2 > 0 && PornireEvacuareInBazin2 <= PornireEvacuare + intarziere_Plutitor) && !nivel_B2_Pin_A1)//umple bazinul 2 dupa evacuare
{ // pompa are 100 litri/min si are nevoie de 180 secunde de a evacua 300 litri in bazinul 2
PornireEvacuareInBazin2-- ;
return;
}
else if (!nivel_B2_Pin_A1 && (PornireEvacuareInBazin2 == 0 )) // s-a terminat umplerea BAZIN 2 si senzorul de nivel nu este cuplat
{ // senzor nivel defect sau murdar si nu cupleaza sau pompa de umplere defecta
alarma = 4; // declansez ALARMA
LCD.Alarma[3]<65535 ? LCD.Alarma[3] += 1 : LCD.Alarma[3] = 65535;
StareCiclu (4); // afisez starea cand s-a declansat alarma
Initializare_Ciclu();
return;
}
else if ( nivel_B2_Pin_A1 || (PornireEvacuareInBazin2 == 0))// senzorul de nivel Bazin 2 s-a cuplat sau s-a epuizat timpul de umplere sau sa ars pompa
{ // de evacuare in exterior si nu se mai executa umplerea functioneza ca vase comunicante
if ((intarziere_Pin_A1 >= 0 && intarziere_Pin_A1 < intarziere_Plutitor) && PornireEvacuareInBazin2 != 0)// pompa de evacuare in Bazin 2 mai functioneaza
{ // 15 secunde sau pana se epuizeaza timpul de umplere
PornireEvacuareInBazin2-- ;
intarziere_Pin_A1++;
if (((PINC & (1 << PC0)) == 0) && ((PornireEvacuareInBazin2 == 0) || (intarziere_Pin_A1 == intarziere_Plutitor)))//verifica daca sa decuplat preaplinul bazin 1
{ //daca a ramas cuplat - senzor nivel defect sau murdar
//si a ramas cupleat sau pompa de umplere defecta
alarma = 4; // declansez ALARMA
LCD.Alarma[3]<65535 ? LCD.Alarma[3] += 1 : LCD.Alarma[3] = 65535;
StareCiclu (4); // afisez starea cand s-a declansat alarma
Initializare_Ciclu();
return;
}
return;
}
Initializare_Ciclu();
return;
}
}
}
return;
}// end Evacuare
Evita_Evacuarea: // saltul la aceasta eticheta pastreaza procesele
// in functiune pana se realizeaza intarzierea pe
// pinul A0 pentru eliminarea semnalelor false
/**** RECIRCULARE ****/
if (Recirculare.SS == true )//&& !nivel_B1_Pin_A0)
{
ORA_Recirculare++;
if ((ORA_Recirculare == 36) && (Recirculare.CL != 0)) {Recirculare.CL--; ORA_Recirculare = 0;}
if (Recirculare.CL == 0)
{
if (LinistireREC == LinistireEvacuare)
{
AerareB1.SS = false; AerareB2.SS = false; LinistireREC--;
if ( (AerareB1.OP == 0) && (AerareB2.OP == 0) )// cilul de recirculare a aparut in perioada linistirii aerarii
{
if (LinistireEvacuare >= (Bazin_2_Linistire - AerareB2.CL))//recupereaza timpul de linistire trecut
{ // in timpul aerarii
LinistireREC = LinistireEvacuare - (Bazin_2_Linistire - AerareB2.CL);// continua linistirea pentru diferenta de timp trecut
}
else LinistireREC = 0;// timpul de linistire s-a epuizat si se poate realiza recircularea
}
//oprim toate pompele
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
PORTD &= ~_BV(PD2); // opreste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
PORTD &= ~_BV(PD3); // opreste releul de pe pinul D3 care activeaza pompa de aerare bazin 2
}
if (LinistireREC |= 0) LinistireREC--;
StareCiclu (2);// afisez starea pentru Recirculare
if (LinistireREC == 0 && Recirculare.OP == PornireRecirculare)
{
PORTC |= _BV(PC4); // porneste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC |= _BV(PC5); // porneste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
Recirculare.OP--;
}
else if ((LinistireREC == 0) && (Recirculare.OP != 0) ) Recirculare.OP--;
else if ((LinistireREC == 0) && (Recirculare.OP == 0) ) {Initializare_Ciclu();} // s-a terminat recircularea
}
}// end Recirculare
/**** AERARE ****/
if (AerareB1.SS == true && AerareB2.SS == true)//aerarea se face in pararel la timpi diferiti pt fiecare bazin
{
StareCiclu (3);// afisez starea pentru Aerare
//aerare Bazin 1
if (AerareB1.OP == Bazin_1_Aerare)
{
//oprim pompele de recirculare si evacuare
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
AerareB1.OP--;
PORTD |= _BV(PD2); // porneste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
}
else if (AerareB1.OP != 0) AerareB1.OP--;
else if ((AerareB1.OP == 0) && (AerareB1.CL == Bazin_1_Linistire))
{
PORTD &= ~_BV(PD2); // opresc releul de pe pinul D2 care activeaza pompa de aerare bazin 1
AerareB1.CL--;
}
else if ((AerareB1.OP == 0) && (AerareB1.CL != 0)) AerareB1.CL--;
else if ((AerareB1.OP == 0) && (AerareB1.CL == 0))
{
AerareB1.CL = Bazin_1_Linistire; AerareB1.OP = Bazin_1_Aerare;
}
// aerare Bazin 2
if (AerareB2.OP == Bazin_2_Aerare)
{
//oprim pompele de recirculare si evacuare
PORTC &= ~_BV(PC3); // opreste releul de pe pinul A3 care activeaza pompa de evacuare in exterior
PORTC &= ~_BV(PC4); // opreste releul de pe pinul A4 care activeaza pompa de evacuare in bazin 2
PORTC &= ~_BV(PC5); // opreste releul de pe pinul A5 care activeaza pompa de evacuare in bazin 0
AerareB2.OP--;
PORTD |= _BV(PD3); // porneste releul de pe pinul D2 care activeaza pompa de aerare bazin 1
}
else if (AerareB2.OP != 0) AerareB2.OP--;
else if ((AerareB2.OP == 0) && (AerareB2.CL == Bazin_2_Linistire))
{
PORTD &= ~_BV(PD3); // opresc releul de pe pinul D2 care activeaza pompa de aerare bazin 2
AerareB2.CL--;
}
else if ((AerareB2.OP == 0) && (AerareB2.CL != 0)) AerareB2.CL--;
else if ((AerareB2.OP == 0) && (AerareB2.CL == 0))
{
AerareB2.CL = Bazin_2_Linistire; AerareB2.OP = Bazin_2_Aerare;
}
}// end Aerare
}// end call_ISR_Timer
//////////////******** SAU TERMINAT FUNCTIILE UTILIZATE LA INTRERUPERILE ISR() ********///////////////
/*********** INTRERUPERI ISR LA PRIMIREA UNUI SEMNAL PE PIN **************/
/*****INTRERUPERE/EVENIMENT CARE APARE LA SCHIMBAREA UNUI PIN DIN HIGHT ÎN LOW SI INVERS *****/
//ATENTIE !!! pini D0 si D1 nu se utilizeaza sunt pentru transmisie seriala.
// exemplu
/*PCMSK2 ^= (1 << PD4); La schimbarea in LOW a pinului D4 acesta este dezactivat
pentru chemarea intreruperii ISR()
PCIFR |= bit (PCIF2); clear any outstanding interrupts - sterge toate intreruperile remanente
PCICR |= bit (PCIE2); enable pin change interrupts for D0 to D7 - activeaza intreruperile
Pentru pinii D2 si D3 se foloseste attachInterrupt() , ISR()-urile se folosesc doar pentru
pini pe care nu se poate folosii attachInterrupt()
Ecivalenta pini Dx si Ax in PBx, PCx, PDx se determina din schema Arduino NANO
_BV(n) este un macro care muta 1 << n
*/
// ISR (PCINT0_vect)//Portul B - handle pin change interrupt for D8 to D13 here
// {
// nu este utilizat
// } // end of ISR PCINT0_vect
// ISR (PCINT1_vect)//Portul C - handle pin change interrupt for A0 to A5 here
// {
// if (((PINC & (1 << PC0)) == 0) && bitRead(PCMSK1, PC0) )
// {
// PCMSK1 ^= (1 << PC0); // seteaza pinul A0 sa nu activeze ISR()-ul pana cand nu se trateaza evenimentul
// nivel_B1_Pin_A0 = true;// acest pin este pentru pompa de Evacuare in exterior
// Evacuare.SS = true; // porneste evacuarea cand s-a umplut BAZIN 1
// intarziere_Pin_A0 = 1;
// }
// if ((PINC & (1 << PC1)) == 0 )// acest pin este pentru pompa evacuare in Bazin 2
// { // si stabileste daca este atins nivelul de umplere
// nivel_B2_Pin_A1 = true;
// if ((PINC & (1 << PC0)) == 0) Evacuare.SS = true;// porneste evacuarea in exterior daca pompa de evacuare
// } // in BAZIN 2 este arsa
// else
// {
// nivel_B2_Pin_A1 = false;
// intarziere_Pin_A1 = 1;
// Evacuare.OP = PornireEvacuare;// Revine la PornireEvacuare dupa ce s-a evacuat tot surplusul de apa care
// // depașeste senzorul de nivel din bazinul 2, care nu poate fi mai mare
// // decat intrega cantitate de evacuat
// }
// if ((PINC & (1 << PC2)) == 0 ) prea_plin_B2_Pin_A2 = true;// acest pin este pentru prea plin din Bazin 2
// se seteaza prea_plin_B2_Pin_A2 = false in
// functia call_ISR_Timer dupa ce s-a tratat
// evenimentul adica, evacueaza in exterior 50 litri
// } // end of ISR PCINT1_vect
// ISR (PCINT2_vect )//Portul D - handle pin change interrupt for D4 to D7, D0 si D1 nu se folosesc
// {
// nu este utilizat
// } // end of ISR PCINT2_vect
/******************** FUNCTIE RESETARE SOFTWARE PLACA *******************/
// resetare arduino.
// Trebuie scrisa inainte functiei loop().
// resetFunc() este chemata cand este nevoie.
inline void(* resetFunc) (void) = 0;
/************************************************************************/
/************************ INTRERUPERE ISR PENTRU TIMP ***************************/
ISR(TIMER1_OVF_vect) //Interrupción del TIMER1
{
/************ INTRERUPERE/EVENIMENT CARE MASOARA TIMPUL IN SECUDE **********************************/
// Acesta intrerupere este folosita pentru functii de timp prin intreruperea functiei " loop () "
// Se poate utiliza pentru ceas, semnale pe pini, etc. care nu au nevoie de timp de precizie la microsecunda
// Variabila " Durata " este incrementata la fiecare secunda
// Pentru atribuirea variabilei " Durata " in void loop() se va utiliza
//ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { UNSIGNED Long temp = Durata} din lib. #include <util/atomic.h>
// pentru a nu se transmite un rezultat eronat in timpul intreruperii
Durata ++;// reprezinta timpul de cand este pornit controlerul aproximativ 68 ani adica 2^32 secunde
//TIMSK1 &= ~(1 << TOIE1);// opreste Timer 1 pana la terminarea executiei functiei call_ISR_Timer ()
// pentru a se evita imbricarea codului daca timpul de executie al
//call_ISR_Timer (); // functia de tratare evenimente pe PINI
//TIMSK1 |= (1 << TOIE1); // porneste Timer 1 dupa ce sa rulat call_ISR_Timer ()
//TCNT1 = 0xC2F7; // Reinitiaza Timer1
//Serial.println(micros());//(Durata%60);
flag_Timer1 = true;
timp_VACANTA ++;
}
void setup()
{
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{
// initializare pini butoane
pinMode(butonPinSETUP, INPUT_PULLUP);
pinMode(butonPinTimpMINUS, INPUT_PULLUP);
pinMode(butonPinTimpPLUS, INPUT_PULLUP);
// initializare pin buzzer
pinMode(buzzerPin, OUTPUT);
// initializare pini senzori de nivel (plutitori cu contacte REED montati in bazine)
pinMode(A0, INPUT_PULLUP);
pinMode(A1, INPUT_PULLUP);
pinMode(A2, INPUT_PULLUP);
lcd.begin(20, 4);
Serial.begin(9600);
Initializare_Ciclu();
// initializare MsTimer folosit pentru afisare intermitenta STARE / ALARM cand apare o alarma
//MsTimer2::set(500, Timer2_STARE_ALARM ); // intrerupre la 300 de milisecunde
//MsTimer2::start();
/******************************* Pin change interrupt ********************************************/
// sunt trei porturi PORTB, PORTC, PORTD - a se vedea diagrama controlerului si tabelul porturilor;
// DDRB, DDRC, DDRD seteaza I/O pe fiecare pin din port echivalent cu pinMode() mai rapid dar fara PULLUP;
// DDRD |= ~_BV(PD2) | ~_BV(PD4); Pini D2 si D4 setati input;
// DDRD &= (1 << PD2) & (1 << PD4); Pini D2 si D4 setati output;
// PORTD |= (1 << PD2) | (1 << PD4); Pini D2 si D4 setati PULLUP dupa ce sunt setati input ca mai sus;
// pentru fiecare port exista cite o intrerupere PCMSK0, PCMSK1, PCMSK2 - PCINTxx este nr. pinului
// in vectorul de intrerupere - vezi fisa de date a controlerului
// PCMSK2 |= bit (PCINT22); // want pin D6 - stabileste intrerupere pe pinul D6;
// PCMSK2 |= bit (PCINT21); // want pin D5 - stabileste intrerupere pe pinul D5;
// .......................
// PCMSK2 |= bit (PCINT17); // want pin D1 - stabileste intrerupere pe pinul D1;
// PCMSK2 |= bit (PCINT16); // want pin D0 - stabileste intrerupere pe pinul D0;
// sau se mai pot activa toti odata. Bitul cel mai scazut este D0 si se procedeaza pentru toate porturile la fel;
// initializare pini care activeaza intreruperea
// PCMSK1 |= 0b00000111; // seteaza A0, A1 si A3 sa activeze intreruperea ISR() ;
// PCIFR |= bit(PCIF1); // clear any outstanding interrupts - sterge toate intreruperile remanente;
// PCICR |= bit (PCIE1); // enable pin change interrupts for A0 to A5 - activeaza intreruperile;
// PCMSK2 |= 0b00001100; // seteaza D2, si D3 sa activeze ISR() ;
// PCIFR |= bit (PCIF2); // clear any outstanding interrupts - sterge toate intreruperile remanente;
// PCICR |= bit (PCIE2); // enable pin change interrupts for D0 to D7 - activeaza intreruperile;
/******* initializare pini iesire pompe *******/
DDRC |= _BV(PORTC3) | _BV(PORTC4) | _BV(PORTC5) ; // seteaza pinii A3, A4 si A5 OUTPUT mai rapid decat pinMode()
DDRD |= _BV(PORTD2) | _BV(PORTD3) ; // seteaza pinii D2 si D3 OUTPUT mai rapid decat pinMode()
// verificare contacte plutitori
// if ((PINC & (1 << PC0)) == 0)//verifica pe pinul A0 daca senzorul de nivel din BAZIN 1 este ON
// { //si activeaza evacuarea in exterior din BAZIN 2
// //PCMSK1 ^= (1 << PC0); // opreste pinul A0 sa declanseze evenimente numai dupa iesire din call_ISR_Timer
// nivel_B1_Pin_A0 = true; // pentru ca senzorul de nivel BAZIN 1 este in contact la pornirea Micro Controleru-lui
// Evacuare.SS = true; // adica BAZIN 1 este plin si trebuie executata evacuarea exterioara
// intarziere_Pin_A0 = 1;
// }
// if ((PINC & (1 << PC1)) == 0) nivel_B2_Pin_A1 = true;//verifica pe pinul A1 daca senzorul de nivel este ON,
// else nivel_B2_Pin_A1 = false; //adica daca BAZIN 2 este la nivel
// if ((PINC & (1 << PC2)) == 0) prea_plin_B2_Pin_A2 = true;//verifica pe pinul A2 daca senzorul de prea plin din Bazin 2 este ON,
// else prea_plin_B2_Pin_A2 = false; //asta insemna ca in timpul linistirii inainte de evacuare in exterior
//debitul de apa din canalizare este atat de mare, incat este depasit
//nivelul de prea plin din BAZIN 1 si BAZIN 2
//rezerva de prea plin reprezinta 400 de litrii in 15 min (900 sec)
//care reprezinta 27 de litrii/min
/**************** setare intreruperea ISR pentru timp ********************************************/
//Activeaza întreruperea pentru Timer1 dupa ce s-a citit starea pinilor care provoaca intreruperi
// TCCR1A = 0; //Registrul de control A pe 0, pinii OC1A și OC1B dezactivați
// TCCR1B = 0; //opreste ISR() timer si reseteaza clock-ul
// TCCR1B |= (1<<CS10)|(1 << CS12); //Configureaza prescaler 1024: CS12 = 1 si CS10 = 1
// TCNT1 = 0xC2F8; //Pornste cronometrul pentru depășire la 1 secundă
//65536-(16MHz/1024/1Hz - 1) = 49912 = 0xC2F8 in hexadecimal
// TIMSK1 |= (1 << TOIE1); //Activeaza întreruperea pentru Timer1
// Folosesc setarea de mai jos fiinca este mai exacta
// si nu mai este nevoie de resetarea registrului TCNT1
// RTM_TimerCalc 1.40, RuntimeMicro.com
// Timer-1 16-bit, Mode-10 Phase, Top=ICR
// 1 Second Interval, Clock is 16 MHz
TCCR1B = 0x10; // 0001 0000, Disable Timer
TCCR1A = 0xA2; // 1010 0010
ICR1 = 31250; // valuare TOP
TCNT1 = 0x0; // porneste de la 0
TCCR1B |= 4; // Prescale=256, Enable Timer in binar 0000 0100
// sau (1<<CS10)|(0 << CS11)|(0 << CS12) prin scriere registrii
// Set Overflow Interrupt Mask Bit
TIMSK1 |= 1; // ISR Prototype --> ISR(TIMER1_OVF_vect){}
/*************************************************************************************************/
} //end ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
}// end setup()
void loop()
{
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{
if ( flag_Timer1 ) { flag_Timer1 = false; call_ISR_Timer ();}
if (Durata > 604800)
{
Initializare_Ciclu();
resetFunc() ;// se reseteaza controlerul la fiecare 7 de zile daca nu ajung sa elimin
} // alarmele cu speranta ca nu sunt arse pompele si sunt doar murdari senzorii
}
Defilare_Meniu_Setup();// intra in meniul SETUP cand buttonSETUP este apasat
}//end loop()
//////////////////////// FUNCTII INTRODUSE IN void loop() //////////////////////////////////////////
/************ FUNCTIE CARE DETERMINA CAT TIMP ESTE APASAT UN BUTON *******************/
// ACEASTA FUNCTIE DETERMINA CÂT TIMP UN BUTON ESTE APASAT SI RETURNEAZA TRUE DACA ESTE DEPASIT timpAPASARE
// SAU DACA timpAPASARE = 0 secunde RETURNEAZA EFECTIV TIMPUL DE APASARE
// TIMPUL MAXIM DE APASARE ESTE 2^32-1 MILISECUNDE APROXIMATIV 50 ZILE APOI SE RESETEAZA
// Variabila " btnPIN " reprezinta numarul pinului la care este atasat butonul activat in functia " setup "
// Pinii digitali sunt de la 0 pana la 13
// Pinii analogici de la A0 pana la A7 pentru Arduino NANO PLUS ( ch340 )
// Pinii analogici trebuie introdusi in cadrul functiei cu constantele implicite A0..A7 si au valori de la 14 .. 21
// Se foloseste functia " digitalRead() " indiferent de tipul pinului
// Variabila " start " reprezinta timpul la care a fost apasat butonul si se determina
// cu functia arduino " millis() "
// Variabila " timpAPASARE " reprezinta timpul necesar de apasare ca butonul sa produca efect si este dat in milisecude,
// In interiorul functiei calculul se realizeaza in milisecunde deoarece valoarea " start " este data de functia " millis() "
// Se poate folosi si ISR-ul de mai sus
unsigned long Timp_Apasare_BTN ( const byte &btnPIN, const unsigned long &timpAPASARE )
{
unsigned long secundeDOWN = 0;
unsigned long start = millis();
if (digitalRead(btnPIN)) {return false;}
while(!digitalRead(btnPIN)) { secundeDOWN = millis(); }
if ( secundeDOWN >= start )
{
if (timpAPASARE == 0) {return (secundeDOWN - start);}
else if ((secundeDOWN - start) >= timpAPASARE) {return true;}
else {return false;}
}
else if (secundeDOWN < start)
{
if (timpAPASARE == 0) {return (( pow(2 , 32) -1 - start) + secundeDOWN );}
else if ((( pow(2 , 32) -1 - start) + secundeDOWN )>= timpAPASARE) {return true;}
else {return false;}
}
}//end Timp_Apasare_BTN
/*********************** FUNCTIE Blink_Meniu ***********************/
// Acesata functie afiseaza meniul pentru afisaj 20x4
// Meniul selectat va clipi
// Prima linie a afisajului este folosita pentru titlu
// Sunt afisate doar trei linii de meniu
// Denumirea meniului nu trebuie sa fie mai mare de 14 caractere daca este
// necesara introducere de date, altfel sa nu depasasca 18 caractere
// sel reprezinta pozitia meniului selectat
// sel reprezinta linia de afisare cu valori 1, 2 sau 3
// val_ reprezinta valorile variabilelor care se vor afisa modificate prin introducere de date
// UM_ reprezinta unitatea de masura
void Blink_Meniu ( int sel = 1, String meniu_1 = "", String meniu_2 = "", String meniu_3 = "",
int val_1 = -1, int val_2 = -1, int val_3 = -1,
String UM_1 = "", String UM_2 = "",String UM_3 = "" )
{
unsigned long timpBlink ;// timpul de afisare a textului
int max_nrChar;// nr. maxim de caracte dintr-un meniu afisat
timpBlink = millis ();
timpBlink %= 300;
max_nrChar =max ( max( meniu_1.length(), meniu_2.length() ), meniu_3.length() ) + 3;// se aduna 3 pentru ca adauga caracterul >> sau 2 spatii inainte + spatiul de delimitare
switch (sel) { // stabileste meniul selectat
case 1: meniu_1 = ">> " + meniu_1; meniu_2 = " " + meniu_2 ; meniu_3 = " " + meniu_3 ; break;
case 2: meniu_1 = " " + meniu_1 ; meniu_2 = ">> " + meniu_2; meniu_3 = " " + meniu_3 ; break;
case 3: meniu_1 = " " + meniu_1 ; meniu_2 = " " + meniu_2 ; meniu_3 = ">> " + meniu_3; break;
}
for ( int i = 2; i = max_nrChar - meniu_1.length(); i++ ) { meniu_1 = meniu_1 + " "; } // se adauga spatii daca textul este mai mic decat max_nrChar
for ( int i = 2; i = max_nrChar - meniu_2.length(); i++ ) { meniu_2 = meniu_2 + " "; } // se adauga spatii daca textul este mai mic decat max_nrChar
for ( int i = 2; i = max_nrChar - meniu_3.length(); i++ ) { meniu_3 = meniu_3 + " "; } // se adauga spatii daca textul este mai mic decat max_nrChar
while (timpBlink > 100 && timpBlink < 299) {
lcd.setCursor(0, 1); lcd.print( meniu_1 ); if (val_1 != -1) { lcd.setCursor(max_nrChar, 1); lcd.print(val_1); }; if (UM_1 != "") { lcd.setCursor(17, 1); lcd.print(UM_1); }
lcd.setCursor(0, 2); lcd.print( meniu_2 ); if (val_2 != -1) { lcd.setCursor(max_nrChar, 2); lcd.print(val_2); }; if (UM_2 != "") { lcd.setCursor(17, 2); lcd.print(UM_2); }
lcd.setCursor(0, 3); lcd.print( meniu_3 ); if (val_3 != -1) { lcd.setCursor(max_nrChar, 3); lcd.print(val_3); }; if (UM_3 != "") { lcd.setCursor(17, 3); lcd.print(UM_3); }
timpBlink = millis (); timpBlink %= 300;
}
// if (val_1 != -1 && sel == 1) { lcd.setCursor(0,sel); lcd.print(" ");//creaza efectul de clipire a caracterelor >>
// lcd.setCursor(max_nrChar, sel); lcd.print(" ");}//afiseaza 3 spatii si creaza efectul de clipire citire date
// else if (val_2 != -1 && sel == 2) { lcd.setCursor(0,sel); lcd.print(" ");//creaza efectul de clipire a caracterelor >>
// lcd.setCursor(max_nrChar, sel); lcd.print(" ");} //afiseaza 3 spatii si creaza efectul de clipire citire date
// else if (val_3 != -1 && sel == 3) { lcd.setCursor(0,sel); lcd.print(" ");//creaza efectul de clipire a caracterelor >>
// lcd.setCursor(max_nrChar, sel); lcd.print(" ");} //afiseaza 3 spatii si creaza efectul de clipire citire date
// else { lcd.setCursor(0, sel); lcd.print( ">> " ); }//afiseaza >> + 19 spatii si creaza efectul de clipire meniu
if (val_1 != -1 && sel == 1) { lcd.setCursor(max_nrChar, sel); lcd.print(" ");} //afiseaza 3 spatii si creaza efectul de clipire citire date
else if (val_2 != -1 && sel == 2) { lcd.setCursor(max_nrChar, sel); lcd.print(" ");} //afiseaza 3 spatii si creaza efectul de clipire citire date
else if (val_3 != -1 && sel == 3) { lcd.setCursor(max_nrChar, sel); lcd.print(" ");} //afiseaza 3 spatii si creaza efectul de clipire citire date
else { lcd.setCursor(0, sel); lcd.print( ">> " ); }//afiseaza >> + 18 spatii si creaza efectul de clipire meniu
}// end Blink_Meniu
/***************** FUNCTIE Afisare_Meniu ********************/
// Aceasta functie afiseaza Meniul si Meniul selectat prin licarire si marcat cu caracterul ">"
// Functia este utilizata in interiorul functiei Defilare_Meniu ()
inline void Afisare_Meniu_Setup ()
{
if (Meniu >= 1 && Meniu <= 4) { lcd.setCursor(0, 0); lcd.print("------ SETARE ------"); }
switch (Meniu) {
case 1: // Meniu principal 1 - AERARE
Blink_Meniu ( 1, "AERARE", "EVACUARE", "RECIRCULARE" ); break;
case 2: // Meniu principal 2 - EVACUARE
Blink_Meniu ( 2, "AERARE", "EVACUARE", "RECIRCULARE" ); break;
case 3: // Meniu principal 3 - RECIRCULARE
Blink_Meniu ( 3, "AERARE", "EVACUARE", "RECIRCULARE" ); break;
case 4: // Meniu principal 4 - EXIT
Blink_Meniu ( 3, "EVACUARE", "RECIRCULARE", "EXIT" ); break;
case 5: // Meniu AERARE
if (subMeniuAERARE >= 1 && subMeniuAERARE <= 3) { lcd.setCursor(0, 0); lcd.print("-- SETARE: AERARE --");}
switch (subMeniuAERARE) { // subMeniuAERARE
case 1:
Blink_Meniu ( 1, "BAZIN 1", "BAZIN 2", "EXIT" ); break;
case 2:
Blink_Meniu ( 2, "BAZIN 1", "BAZIN 2", "EXIT" ); break;
case 3:
Blink_Meniu ( 3, "BAZIN 1", "BAZIN 2", "EXIT" ); break;
case 4: //Aerare BAZIN 1
lcd.setCursor(0, 0); lcd.print("-- AERARE BAZIN 1 --");
switch (subMeniuBazin_1_AERARE) {
case 1: // PORNIRE
Blink_Meniu ( 1, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_1_Aerare, Bazin_1_Linistire/60,-1, "sec", "min" ); break;
case 2: // LINISTIRE
Blink_Meniu ( 2, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_1_Aerare, Bazin_1_Linistire/60, -1, "sec", "min" ); break;
case 3: //SAVE & EXIT
Blink_Meniu ( 3, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_1_Aerare, Bazin_1_Linistire/60, -1, "sec", "min" ); break;
}
break;
case 5: // Aerare BAZIN 2
lcd.setCursor(0, 0); lcd.print("-- AERARE BAZIN 2 --");
switch (subMeniuBazin_2_AERARE) {
case 1: // PORNIRE
Blink_Meniu ( 1, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_2_Aerare, Bazin_2_Linistire/60, -1, "sec", "min" ); break;
case 2: // LINISTIRE
Blink_Meniu ( 2, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_2_Aerare, Bazin_2_Linistire/60, -1, "sec", "min" ); break;
case 3: // SAVE & EXIT
Blink_Meniu ( 3, "PORNIRE", "LINISTIRE", "SAVE & EXIT",Bazin_1_Aerare, Bazin_1_Linistire/60, -1, "sec", "min" ); break;
}
break;
}
break;
case 6: // Meniu EVACUARE
if (subMeniuEVACUARE >= 1 && subMeniuEVACUARE <= 2) { lcd.setCursor(0, 0); lcd.print("----- EVACUARE -----");}
switch (subMeniuEVACUARE) { // subMeniuAERARE
case 1:
Blink_Meniu ( 1, "PORNIRE", "SAVE & EXIT", "", PornireEvacuare, -1, -1, "sec" ); break;
case 2:
Blink_Meniu ( 2, "PORNIRE", "SAVE & EXIT", "", PornireEvacuare, -1, -1, "sec" ); break;
}
break;
case 7: // Meniu RECIRCULRE
if (subMeniuRECIRCULARE >= 1 && subMeniuRECIRCULARE <= 2) { lcd.setCursor(0, 0); lcd.print("---- RECIRCULARE ---");}
switch (subMeniuRECIRCULARE) { // subMeniuAERARE
case 1:
Blink_Meniu ( 1, "PORNIRE", "ASTEPTARE" , "SAVE & EXIT", PornireRecirculare, AsteptareRecirculare, -1, "sec" , "ore" ); break;
case 2:
Blink_Meniu ( 2, "PORNIRE", "ASTEPTARE" , "SAVE & EXIT", PornireRecirculare, AsteptareRecirculare, -1, "sec" , "ore" ); break;
case 3:
Blink_Meniu ( 3, "PORNIRE", "ASTEPTARE" , "SAVE & EXIT", PornireRecirculare, AsteptareRecirculare, -1, "sec" , "ore" ); break;
}
break;
}
}// end Afisare_Meniu_Setup
/***************** FUNCTIE CARE DEFILEZA MeniuL SETARE CU UN SINGUR BUTON ********************/
// Cand este chemata modifica valoare variabilei " Meniu ".
// Functia este executata numai cand valorea variabilei " Meniu " este >= 1
// Cand variabila " Meniu = -1 " microcontroler-ul executa alte operatii
// Daca butonul SETARE este apasat 1 secunda programul intra in modul setare
// Daca butonul SETARE este apasat 1 secunda pe subMeniu se intra in subMeniuri
inline void Defilare_Meniu_Setup ()
{
if (Meniu == -1 && digitalRead(butonPinSETUP)) return;
// unsigned long timpAPASARE = 1000;// timpul de apasare al butonului in milisecunde - adica 1 secunda
Afisare_Meniu_Setup ();
if (digitalRead(butonPinSETUP)) return;
bool timp = Timp_Apasare_BTN ( butonPinSETUP, 1000 );// returneaza intotdeauna TRUE sau FALSE
// deoarece timpAPASARE este diferit de zero
switch (Meniu) { // Meniul principal are 4 submeniuri
case -1: // intra in modul SETARE
if (timp) { Meniu = 1; lcd.clear ();}
break;
case 1: // Meniu principal 1 - AERARE
if (!timp) { Meniu ++; }
else { Meniu = 1 + 4; subMeniuAERARE = 1; lcd.clear(); }
break;
case 2: // Meniu principal 2 - EVACUARE
if (!timp) { Meniu ++; }
else { Meniu = 2 + 4; subMeniuEVACUARE = 1; lcd.clear(); }
break;
case 3: // Meniu principal 3 - RECIRCULARE
if (!timp) { Meniu ++; }
else { Meniu = 3 + 4; subMeniuRECIRCULARE = 1; lcd.clear(); }
break;
case 4: // Meniu principal 4 - EXIT
if (!timp) { Meniu = 1; }
else { Meniu = -1 ; subMeniuAERARE = -1; subMeniuEVACUARE = -1; subMeniuRECIRCULARE = -1; lcd.clear(); }
break;
case 5: // Meniu secundar 1 - AERARE
switch (subMeniuAERARE) { // subMeniuAERARE are 3 subMeniuri bazin 1 bazin 2 exit
case 1: // sub Meniu BAZN 1
if (!timp) { subMeniuAERARE ++; }
else { subMeniuAERARE = 1 + 3; subMeniuBazin_1_AERARE = 1;}
break;
case 2: // sub Meniu BAZN 2
if (!timp) { subMeniuAERARE ++; }
else { subMeniuAERARE = 2 + 3; subMeniuBazin_2_AERARE = 1;}
break;
case 3: // sub Meniu EXIT
if (!timp ) { subMeniuAERARE = 1; }
else { Meniu = 1; subMeniuAERARE = -1; lcd.clear ();}
break;
case 4: //sub Meniu Bazin 1 AERARE // are 3 submeniuri PORNIRE , LINISTIRE si SAVE & EXIT
switch (subMeniuBazin_1_AERARE) {
case 1: //PORNIRE
if (!timp ) { subMeniuBazin_1_AERARE++; }
break;
case 2: //LINISTIRE
if (!timp ) { subMeniuBazin_1_AERARE++; }
break;
case 3: //SAVE & EXIT
if (!timp ) { subMeniuBazin_1_AERARE = 1; }
else { subMeniuAERARE = 1; subMeniuBazin_1_AERARE = -1; subMeniuBazin_2_AERARE = -1; lcd.clear (); }
break;
}// end switch (subMeniuBazin_1_AERARE)
break;
case 5: //sub Meniu Bazin 2 AERARE // are 3 submeniuri PORNIRE , LINISTIRE si SAVE & EXIT
switch (subMeniuBazin_2_AERARE) {
case 1: //PORNIRE
if (!timp ) { subMeniuBazin_2_AERARE++; }
break;
case 2: //LINISTIRE
if (!timp ) { subMeniuBazin_2_AERARE++; }
break;
case 3: //SAVE & EXIT
if (!timp ) { subMeniuBazin_2_AERARE = 1; }
else { subMeniuAERARE = 2; subMeniuBazin_1_AERARE = -1; subMeniuBazin_2_AERARE = -1; lcd.clear (); }
break;
}// end switch (subMeniuBazin_2_AERARE)
break;
}// end switch (subMeniuAERARE)
break;
case 6: // sub Meniu EVACUARE // are un2 sub Meniuri PORNIRE si SAVE & EXIT
switch (subMeniuEVACUARE) {
case 1: //PORNIRE
if (!timp ) { subMeniuEVACUARE++; }
break;
case 2: //SAVE & EXIT
if (!timp ) { subMeniuEVACUARE = 1; }
else { Meniu = 2; subMeniuEVACUARE = -1; lcd.clear (); }
break;
}// end switch (subMeniuEVACUARE)
break;
case 7: // RECIRCULARE // are un2 sub Meniuri PORNIRE si SAVE & EXIT
switch (subMeniuRECIRCULARE) {
case 1: //PORNIRE
if (!timp ) { subMeniuRECIRCULARE++; }
break;
case 2: //ASTEPTARE
if (!timp ) { subMeniuRECIRCULARE++; }
break;
case 3: //SAVE & EXIT
if (!timp ) { subMeniuRECIRCULARE = 1; }
else { Meniu = 3; subMeniuRECIRCULARE = -1; lcd.clear (); }
break;
}// end switch (subMeniuRECIRCULARE)
break;
}// end switch (Meniu)
}//end Defilare_Meniu_Setup