B1 Energy manager (some notes at section end)

Transcript

1 B1 Energy manager (some notes at section end) L energy manager e una figura professionale con competenze tecniche ed economiche tali da consentire il monitoraggio, l analisi e l ottimizzazione dell utilizzo dell energia. In questo progetto Arduino monitorizza il consumo di energia elettrica di tre utenze e nel momento in cui il consumo globale supera una soglia predefinita, procede alla temporanea disattivazione dell utenza meno prioritaria. Sotto il profilo operativo il sistema consente di definire, tramite un tastierino da 11 tasti, la soglia di massimo consumo ammissibile (in watt) e di assegnare ad ogni utenza un livello di priorita (3, 2, oppure 1: alta, media oppure bassa). Subito dopo l assegnazione delle priorita il sistema inizia a monitorare il consumo di ogni utenza e nel momento in cui la soglia viene superata per piu di 5 secondi consecutivi, attiva un countdown di 5 secondi al termine del quale disattiva l utenza meno prioritaria. Il sistema segnala la fase di countdown sia tramite il display lcd, che facendo lampeggiare un led rosso, che attivando un cicalino. Se nonostante la disattivazione dell utenza meno prioritaria il consumo globale continua ad essere superiore alla soglia, il sistema attiva nuovamente il countdown al termine del quale disattiva la successiva utenza meno prioritaria. Il sistema continua il monitoraggio e nel momento in cui il consumo scende al punto da consentire la riattivazione di un utenza disattivata (nel momento in cui la disponibilita residua di energia diventa superiore del 10% all ultimo consumo rilevato per l utenza con maggiore priorita tra le disattivate), procede alla riattivazione, sempre preceduta da un countdown di 5 secondi. I principi di funzionamento e di utilizzo del sensore TA12-100, per la rilevazione istantanea del consumo di corrente, sono descritti nel progetto 53 - misuratore di corrente, cui si rimanda per gli opportuni approfondimenti. Attenzione: Nel caso si volesse replicare questo progetto, si raccomanda la massima attenzione nell utilizzo delle apparecchiature collegate alla rete elettrica, per via delle alte tensioni presenti. Prima di compilare il programma bisogna, scaricare ed installare, se non gia fatto: La libreria di gestione del display a cristalli liquidi, reperibile qui. Per installare una libreria: Scaricarla mantenendola in formato compresso Andare in IDE-> sketch-> importa libreria-> add library-> Individuare la cartella di download-> Fare doppio click sulla libreria da installare Verificarne la presenza in IDE-> sketch-> includes Library-> Contributed library Bisogna anche installare, sempre se non gia fatto, la libreria keypad, gia presente nel library manager ma non ancora installata (sketch->include libreria->gestione librerie)

2 Nota: Questo esercizio e questa nota sono parte di una serie che vede protagonisti Arduino ed alcuni dei componenti ad esso collegabili. Per la maggior parte degli esercizi e anche disponibile un filmato su youtube: Esercizi facenti parte della raccolta Filmati presenti su youtube Informazioni su arduino e sui componenti collegabili (PDF scaricato nell area di download) Breve manuale di programmazione (PDF scaricato nell area di download) Per eventuali chiarimenti o suggerimenti sul contenuto di questa scheda scrivere a giocarduino@libero.it Here some notes about this project, translated by google translator The energy manager is a professional profile with technical and economic skills that allow energy use monitoring, analysis and optimization. In this project Arduino monitors electricity consumption on three users and when global consumption exceeds a predefined threshold, proceeds to a temporary deactivation of the less priority user. Under operating profile, the system allows to define, by means of an 11-key keypad, the maximum consumption threshold (in watts) and to assign to each user a priority level (high, medium, low). Immediately after the priority assignment, system starts monitoring consumption of each user and when the threshold is exceeded for more than 5 consecutive seconds, activates a countdown of 5 seconds at the end of which deactivates the less priority user. System shows countdown phase both on a LCD display, which by a flashing red led and a buzzer activation. If, despite the least priority user deactivation, the global consumption continues to exceed the threshold, system activates the countdown again after which deactivates the next least priority user. System continues monitoring and, when consumption allows the reactivation of a deactivated utility (when the residual availability becomes 10% higher than the last consumption detected on users with higher priority among deactivated), proceeds to reactivation, always preceded by a 5 seconds countdown. The TA sensor operation rules, for instantaneous detection of current consumption, are described in project 53 current meter, to which reference should be made for further details. Warning: If you want replicate this project, we recommend the utmost care in use of connections and equipment connected to mains, because of the high voltages present. Before proceeding to program compilation must be installed, if not already done, the library: LiquidCrystal_I2C.h found here For library installation, see process shown in previous projects, and summarized in: library download in compressed form; Installation via IDE-> sketch-> includes Library-> add.zip library

3 After installation please verify the library. It must be present in IDE-> sketch-> includes Library-> Contributed library We must also install, if not already done, the "keypad" library, present in the IDE library manager but not yet installed (sketch-> include library-> library management) Note: This project and this note is part of a series that sees, as main characters, Arduino and some of connectable components. For most projects there is also a video on youtube. Projects collection Movies on youtube About Arduino and components (italian; pdf will be downloaded in your download area Quick programming guide (almost english; pdf will be downloaded in your download area) For any questions or suggestions about this note (and on its english translation), please write to giocarduino@libero.it (simple words and short sentences, please) Materiali 3 sensori di corrente modello TA relays 1 tastiera da 11 tasti 1 display tipo 2004 con driver I2C 1 buzzer 1 led rosso 2 resistenze da 220 ohm

4 Schema Programma /* Attenzione: facendo il copia/incolla dal PDF all IDE si perde la formattazione del testo. Per rendere piu facilmente leggibile il programma e opportuno formattarlo subito dopo il trasferimento nell IDE, premendo CTRL+T. Prima di compilare il programma scaricare ed installare, se non gia' fatto, le seguenti librerie: - driver I2C del display: - libreria keypad.h, presente nel "library manager" e da installare tramite il library manager Questo programma misura l'assorbimento di tre utenze elettriche e, al superamento di una soglia globale predefinita, procede all'interruzione programmata del flusso elettrico verso l'utenza con priorita' piu' bassa. Il programma procede anche, autonomamente, alla riattivazione di un'eventuale utenza spenta nel momento in cui il consumo globale ne consente la riaccensione la soglia di consumo (in watt) e la priorita' di attivazione/disattivazione di ogni singola utenza sono definite dall'utente mediante una tastiera numerica da 11 tasti connessioni - pin da 2 a 8: tastiera numerica (il pin2 e' collegato il primo connettore di destra della tastiera mentre il pin 8 e' collegato al primo connettore di sinistra - pin 9: led di "warning", che si illumina durante il countdown di attivazione/disattivazione di un'utenza - pin 10: rele' di attivazione /disattivazione dell'utenza # 3 - pin 11: rele' di attivazione /disattivazione dell'utenza # 2

5 - pin 12: rele' di attivazione /disattivazione dell'utenza # 1 - pin 13: buzzer di "warinig" che si attiva durante il countsown di attivazione/disattivazione di un'utenza - pin analogico 1: connesso al rilevatore (modulo TA12-100) dell'utenza #1 - pin analogico 2: connesso al rilevatore (modulo TA12-100) dell'utenza #2 - pin analogico 3: connesso al rilevatore (modulo TA12-100) dell'utenza #3 - pin analogici 4 e 5 (bus SDA/SCL): connessi al driver I2C del display 2004 (20 caratteri su 4 righe) Warning: cut&paste from PDF to IDE loses formatting. To restore it press CTRL + T. Before compiling program you must download and install, if not already done, the following libraries: - I2C display driver: - keypad.h library, present in the IDE's library repository, and to be installed through the library Manager This program measures the absorption of three electrical devices and when a global threshold is exceeded, proceeds to a scheduled interruption on appliance with lower priority. The program also proceeds, autonomously, to reactivation of an eventual powered off device when global consumption allows it to be re-ignited The consumption threshold (in watts) and the activation / deactivation priority of each appliance are defined by user, using an 11 keys numeric keypad Connections - pin 2 to 8: numeric keypad (pin2 is connected to the first connector on the right while pin 8 is connected to the leftmost one - pin 9: "warning" led, which lights up during the activation / deactivation countdown of a device - pin 10: device # 3 activation / deactivation relay - pin 11: device # 2 activation / deactivation relay - pin 12: device # 1 activation / deactivation relay - pin 13: "warinig" buzzer that activates during the activation / deactivation countdown of a device - analog pin 1: connected to the detector (module TA12-100) of device # 1 - analog pin 2: connected to the detector (module TA12-100) of device # 2 - analog pin 3: connected to the detector (module TA12-100) of device # 3 - analog pins 4 and 5 (SDA / SCL bus): connected to the I2C driver of the 2004 display (20 characters on 4 lines) */ #include <Keypad.h> libreria di gestione della tastiera #include <Wire.h> libreria wire presente, di fault, nell'ide #include <LiquidCrystal_I2C.h> libreria di gestione del display lcd nelle prossime due righe vengono attribuiti i parametri per la gestione del display addr, en,rw,rs,d4,d5,d6,d7,bl,blpol LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); const byte righe = 4; numero di righe della tastiera (quattro) const byte colonne = 3; numero di colonne della tastiera (tre) char chiave[righe][colonne] = tabella di trascodifica dei tasti battuti. la tabella riproduce, su quattro righe di quattro colonne, la posizione dei tasti e assegna ad ogni tasto il valore che gli compete. E'possibile assegnare valori diversi semplicemente modificando i singoli valori in tabella '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '0', '#' ; byte pinrighe[righe] = 8, 7, 6, 5; porte cui devono essere connessi i pin delle righe (i primi quattro pin di sinistra) della tastiera byte pincolonne[colonne] = 4, 3, 2,; porte cui devono essere connessi i pin delle colonne (gli ultimi quattro pin di destra) della tastiera prossima riga: assegnazione dei parametri alla libreria keypad.h Keypad keypad = Keypad( makekeymap(chiave), pinrighe, pincolonne, righe, colonne ); char tastobattuto; variabile di memorizzazione del carattere battuto byte semaforo = 0; semaforo di acquisizione delle priorita' byte semaforoval = 0; semaforo di gestione della routine di ricezione valori da tastiera int valore = 0; numero battuto (password) battuto sulla tastiera int moltiplicatore = 0; utilizzato nel calcolo del codice battuto su tastiera

6 byte indice = 0; utilizzato nel calcolo del valore battuto su tastiera byte tabnum [5]; zona di memorizzazione dei singoli tasti battuti byte indtab = 0; indice di scorrimento della tabella tabnum byte numerocifre = 4; numero delle cifre da digitare su tastiera int soglia = 0; zona di memorizzazone della soglia di massimo consumo globale byte priorita [5]; tabella delle priorita'; l'indice di scorrimento identifica l'utenza (1 = utenza 1 e 3 = utenza 3) mentre il contenuto (1 oppure 2 oppure 3) identifica la priorita': 1 = bassa, 2 = media, 3 = alta int statoutenza [5] = tabella dello stato dell'utenza 0, 1, 1, 1; 0 = utenza disattiva; 1 = utenza attiva. le utenze sono inizialmente tutte attive int potenzaassorbita [5]; tabella di memorizzazione della potenza assorbita da ogni utenza; l'indice identifica l'utenza (1 = utenza 1, 2 = utenza 2 e 3 = utenza 3) byte utenza = 0; numero utenza e indice di scorrimento tabelle priorita' e potenzaassorbita byte valorevalido = 0; semaforo ciclo acquisizione priorita: 0 = non valida; 1 = valida byte controllopriorita [5] = ' ', '*', '*', '*'; tabella di controllo priorita' (la priorita' e' l'indice della tabella e se il contenuto e' "*" la priorita' e' valida) float momentocorrente = 0; momento corrente (utilizato nel countdown) float momentoprec = 0; momento precedente (utilizzato nel countdown) float momentoinizio = 0; momento di inizio osservazione consumi float momentoiniziopicco = 0; momento di inzio della rilevazione del picco int assorbimentoglobale = 0; totale assorbimento istantaneo int prioritapiubassa = 4; priorita' piu' bassa tra le utenze disattivabili int utenzainesame = 0; utenza da attivare o disattivare int tempo = 0; tempo trascorso da inizio countdown int picco [4]; tabella dei picchi in un secondo int statosensore = 0; valore istantaneo fornito dal sensore float tensione = 0; tensione erogata dal rilevatore float intensita = 0; intensita corrente prodotta dal rilevatore float intensitarms = 0; valore efficace (o RMS) della corrente prodotta dal rilevatore float ampere = 0; ampere in erogazione sull'utenza (il sensore genere 1/1000 della corrente in erogazione) int watt = 0; watt in erogazione sull'utenza byte semaforoconsumo = 2; semaforo che indica la situazione del consumo: 0 = sotto la soglia e 1 = sopra la soglia (2 = valore iniziale, non valido ma usato per forzare l'inizializzazione dei parametri di tempo) int residuosoglia = 0; potenza non utilizzata, fruibile da un'eventuale utenza disattivata int potenzanecessaria = 0; potenza necessaria per riattivare un'utenza (il 10% in piu' dell'ultimo consumo rilevato) int tabrele [4] = 0, 12, 11, 10; tabella di correlazione tra utenza e rele': l'utenza 1 e' gestita dal rele' collegato alla porta 12; l'utenza 2 e' gestita dal rele' collegato alla porta 11 mentre l'utenza 3 e' gestita dal rele' collegato alla porta 10 *****routine di ricezione dei caratteri da tastiera e loro trasformazione in valori **** *********** receives data from keypad and transforms them in a value ******************** void ricevivalore (void) valore = 0; semaforoval = 0; for (indtab = 0; indtab <= 5; indtab++) azzera la tabella dei valori tabnum[indtab] = 0; indtab = 0; while (semaforoval == 0) loop di ricezione dati tastobattuto = keypad.getkey(); acquisisce il valore del tasto battuto if (tastobattuto) se e' stato battuto un tasto delay (150); attende 1,5/10 di sec. per evitare una doppia battuta lcd.print (tastobattuto); visualizza sul display il tasto battuto if ((tastobattuto >= '0') && (tastobattuto <= '9')) tabnum [indtab] = tastobattuto - 48; memorizza il valore battuto, trasformato in un numero da 0 a 9 indtab++; if (indtab == numerocifre) semaforoval = 1; esce dal loop di ricezione dati if (tastobattuto == '#') se e' stato battuto il fine input semaforoval = 1; esce dal loop di ricezione dati ********* trasforma le singole cifre battute in un numero unico ****** moltiplicatore = 1;

7 for (indice = indtab; indice > 1; indice--) moltiplicatore = moltiplicatore * 10; for (indice = 0; indice <= indtab; indice++) valore = valore + tabnum[indice] * moltiplicatore; moltiplicatore = moltiplicatore / 10; ***** routine di rilevazione dell'assorbimento istantaneo di ogni utenza************ ************** routine to detect the instantaneous absorption of each device ****** void rilevaassorbimento () assorbimentoglobale = 0; utenza = 1; Inizializza il numero di utenza while (utenza < 4) statosensore = analogread (utenza); if (statosensore > picco [utenza]) picco [utenza] = statosensore; memorizza il valore piu' alto rilevato utenza ++; ************* routine di calcolo dell'assorbimento di ogni utenza ******************* ********************* computes each appliance absorption **************************** void calcolaconsumo () momentoiniziopicco = momentocorrente; for (utenza = 1; utenza < 4; utenza++) tensione = (picco [utenza] * 5.0) / ; trasforma in una tensione il valore di picco rilevato sulla porta analogica picco [utenza] = 0; azzera il valore di picco, per consentire una nuova misurazione intensita = (tensione / 200.0); applica la legge di ohm per calcolare l'intensita della corrente prodotta dal secondario (200 sono gli ohm della resistenza sulla quale viene misurata la tensione) intensitarms = intensita * 0.707; calcola il "valore efficace" o valore RMS ampere = intensitarms * 1000; calcola gli ampere in erogazione sull'utenza (il rapporto tra primario e secondario e' 1:1000) watt = ampere * 220; if (statoutenza [utenza] == 1) se si tratta di un'utenza attiva potenzaassorbita [utenza] = watt; memorizza la potenza istantanea assorbita dall'utenza assorbimentoglobale = assorbimentoglobale + potenzaassorbita [utenza]; lcd.setcursor (0, utenza); lcd.print ("assorb. "); lcd.print (utenza); lcd.print (" - W: "); lcd.print (watt); lcd.print (" "); lcd.setcursor (15, 0); lcd.print (assorbimentoglobale); lcd.print (" "); ************** routine di countdown ******************** void countdown () momentocorrente = millis (); momentoprec = momentocorrente; digitalwrite (13, HIGH); attiva il led digitalwrite (9, HIGH); attiva il buzzer lcd.setcursor (15, utenzainesame); lcd.print (" "); while ((momentocorrente - momentoprec) < 5500) momentocorrente = millis (); tempo = (momentocorrente - momentoprec) / 1000; lcd.setcursor (15, utenzainesame); lcd.print (5 - tempo); lcd.print (" sec");

8 digitalwrite (13, LOW); disattiva il led digitalwrite (9, LOW); disattiva il buzzer ******** routine di disattivazione dell'utenza meno prioritaria ************* ***************** less priority device deactivation routine *************** void disattivautenza () utenzainesame = 0; prioritapiubassa = 4; for (utenza = 1; utenza < 4; utenza ++) individua l'utenza attiva con priorita' piu' bassa if ((statoutenza [utenza] == 1) && (priorita [utenza] < prioritapiubassa)) utenzainesame = utenza; prioritapiubassa = priorita [utenza]; lcd.setcursor (0, utenzainesame); lcd.print ("disatt. ut. "); lcd.print (utenzainesame); lcd.print (": "); countdown (); avvia il countdown digitalwrite (tabrele [utenzainesame], HIGH); Disattiva il rele' (lo mette in HIGH poiche' il rele' e' normalmente connesso, e mettendolo in HIGH lo disconnette) lcd.setcursor (0, utenzainesame); lcd.print ("ut. "); lcd.print (utenzainesame); lcd.print (" disattivata "); attenzione: inserire tre spazi alla fine statoutenza [utenzainesame] = 0; aggiorna la tabella dello stato utenza assorbimentoglobale = 0; ********** verifica ed eventualmente riattiva un'utenza ***************** ********** checks and if possible, reactivate a device ***************** void verificariattivazione () utenzainesame = 0; prioritapiubassa = 0; for (utenza = 1; utenza < 4; utenza ++) individua l'utenza disattivata con priorita' piu' alta if ((statoutenza [utenza] == 0) && (priorita [utenza] > prioritapiubassa)) utenzainesame = utenza; prioritapiubassa = priorita [utenza]; if (utenzainesame > 0) se e' stata individuata un'utenza disattivata residuosoglia = soglia - assorbimentoglobale; potenza disponibile per la riattivazione potenzanecessaria = potenzaassorbita [utenzainesame] + (potenzaassorbita [utenzainesame] * 0.1); potenza necessaria = potenza assorbita + 10% if (residuosoglia > potenzanecessaria) se la potenza redisua e' maggiore della potenza necesaria lcd.setcursor (0, utenzainesame); lcd.print ("attiva ut. "); lcd.print (utenzainesame); lcd.print (": "); countdown (); avvia il countdown digitalwrite (tabrele [utenzainesame], LOW); disattiva il rele' (lo mette in LOW poiche' l utenza e connessa quando il rele' e' LOW lcd.setcursor (0, utenzainesame); lcd.print ("ut. "); lcd.print (utenzainesame); lcd.print (" riattivata "); attenzione: inserire quattro spazi alla fine statoutenza [utenzainesame] = 1; aggiorna la tabella dello stato utenza void setup()

9 Serial.begin (9600); lcd.begin(20, 4); inizializza il display (20 caratteri per 4 righe) lcd.backlight(); illumina lo sfondo del display lcd.print("buongiorno"); delay(1000); for (indice = 9; indice < 14; indice++) pinmode (indice, OUTPUT); definisce OUTPUT le porte dalla 9 alla 13 digitalwrite (indice, LOW); lcd.clear(); pulisce il display lcd.print ("watt max: "); chiede la soglia di consumo globale numerocifre = 4; ricevivalore (); acquisisce il valore della soglia (in watt) soglia = valore; memorizza la soglia globale lcd.clear (); lcd.print ("max: "); lcd.print (soglia); lcd.setcursor (10, 0); lcd.print ("ora: "); lcd.setcursor (15, 0); lcd.print (assorbimentoglobale); numerocifre = 1; predispone la tastiera ad accettare una sola cifra utenza = 1; inizializza l'indice della tabella utenza ************* loop di acquisizione della priorita' di ogni utenza *************************** ***************** each device priority, acquisition loop*********************************** while (utenza < 4) ciclo di assegnazione della priorita valorevalido = 0; while (valorevalido == 0) ciclo di ricezione e controllo della priorita' lcd.setcursor (0, utenza); lcd.print ("prior. utenza "); lcd.print (utenza); lcd.print (": "); ricevivalore (); riceve la priorita' (da 1 a 3) if ((valore > 0 ) && (valore < 4) && (controllopriorita [valore] == '*')) se la priorita' e' valida controllopriorita [valore] = ' '; considera assegnata la priorita' priorita [utenza] = valore; assegna la priorita' all'utenza utenza++; predipone la ricezione della priorita' per la prossima utenza valorevalido = 1; esce dal ciclo di acquisizione priorita' per l'utenza in esame else se la priorita' non e' valida lcd.setcursor (0, utenza); lcd.print ("valore non valido "); delay (3000); attende tre secondi per consentire la lettura del messaggio lcd.setcursor (0, utenza); lcd.print (" "); attenzione: inserire 20 spazi tra gli apici void loop() momentocorrente = millis (); memorizza il momento corrente rilevaassorbimento (); lancia la routine di rilevamento dell'assorbimento utenze if (momentocorrente - momentoiniziopicco > 2000) se sono passati piu' di due secondi dall'ultimo calcolo del consumo calcolaconsumo (); if (assorbimentoglobale < soglia) if (!(semaforoconsumo == 0)) se e' l'inizio del periodo di consumo sotto la soglia semaforoconsumo = 0; attiva il semaforo di consumo sotto la soglia momentoinizio = momentocorrente; memorizza il momento di inizio periodo di osservazione if (momentocorrente - momentoinizio > 5000) se sono passati piu' di cinque secondi (e quindi se il consumo e' stato per cinque secondi costantemente sotto la soglia) verificariattivazione (); lancia la routine di verifica eventuale riattivazione utenza

10 semaforoconsumo = 3; valore non valido in semaforoconsumo (per ripristinare i controlli) if (assorbimentoglobale > soglia) se l'assorbimento e' superiore alla soglia if (!(semaforoconsumo == 1)) se e' l'inizio del periodo di consumo sopra la soglia semaforoconsumo = 1; attiva il semaforo di consumo sopra la soglia momentoinizio = momentocorrente; memorizza il momento di inizio periodo osservazione if (momentocorrente - momentoinizio > 5000) se sono passati piu' di cinque secondi (e quindi se il consumo e' stato per cinque secondi costantemente sopra la soglia) disattivautenza (); lancia la routine di disattivazione dell'utenza meno prioritaria semaforoconsumo = 3; valore non valido in semaforoconsumo (per ripristinare i controlli)