Digital AC Clamp and meter [prototype]

Digital Energy Counter that can trigger events based on energy consumption or energy bill threshold.

Nov 10, 2022

•

288 views

•

0 respects

energy efficiency

smart appliances

Components and supplies

Resistor 100 ohm

5 mm LED: Yellow

5 mm LED: Red

Tactile Switch, Top Actuated

Arduino UNO

sct013 Split-core Current Transformer

LED, Blue Green

Resistor 10k ohm

Through Hole Resistor, 200 ohm

Project description

Code

Prototype sketch

c_cpp

1static float mV = 4.8828125;
2#define ANALOG_RAW_RESOLUTION 150
3
4enum  convert { none, seconds, minutes, hours, days };
5
6class timer {
7  private:
8    bool                micro;
9    unsigned long int   start;
10
11  public:
12      timer(bool _micro=false);
13
14      void reset(void);
15      float duration(convert  _c=none);
16      String report(convert _c=none, int _digits=0);
17};
18
19timer::timer(bool  _micro) {
20  micro = _micro;
21  reset();
22}
23
24void timer::reset(void)  {
25  if (micro) {
26    start=micros();
27  } else {
28    start=millis();
29  }
30}
31
32float timer::duration(convert _c) {
33  unsigned long int len =  0;
34
35  if (micro) {
36    len = micros() - start;
37  } else {
38    len  = millis() - start;
39  }
40
41  switch(_c) {
42    case none:
43      return(len);
44      break;
45    case seconds:
46      if (micro) {
47        return(len/10000000);
48      } else {
49        return(len/1000);
50      }
51      break;
52    case  minutes:
53      if (micro) {
54        return(len/600000000);
55      } else  {
56        return(len/60000);
57      }
58      break;
59    case hours:
60      if (micro) {
61        return(len/36000000000);
62      } else {
63        return(len/3600000);
64      }
65      break;
66  }
67  return(0);
68}
69
70String timer::report(convert  _c, int _digits) {
71  String unit = "none";
72
73  switch(_c) {
74    case  none:
75      if (micro) {
76        unit = "us";
77      } else {
78        unit  = "ms";
79      }
80      break;
81    case seconds:
82      unit ="sec";
83      break;
84    case minutes:
85      unit = "min";
86      break;
87    case  hours:
88      unit = "h";
89      break;
90  }
91  
92  return(String(duration(_c),_digits)+unit);
93}
94
95class  analogSample {
96  private:
97      int     freq;
98      float   timeout;
99   
100      double  vcc_offset;
101
102      int devicePin;
103      int vccDividerPin;
104  
105      int raw_values[ANALOG_RAW_RESOLUTION];
106      unsigned long int raw_timestamp[ANALOG_RAW_RESOLUTION];
107
108      int raw_max;
109      int raw_min;
110      int values;
111
112      double  avg_vcc_offset;
113      double avg_vcc_offset_points;
114      
115      double  avg_values;
116      double avg_max;
117      double avg_min;
118      
119  public:  
120      analogSample(int _freq, int _divider_pin, int _device_pin);
121
122      void  readDividerValue(void);
123      void resetSample(void);
124      void readSample(void);
125      void processSample(int _log_level);
126
127      double getUEff(void);
128      void report(void);
129};
130
131analogSample::analogSample(int _freq, int  _divider_pin, int _device_pin) {
132 freq =  _freq;
133
134 vcc_offset = 0;
135
136  vccDividerPin = _divider_pin;
137 devicePin = _device_pin;
138 
139 timeout = 1000000/_freq;
140
141  avg_vcc_offset = 99999;
142 avg_vcc_offset_points = 99999; 
143 
144 avg_values  = 99999;
145 avg_max = 99999;
146 avg_min = 99999;
147
148 resetSample();
149}
150
151void  analogSample::resetSample(void) {
152   raw_min = 1024;
153   raw_max = -1024;
154   values = 0;
155
156
157   avg_values = 99999;
158   avg_max = 99999;
159   avg_min  = 99999;
160
161   int counter;
162   for (counter=0;counter<ANALOG_RAW_RESOLUTION;counter++)  {
163    raw_values[counter]=9999;
164    raw_timestamp[counter]=0;
165   }
166}
167
168void  analogSample::readDividerValue(void) {
169  
170  int counter = 1;
171  vcc_offset  = analogRead(vccDividerPin);
172  
173  timer t(true);
174  while(t.duration()<timeout*5)  {
175    vcc_offset += analogRead(vccDividerPin);
176    counter++;
177  }
178  vcc_offset  /= counter;
179  
180  if (avg_vcc_offset == 99999) {
181    avg_vcc_offset = vcc_offset;
182  } else {
183    avg_vcc_offset += vcc_offset;
184    avg_vcc_offset /= 2;
185  }
186
187  if (avg_vcc_offset_points == 99999) {
188    avg_vcc_offset_points  = counter;
189  } else {
190    avg_vcc_offset_points += counter;
191    avg_vcc_offset_points  /= 2;
192  }
193}
194
195void analogSample::readSample(void) {
196  int counter  = 0;
197  timer t(true);
198  while(t.duration()<timeout*1.1 && counter<ANALOG_RAW_RESOLUTION)  {
199    raw_timestamp[counter] = micros();
200    raw_values[counter++] = analogRead(devicePin);  
201  }
202  values = counter;
203  if (avg_values == 99999) {
204    avg_values  = values;
205  } else {
206    avg_values += values;
207    avg_values /= 2;
208  }
209}
210
211void analogSample::processSample(int _log_level) {
212  int counter  = 0;
213
214  raw_max = -1024;
215  raw_min = 1024;
216  
217  if (_log_level >  2) {
218      Serial.println();
219      Serial.println("Analog Sample data table");
220  }
221  for (counter=0;counter<ANALOG_RAW_RESOLUTION;counter++) {
222    if (raw_values[counter]  == 9999) {
223      break;
224    }
225    if (_log_level > 2) {
226      Serial.println(String(counter)+","+String(raw_timestamp[counter])+","+String(raw_values[counter]));
227    }
228    if (raw_values[counter]<raw_min) {
229      raw_min = raw_values[counter];
230    }
231    if (raw_values[counter]>raw_max) {
232      raw_max = raw_values[counter];
233    }
234  }
235
236  if ((avg_max||avg_min) == 99999) {
237    avg_max = raw_max;
238    avg_min = raw_min;
239  } else {
240    avg_max += raw_max;
241    avg_max /=  2;
242    avg_min += raw_min;
243    avg_min /= 2;
244  }
245}
246
247double analogSample::getUEff(void)  {
248  double ueff = mV*((avg_max-avg_min)/2)/sqrt(2);
249  return(ueff);
250}
251
252void  analogSample::report(void) { 
253  Serial.print(" [VCC divider: " + String(mV*avg_vcc_offset)  + "mV (" + String(avg_vcc_offset_points) + "pts)");
254  Serial.print(" "  + String(freq) + "Hz:" + String(avg_values) + "pts] ");
255  Serial.print("("+String(mV*avg_max,2)+"-"+String(mV*avg_min,2)+"mV  c="+String(mV*(avg_max-avg_min)/2));
256  Serial.print("mV) Amp "+String((avg_max-avg_min)*mV,2)  +"mV UEff: " +String(getUEff())+ "mV");
257}
258
259class sct013 {
260  private:
261    int vccDividerPin;
262    double Ieff_calibration;
263
264  public:  
265    int  devicePin;
266    int deviceModel;
267
268    bool calibrated;
269    
270    sct013(int  _vcc_divider_pin, int _device_pin, int _device_model);
271
272    void calibrate(int  _length, int _freq, int _log_level=0);
273    double probe(int _freq, int _log_level=0,  bool _calibrate=false);
274};
275
276sct013::sct013(int _vcc_divider_pin, int _device_pin,  int _device_model) {
277  vccDividerPin = _vcc_divider_pin;
278  devicePin = _device_pin;
279  deviceModel = _device_model;
280
281  calibrated = false;
282  Ieff_calibration  = 0;
283}
284
285void sct013::calibrate(int _length, int _freq, int _log_level)  {
286  timer t;
287  int counter = 0;
288  
289  calibrated = true;
290
291  if  (_log_level > 0) {
292    Serial.println("sct013::calibrate() calibration started,  make sure the line is off");
293  }
294  
295  Ieff_calibration = probe(_freq,_log_level,true);
296  while(t.duration()<_length) {
297    Ieff_calibration += probe(_freq,_log_level,true);
298    Ieff_calibration /= 2;
299    counter++;
300  } 
301  if (_log_level > 0) {
302    Serial.println();
303    if (_log_level > 1) {   
304      Serial.println("Calibration  data : " + String(Ieff_calibration) + "mA " + String(counter) + " pts.");
305    }
306    Serial.println("Calibration ended : Ieff noise " + String(Ieff_calibration)  + "mA");
307    Serial.println();
308  }
309}
310
311double sct013::probe(int  _freq, int _log_level, bool _calibrate) {
312  double Ieff=0;
313  
314  if (!calibrated)  {
315    Serial.println("sct013::probe() WARNING device not calibrated()");
316    return(0);
317  }
318  
319  analogSample as(_freq,vccDividerPin,devicePin);
320  int counter = 0;
321
322  if (_log_level >= 1) {
323    Serial.print("sct013  1V/" + String(deviceModel) + "A (pin A" + String(devicePin)+")");
324  }
325  
326  as.readDividerValue(); 
327  timer t;
328  while(t.duration()<1000) {
329     as.resetSample();
330     as.readSample();
331     as.processSample(_log_level);
332     counter++;
333  }
334
335  if (_log_level >= 2) {
336    as.report();
337  }
338
339  Ieff = as.getUEff()*deviceModel;
340  
341  if (_log_level >= 1) {
342    Serial.print("  [" + String(counter) + " sample/sec]");
343    Serial.println(" I=" + String(Ieff*2)  + "mA "); // 2 phases a period Ieff needs x2
344  }
345  if (_calibrate) {
346    return(Ieff*2);  // 2 phases a period Ieff needs x2
347  }
348
349  if (Ieff  < Ieff_calibration*1.1) { // We take 110% of noise value to exclude noise from measures
350    return(0);
351  }
352  return(Ieff*2); // 2 phases a period Ieff needs x2
353}
354
355class  EnergyMonitor {
356  private:
357    int voltage;
358    int freq;
359
360    double  pCount; // Wh
361    
362    unsigned long int timestamp;
363   
364  public:
365    int cLed;
366    int pLed;
367    int wLed;
368    double wCount;
369    double  wStep;
370    bool useLeds;
371  
372    double pLast; // W
373    double pAvg;  // kWh
374    double pMax; // kWh
375    double pMin; // kWh
376    
377    EnergyMonitor(int  _voltage, int _freq);
378
379    double getPower(sct013 _device, int _log_level=0);
380    double getPowerCount(int _log_level=0);
381    double getBudget(float _kWh_cost=0.1740);
382
383    void setupLeds(int _cLed, int _pLed, int _wLed, int _wStep);    
384    void  updateLeds(sct013 _device);
385};
386
387EnergyMonitor::EnergyMonitor(int _voltage,  int _freq) {
388  voltage=_voltage;
389  freq = _freq;
390  
391  pLed= 9999;
392  cLed = 9999;
393  wLed = 9999;
394  wStep = 9999;
395  wCount = 0;
396  useLeds  = false;
397
398  timestamp = 99999;
399
400  pLast = 99999;
401  pAvg = 99999;
402  pMax = -99999;
403  pMin = 99999;
404  pCount = 0;
405}
406
407double EnergyMonitor::getPower(sct013  _device, int _log_level) {
408
409  if (useLeds) {
410    updateLeds(_device);
411  }
412  
413  double mA = _device.probe(freq,_log_level);
414  double p = voltage*mA/1000;
415  double Wh = p;
416  double kWh = p*24/1000;
417
418  if (timestamp != 99999) {
419    unsigned long int now = millis();
420    double count = (now-timestamp)/1000;
421    count /= 3600;
422    count *= p;
423    pCount += count;
424  }
425  timestamp  = millis();
426
427  pLast = p;
428
429  if (pAvg == 99999) {
430    pAvg = kWh;
431  } else {
432    pAvg += kWh;
433    pAvg /= 2;
434  }
435
436  if (kWh < pMin)  {
437    pMin = kWh;
438  }
439  if (kWh > pMax) {
440    pMax = kWh;
441  }
442
443  if (_log_level > 0 && p > 0) {
444    Serial.print("EnergyMonitor pin A" + String(_device.devicePin)  + ": " + String(p) +"W " + String(pAvg) + "kWh/day");
445    Serial.println("  (" + String(pMin) + "-" + String(pMax)+"kWh/day)");
446  }
447  
448  return(kWh);
449}
450
451double  EnergyMonitor::getPowerCount(int _log_level) {
452  if (_log_level > 0 && pLast  > 0) {
453    Serial.println("EnergyCounter : " + String(pCount/1000,6) + "kWh  (" + String(getBudget(),8) + "€) Last=" + String(pLast) + "W [24h a day : Max="  + String(pMax) + "kWh avg=" + String(pAvg) + "kWh]");
454  }
455  return(pCount/1000);
456}
457
458double  EnergyMonitor::getBudget(float _kWh_cost) {
459  return(double(pCount/1000*_kWh_cost));
460}
461
462void  EnergyMonitor::setupLeds(int _cLed, int _pLed, int _wLed, int _wStep) {
463  cLed  = _cLed;
464  pLed = _pLed;
465  wLed = _wLed;
466  wStep = _wStep;
467  useLeds  = true;
468}
469
470void EnergyMonitor::updateLeds(sct013 _device) {
471  if (_device.calibrated)  {
472    digitalWrite(cLed,HIGH);
473  } else {
474    int i;
475    for (i=0;i<3;i++)  {
476      digitalWrite(cLed,HIGH);
477      delay(150);
478      digitalWrite(cLed,LOW);
479      delay(150);
480    }
481  }
482
483  if (floor(pCount/wStep) > wCount ) {
484    wCount++;
485    digitalWrite(wLed,HIGH);
486    delay(800);
487    digitalWrite(wLed,LOW);
488  }
489  
490  if (pLast > 0) {
491    digitalWrite(pLed, HIGH);
492  } else {
493    digitalWrite(pLed, LOW);
494  }
495  
496}
497
498static int POWER_FREQ=50;           // setup your electrical network frequency
499static int POWER_VOLTAGE=220;       // setup your electrical network voltage for power accounting
500static float  POWER_ACCOUNTING=1;  // setup power accounting in Wh in order wLed to report
501
502static  int LOG_LEVEL0=0;             // setup log level from 0 (no logs) to 3 (all required  data)
503static int LOG_LEVEL1=1;
504static int LOG_LEVEL2=2;
505static int LOG_LEVEL3=3;
506
507static  int SCT013_CALIB_TIMEOUT=10000; // setup timeout for sct013 devices to calibrate
508
509int  calibration_button_pin = 2; // end-user can request calibration anytime
510
511//  declare all your sct013 devices
512sct013 SCT013_01(1,5,10); // (vccDividerPin,  devicePin, deviceModel)
513
514// declare all your energy monitors
515EnergyMonitor  EM(POWER_VOLTAGE,POWER_FREQ);
516
517void setup() {
518  // initialize serial port  to access reports
519  Serial.begin(9600);
520  Serial.println();
521  Serial.println("Power  Accounting and Triggering Engine v0.1 [08/11/2022 - freddy@linuxtribe.fr]");
522  EM.setupLeds(12,13,8,POWER_ACCOUNTING); // leds enable report about state of device  and power on monitored line (calibration, power on, end-user accounting settings)
523}
524
525void  loop() {
526
527// check if end-user request sct013 devices calibration
528  if  (digitalRead(calibration_button_pin) == HIGH) {
529    // calibration measures electromagnetic  noise induced by the circuit (looks to be dependant on AC supply). Bellow noise  level, line is considered as off, ueff=0V
530    SCT013_01.calibrate(SCT013_CALIB_TIMEOUT,POWER_FREQ,LOG_LEVEL2);  // (time for calibration in milli seconds, frequence of monitored signal, log_level)   
531  }
532  
533// ask energy monitor to probe sct013 device to get line state  and proceed to power accounting
534  EM.getPower(SCT013_01,LOG_LEVEL0); // (device  to use for monitoring, log_level)
535  EM.getPowerCount(LOG_LEVEL1);
536}
537

static float mV = 4.8828125;
#define ANALOG_RAW_RESOLUTION 150

enum  convert { none, seconds, minutes, hours, days };

class timer {
  private:
    bool                micro;
    unsigned long int   start;

  public:
      timer(bool _micro=false);

      void reset(void);
      float duration(convert  _c=none);
      String report(convert _c=none, int _digits=0);
};

timer::timer(bool  _micro) {
  micro = _micro;
  reset();
}

void timer::reset(void)  {
  if (micro) {
    start=micros();
  } else {
    start=millis();
  }
}

float timer::duration(convert _c) {
  unsigned long int len =  0;

  if (micro) {
    len = micros() - start;
  } else {
    len  = millis() - start;
  }

  switch(_c) {
    case none:
      return(len);
      break;
    case seconds:
      if (micro) {
        return(len/10000000);
      } else {
        return(len/1000);
      }
      break;
    case  minutes:
      if (micro) {
        return(len/600000000);
      } else  {
        return(len/60000);
      }
      break;
    case hours:
      if (micro) {
        return(len/36000000000);
      } else {
        return(len/3600000);
      }
      break;
  }
  return(0);
}

String timer::report(convert  _c, int _digits) {
  String unit = "none";

  switch(_c) {
    case  none:
      if (micro) {
        unit = "us";
      } else {
        unit  = "ms";
      }
      break;
    case seconds:
      unit ="sec";
      break;
    case minutes:
      unit = "min";
      break;
    case  hours:
      unit = "h";
      break;
  }
  
  return(String(duration(_c),_digits)+unit);
}

class  analogSample {
  private:
      int     freq;
      float   timeout;
   
      double  vcc_offset;

      int devicePin;
      int vccDividerPin;
  
      int raw_values[ANALOG_RAW_RESOLUTION];
      unsigned long int raw_timestamp[ANALOG_RAW_RESOLUTION];

      int raw_max;
      int raw_min;
      int values;

      double  avg_vcc_offset;
      double avg_vcc_offset_points;
      
      double  avg_values;
      double avg_max;
      double avg_min;
      
  public:  
      analogSample(int _freq, int _divider_pin, int _device_pin);

      void  readDividerValue(void);
      void resetSample(void);
      void readSample(void);
      void processSample(int _log_level);

      double getUEff(void);
      void report(void);
};

analogSample::analogSample(int _freq, int  _divider_pin, int _device_pin) {
 freq =  _freq;

 vcc_offset = 0;

  vccDividerPin = _divider_pin;
 devicePin = _device_pin;
 
 timeout = 1000000/_freq;

  avg_vcc_offset = 99999;
 avg_vcc_offset_points = 99999; 
 
 avg_values  = 99999;
 avg_max = 99999;
 avg_min = 99999;

 resetSample();
}

void  analogSample::resetSample(void) {
   raw_min = 1024;
   raw_max = -1024;
   values = 0;


   avg_values = 99999;
   avg_max = 99999;
   avg_min  = 99999;

   int counter;
   for (counter=0;counter<ANALOG_RAW_RESOLUTION;counter++)  {
    raw_values[counter]=9999;
    raw_timestamp[counter]=0;
   }
}

void  analogSample::readDividerValue(void) {
  
  int counter = 1;
  vcc_offset  = analogRead(vccDividerPin);
  
  timer t(true);
  while(t.duration()<timeout*5)  {
    vcc_offset += analogRead(vccDividerPin);
    counter++;
  }
  vcc_offset  /= counter;
  
  if (avg_vcc_offset == 99999) {
    avg_vcc_offset = vcc_offset;
  } else {
    avg_vcc_offset += vcc_offset;
    avg_vcc_offset /= 2;
  }

  if (avg_vcc_offset_points == 99999) {
    avg_vcc_offset_points  = counter;
  } else {
    avg_vcc_offset_points += counter;
    avg_vcc_offset_points  /= 2;
  }
}

void analogSample::readSample(void) {
  int counter  = 0;
  timer t(true);
  while(t.duration()<timeout*1.1 && counter<ANALOG_RAW_RESOLUTION)  {
    raw_timestamp[counter] = micros();
    raw_values[counter++] = analogRead(devicePin);  
  }
  values = counter;
  if (avg_values == 99999) {
    avg_values  = values;
  } else {
    avg_values += values;
    avg_values /= 2;
  }
}

void analogSample::processSample(int _log_level) {
  int counter  = 0;

  raw_max = -1024;
  raw_min = 1024;
  
  if (_log_level >  2) {
      Serial.println();
      Serial.println("Analog Sample data table");
  }
  for (counter=0;counter<ANALOG_RAW_RESOLUTION;counter++) {
    if (raw_values[counter]  == 9999) {
      break;
    }
    if (_log_level > 2) {
      Serial.println(String(counter)+","+String(raw_timestamp[counter])+","+String(raw_values[counter]));
    }
    if (raw_values[counter]<raw_min) {
      raw_min = raw_values[counter];
    }
    if (raw_values[counter]>raw_max) {
      raw_max = raw_values[counter];
    }
  }

  if ((avg_max||avg_min) == 99999) {
    avg_max = raw_max;
    avg_min = raw_min;
  } else {
    avg_max += raw_max;
    avg_max /=  2;
    avg_min += raw_min;
    avg_min /= 2;
  }
}

double analogSample::getUEff(void)  {
  double ueff = mV*((avg_max-avg_min)/2)/sqrt(2);
  return(ueff);
}

void  analogSample::report(void) { 
  Serial.print(" [VCC divider: " + String(mV*avg_vcc_offset)  + "mV (" + String(avg_vcc_offset_points) + "pts)");
  Serial.print(" "  + String(freq) + "Hz:" + String(avg_values) + "pts] ");
  Serial.print("("+String(mV*avg_max,2)+"-"+String(mV*avg_min,2)+"mV  c="+String(mV*(avg_max-avg_min)/2));
  Serial.print("mV) Amp "+String((avg_max-avg_min)*mV,2)  +"mV UEff: " +String(getUEff())+ "mV");
}

class sct013 {
  private:
    int vccDividerPin;
    double Ieff_calibration;

  public:  
    int  devicePin;
    int deviceModel;

    bool calibrated;
    
    sct013(int  _vcc_divider_pin, int _device_pin, int _device_model);

    void calibrate(int  _length, int _freq, int _log_level=0);
    double probe(int _freq, int _log_level=0,  bool _calibrate=false);
};

sct013::sct013(int _vcc_divider_pin, int _device_pin,  int _device_model) {
  vccDividerPin = _vcc_divider_pin;
  devicePin = _device_pin;
  deviceModel = _device_model;

  calibrated = false;
  Ieff_calibration  = 0;
}

void sct013::calibrate(int _length, int _freq, int _log_level)  {
  timer t;
  int counter = 0;
  
  calibrated = true;

  if  (_log_level > 0) {
    Serial.println("sct013::calibrate() calibration started,  make sure the line is off");
  }
  
  Ieff_calibration = probe(_freq,_log_level,true);
  while(t.duration()<_length) {
    Ieff_calibration += probe(_freq,_log_level,true);
    Ieff_calibration /= 2;
    counter++;
  } 
  if (_log_level > 0) {
    Serial.println();
    if (_log_level > 1) {   
      Serial.println("Calibration  data : " + String(Ieff_calibration) + "mA " + String(counter) + " pts.");
    }
    Serial.println("Calibration ended : Ieff noise " + String(Ieff_calibration)  + "mA");
    Serial.println();
  }
}

double sct013::probe(int  _freq, int _log_level, bool _calibrate) {
  double Ieff=0;
  
  if (!calibrated)  {
    Serial.println("sct013::probe() WARNING device not calibrated()");
    return(0);
  }
  
  analogSample as(_freq,vccDividerPin,devicePin);
  int counter = 0;

  if (_log_level >= 1) {
    Serial.print("sct013  1V/" + String(deviceModel) + "A (pin A" + String(devicePin)+")");
  }
  
  as.readDividerValue(); 
  timer t;
  while(t.duration()<1000) {
     as.resetSample();
     as.readSample();
     as.processSample(_log_level);
     counter++;
  }

  if (_log_level >= 2) {
    as.report();
  }

  Ieff = as.getUEff()*deviceModel;
  
  if (_log_level >= 1) {
    Serial.print("  [" + String(counter) + " sample/sec]");
    Serial.println(" I=" + String(Ieff*2)  + "mA "); // 2 phases a period Ieff needs x2
  }
  if (_calibrate) {
    return(Ieff*2);  // 2 phases a period Ieff needs x2
  }

  if (Ieff  < Ieff_calibration*1.1) { // We take 110% of noise value to exclude noise from measures
    return(0);
  }
  return(Ieff*2); // 2 phases a period Ieff needs x2
}

class  EnergyMonitor {
  private:
    int voltage;
    int freq;

    double  pCount; // Wh
    
    unsigned long int timestamp;
   
  public:
    int cLed;
    int pLed;
    int wLed;
    double wCount;
    double  wStep;
    bool useLeds;
  
    double pLast; // W
    double pAvg;  // kWh
    double pMax; // kWh
    double pMin; // kWh
    
    EnergyMonitor(int  _voltage, int _freq);

    double getPower(sct013 _device, int _log_level=0);
    double getPowerCount(int _log_level=0);
    double getBudget(float _kWh_cost=0.1740);

    void setupLeds(int _cLed, int _pLed, int _wLed, int _wStep);    
    void  updateLeds(sct013 _device);
};

EnergyMonitor::EnergyMonitor(int _voltage,  int _freq) {
  voltage=_voltage;
  freq = _freq;
  
  pLed= 9999;
  cLed = 9999;
  wLed = 9999;
  wStep = 9999;
  wCount = 0;
  useLeds  = false;

  timestamp = 99999;

  pLast = 99999;
  pAvg = 99999;
  pMax = -99999;
  pMin = 99999;
  pCount = 0;
}

double EnergyMonitor::getPower(sct013  _device, int _log_level) {

  if (useLeds) {
    updateLeds(_device);
  }
  
  double mA = _device.probe(freq,_log_level);
  double p = voltage*mA/1000;
  double Wh = p;
  double kWh = p*24/1000;

  if (timestamp != 99999) {
    unsigned long int now = millis();
    double count = (now-timestamp)/1000;
    count /= 3600;
    count *= p;
    pCount += count;
  }
  timestamp  = millis();

  pLast = p;

  if (pAvg == 99999) {
    pAvg = kWh;
  } else {
    pAvg += kWh;
    pAvg /= 2;
  }

  if (kWh < pMin)  {
    pMin = kWh;
  }
  if (kWh > pMax) {
    pMax = kWh;
  }

  if (_log_level > 0 && p > 0) {
    Serial.print("EnergyMonitor pin A" + String(_device.devicePin)  + ": " + String(p) +"W " + String(pAvg) + "kWh/day");
    Serial.println("  (" + String(pMin) + "-" + String(pMax)+"kWh/day)");
  }
  
  return(kWh);
}

double  EnergyMonitor::getPowerCount(int _log_level) {
  if (_log_level > 0 && pLast  > 0) {
    Serial.println("EnergyCounter : " + String(pCount/1000,6) + "kWh  (" + String(getBudget(),8) + "€) Last=" + String(pLast) + "W [24h a day : Max="  + String(pMax) + "kWh avg=" + String(pAvg) + "kWh]");
  }
  return(pCount/1000);
}

double  EnergyMonitor::getBudget(float _kWh_cost) {
  return(double(pCount/1000*_kWh_cost));
}

void  EnergyMonitor::setupLeds(int _cLed, int _pLed, int _wLed, int _wStep) {
  cLed  = _cLed;
  pLed = _pLed;
  wLed = _wLed;
  wStep = _wStep;
  useLeds  = true;
}

void EnergyMonitor::updateLeds(sct013 _device) {
  if (_device.calibrated)  {
    digitalWrite(cLed,HIGH);
  } else {
    int i;
    for (i=0;i<3;i++)  {
      digitalWrite(cLed,HIGH);
      delay(150);
      digitalWrite(cLed,LOW);
      delay(150);
    }
  }

  if (floor(pCount/wStep) > wCount ) {
    wCount++;
    digitalWrite(wLed,HIGH);
    delay(800);
    digitalWrite(wLed,LOW);
  }
  
  if (pLast > 0) {
    digitalWrite(pLed, HIGH);
  } else {
    digitalWrite(pLed, LOW);
  }
  
}

static int POWER_FREQ=50;           // setup your electrical network frequency
static int POWER_VOLTAGE=220;       // setup your electrical network voltage for power accounting
static float  POWER_ACCOUNTING=1;  // setup power accounting in Wh in order wLed to report

static  int LOG_LEVEL0=0;             // setup log level from 0 (no logs) to 3 (all required  data)
static int LOG_LEVEL1=1;
static int LOG_LEVEL2=2;
static int LOG_LEVEL3=3;

static  int SCT013_CALIB_TIMEOUT=10000; // setup timeout for sct013 devices to calibrate

int  calibration_button_pin = 2; // end-user can request calibration anytime

//  declare all your sct013 devices
sct013 SCT013_01(1,5,10); // (vccDividerPin,  devicePin, deviceModel)

// declare all your energy monitors
EnergyMonitor  EM(POWER_VOLTAGE,POWER_FREQ);

void setup() {
  // initialize serial port  to access reports
  Serial.begin(9600);
  Serial.println();
  Serial.println("Power  Accounting and Triggering Engine v0.1 [08/11/2022 - freddy@linuxtribe.fr]");
  EM.setupLeds(12,13,8,POWER_ACCOUNTING); // leds enable report about state of device  and power on monitored line (calibration, power on, end-user accounting settings)
}

void  loop() {

// check if end-user request sct013 devices calibration
  if  (digitalRead(calibration_button_pin) == HIGH) {
    // calibration measures electromagnetic  noise induced by the circuit (looks to be dependant on AC supply). Bellow noise  level, line is considered as off, ueff=0V
    SCT013_01.calibrate(SCT013_CALIB_TIMEOUT,POWER_FREQ,LOG_LEVEL2);  // (time for calibration in milli seconds, frequence of monitored signal, log_level)   
  }
  
// ask energy monitor to probe sct013 device to get line state  and proceed to power accounting
  EM.getPower(SCT013_01,LOG_LEVEL0); // (device  to use for monitoring, log_level)
  EM.getPowerCount(LOG_LEVEL1);
}

Downloadable files

Main circuit

Comments

Only logged in users can leave comments

ffrouin

0 Followers

•

0 Projects

Intro

Components and supplies

Project description

Code

Downloadable files