Aproveitamento da energia sobrante de um grupo gerador

Este grupo gerador recebe uma quantiudade de energia constante por unidade de tempo (fluxo de água).
A Energia que não é consumida devera ser queimada para manter a rotação do gerador constante, nos 50/60 Hz da rede elétrica.
Esta energia sobrante é desviada instantaneamente, com controles baseados em semicondutores, para resistências onde é dissipada sem prestar utilidade a comunidade.
Podemos aproveitar esta energia em casa desviando-a para um boiler e assim ter água quente sem perjudicar os demais consumidores.
Considerando a caída de tensão até o ponto de consumo do boiler que deve ser medido nas horas de mínimo consumo (1 AM 210V) teremos assim o
ponto inicial de controle. Caindo mais 10 V podemos supor que devemos desconectar o boiler. Quando a voltagem da línea é maior a 210V o Boiler e conectado na rede
Os limites em este caso de 210 e 200V podem ser variados de acordo a experiencia e para evitar prejudicar a comunidade.

O banheiro fica muito frio de manha, então acresentamosa um calefator que deverá esquentar entre as 7 atê as 9 hs sempre que a temperatura esteja abaixo de 20 GrC.
Quando o calefator está ativo o boiler devera estar desconectado.
Em qualquer momento poderemos ligar por 30 minutos o calefator mais ele só funcionará com a temperatura abaixo de 20 GrC e tendo suficiente energia disponivel

Para alimentar o Boiler vamos utilizar um triac alimentado por un optoisolador controlado por um
microcontrollador ATmega328P.
Utilizamos um pequeno transformador de AC para 2x12V para alimentar o microcontrollador, isolar a fonte e medir a voltagem da linea.

Microcontrollador: ATmega328P

Programação do ATmega328P

float VoltMin = 210.0;
float DeltaVolt = 20;
float GainPico = 0.3096;
int horaIni = 7;
int horaFim = 9;
int tempMax = 9 0;
unsigned long deltaBoiDel;
unsigned long deltaCalDel;
unsigned long deltaCalLig;
int voltSensor = 3;
int gate1 = 6; // boiler
int gate2 = 2; // calefaÃ§Ã£o
unsigned long deltaBoiler;
int V0 = 0;
unsigned long T0;
unsigned long T;
unsigned long Tini;
unsigned long TiniA;
unsigned long Tp;
unsigned long Xt = 4294967295; // overeflow do unsigned long (2^32-1). bin 1111 1111 1111 1111 1111 1111 1111 1111
unsigned long deltaT = 0;
int Vmedio = 0.0;
int Vmax = 0;
int VmaxUltimo = 0;
int VmaxD;
float area = 0.0;
float Area = 0.0;
int K = 0;
float Vefetivo = 0.0;
float Ciclo = 0.0;
int Hz;
int I =0;
int count=0;
int KK = 0;
int TKK = 0;
int controlGate1 = 0;
int controlGate2 = 0;
unsigned long BoilerDelay = 0;
unsigned long CalefDelay = 0;
unsigned long PulsadoDelay =0;
unsigned long deltaCalef;
unsigned long Th;
int hora;
int minuto;
int segundo;
int Pulsado;
int pulsado;
int apaga;
int pulsadoSensor = 1;
int temp;
int tempSensor = 5;

// DS1302 RTC
// ----------

// Set your own pins with these defines !
#define DS1302_SCLK_PIN   4    // Arduino pin for the Serial Clock
#define DS1302_IO_PIN     7    // Arduino pin for the Data I/O
#define DS1302_CE_PIN     8    // Arduino pin for the Chip Enable

#define bcd2bin(h,l)    (((h)*10) + (l))
#define bin2bcd_h(x)   ((x)/10)
#define bin2bcd_l(x)    ((x)%10)

#define DS1302_SECONDS           0x80
#define DS1302_MINUTES           0x82
#define DS1302_HOURS             0x84
#define DS1302_DATE              0x86
#define DS1302_MONTH             0x88
#define DS1302_DAY               0x8A
#define DS1302_YEAR              0x8C
#define DS1302_ENABLE            0x8E
#define DS1302_TRICKLE           0x90
#define DS1302_CLOCK_BURST       0xBE
#define DS1302_CLOCK_BURST_WRITE 0xBE
#define DS1302_CLOCK_BURST_READ  0xBF
#define DS1302_RAMSTART          0xC0
#define DS1302_RAMEND            0xFC
#define DS1302_RAM_BURST         0xFE
#define DS1302_RAM_BURST_WRITE   0xFE
#define DS1302_RAM_BURST_READ    0xFF

#define DS1302_D0 0
#define DS1302_D1 1
#define DS1302_D2 2
#define DS1302_D3 3
#define DS1302_D4 4
#define DS1302_D5 5
#define DS1302_D6 6
#define DS1302_D7 7

#define DS1302_READBIT DS1302_D0 // READBIT=1: read instruction

#define DS1302_RC DS1302_D6

#define DS1302_CH DS1302_D7   // 1 = Clock Halt, 0 = start

#define DS1302_AM_PM DS1302_D5 // 0 = AM, 1 = PM
#define DS1302_12_24 DS1302 D7 // 0 = 24 hour, 1 = 12 hour

#define DS1302_WP DS1302_D7   // 1 = Write Protect, 0 = enabled

#define DS1302_ROUT0 DS1302_D0
#define DS1302_ROUT1 DS1302_D1
#define DS1302_DS0   DS1302_D2
#define DS1302_DS1   DS1302_D2
#define DS1302_TCS0  DS1302_D4
#define DS1302_TCS1  DS1302_D5
#define DS1302_TCS2  DS1302_D6
#define DS1302_TCS3  DS1302_D7

typedef struct ds1302_struct
{
  uint8_t Seconds:4;      // low decimal digit 0-9
  uint8_t Seconds10:3;    // high decimal digit 0-5
  uint8_t CH:1;           // CH = Clock Halt
  uint8_t Minutes:4;
  uint8_t Minutes10:3;
  uint8_t reserved1:1;
  union
  {
    struct
    {
      uint8_t Hour:4;
      uint8_t Hour10:2;
      uint8_t reserved2:1;
      uint8_t hour_12_24:1; // 0 for 24 hour format
    } h24;
    struct
    {
      uint8_t Hour:4;
      uint8_t Hour10:1;
      uint8_t AM_PM:1;      // 0 for AM, 1 for PM
      uint8_t reserved2:1;
      uint8_t hour_12_24:1; // 1 for 12 hour format
    } h12;
  };
  uint8_t Date:4;           // Day of month, 1 = first day
  uint8_t Date10:2;
  uint8_t reserved3:2;
  uint8_t Month:4;          // Month, 1 = January
  uint8_t Month10:1;
  uint8_t reserved4:3;
  uint8_t Day:3;            // Day of week, 1 = first day (any day)
  uint8_t reserved5:5;
  uint8_t Year:4;           // Year, 0 = year 2000
  uint8_t Year10:4;
  uint8_t reserved6:7;
  uint8_t WP:1;             // WP = Write Protect
};

void DS1302_clock_burst_read( uint8_t *p)
{
  int i;

_DS1302_start();

_DS1302_togglewrite( DS1302_CLOCK_BURST_READ, true);

for( i=0; i<8; i++)
  {
    *p++ = _DS1302_toggleread();
  }
  _DS1302_stop();
}

void DS1302_clock_burst_write( uint8_t *p)
{
  int i;

_DS1302_start();

_DS1302_togglewrite( DS1302_CLOCK_BURST_WRITE, false);

for( i=0; i<8; i++)
  {
    // the I/O-line is not released
    _DS1302_togglewrite( *p++, false);  
  }
  _DS1302_stop();
}

uint8_t DS1302_read(int address)
{
  uint8_t data;

// set lowest bit (read bit) in address
  bitSet( address, DS1302_READBIT);

_DS1302_start();
  // the I/O-line is released for the data
  _DS1302_togglewrite( address, true);  
  data = _DS1302_toggleread();
  _DS1302_stop();

return (data);
}

void DS1302_write( int address, uint8_t data)
{
  // clear lowest bit (read bit) in address
  bitClear( address, DS1302_READBIT);

_DS1302_start();
  // don't release the I/O-line
  _DS1302_togglewrite( address, false); 
  // don't release the I/O-line
  _DS1302_togglewrite( data, false); 
  _DS1302_stop();  
}

void _DS1302_start( void)
{
  digitalWrite( DS1302_CE_PIN, LOW); // default, not enabled
  pinMode( DS1302_CE_PIN, OUTPUT);

digitalWrite( DS1302_SCLK_PIN, LOW); // default, clock low
  pinMode( DS1302_SCLK_PIN, OUTPUT);

pinMode( DS1302_IO_PIN, OUTPUT);

digitalWrite( DS1302_CE_PIN, HIGH); // start the session
  delayMicroseconds( 4);           // tCC = 4us
}

void _DS1302_stop(void)
{
  // Set CE low
  digitalWrite( DS1302_CE_PIN, LOW);

delayMicroseconds( 4);           // tCWH = 4us
}

uint8_t _DS1302_toggleread( void)
{
  uint8_t i, data;

data = 0;
  for( i = 0; i <= 7; i++)
  {
    digitalWrite( DS1302_SCLK_PIN, HIGH);
    delayMicroseconds( 1);

digitalWrite( DS1302_SCLK_PIN, LOW);
    delayMicroseconds( 1);        // tCL=1000ns, tCDD=800ns

bitWrite( data, i, digitalRead( DS1302_IO_PIN)); 
  }
  return( data);
}

void _DS1302_togglewrite( uint8_t data, uint8_t release)
{
  int i;

for( i = 0; i <= 7; i++)
  { 
    digitalWrite( DS1302_IO_PIN, bitRead(data, i));  
    delayMicroseconds( 1);     // tDC = 200ns
    digitalWrite( DS1302_SCLK_PIN, HIGH);     
    delayMicroseconds( 1);     // tCH = 1000ns, tCDH = 800ns

if( release && i == 7)
    {
      pinMode( DS1302_IO_PIN, INPUT);
    }
    else
    {
      digitalWrite( DS1302_SCLK_PIN, LOW);
      delayMicroseconds( 1);       // tCL=1000ns, tCDD=800ns
    }
  }
}

void setup()
{   
  ds1302_struct rtc;

Serial.begin(9600);
  DS1302_write (DS1302_ENABLE, 0);

DS1302_write (DS1302_TRICKLE, 0x00);

// Remove the next define, 
// after the right date and time are set.
//#define SET_DATE_TIME_JUST_ONCE
#ifdef SET_DATE_TIME_JUST_ONCE

// Fill these variables with the date and time.
  int seconds, minutes, hours, dayofweek, dayofmonth, month, year;

// Set your own time and date in these variables.
  seconds    = 0;
  minutes    = 20;
  hours      = 10;
  dayofweek  = 2;  // Day of week, any day can be first, counts 1...7
  dayofmonth = 15; // Day of month, 1...31
  month      = 7;  // month 1...12
  year       = 2013;

memset ((char *) &rtc, 0, sizeof(rtc));

rtc.Seconds    = bin2bcd_l( seconds);
  rtc.Seconds10  = bin2bcd_h( seconds);
  rtc.CH         = 0;      // 1 for Clock Halt, 0 to run;
  rtc.Minutes    = bin2bcd_l( minutes);
  rtc.Minutes10  = bin2bcd_h( minutes);

rtc.h24.Hour   = bin2bcd_l( hours);
  rtc.h24.Hour10 = bin2bcd_h( hours);
  rtc.h24.hour_12_24 = 0; // 0 for 24 hour format
  rtc.Date       = bin2bcd_l( dayofmonth);
  rtc.Date10     = bin2bcd_h( dayofmonth);
  rtc.Month      = bin2bcd_l( month);
  rtc.Month10    = bin2bcd_h( month);
  rtc.Day        = dayofweek;
  rtc.Year       = bin2bcd_l( year - 2000);
  rtc.Year10     = bin2bcd_h( year - 2000);
  rtc.WP = 0;

DS1302_clock_burst_write( (uint8_t *) &rtc);
#endif
  pinMode(gate1,OUTPUT);
  pinMode(gate2,OUTPUT);
  pinMode(tempSensor,INPUT);
  pinMode(pulsadoSensor,INPUT);
  digitalWrite(gate1,LOW);
  digitalWrite(gate2,LOW);
  deltaBoiDel = 40; // 40 seg deley para conectar 
  deltaCalDel = 20; // 20 deley para ligar calefator
  deltaCalLig = 1800; // 30:00 Calef ligado seg
    DS1302_clock_burst_read( (uint8_t *) &rtc);
    hora = bcd2bin( rtc.h24.Hour10, rtc.h24.Hour);
    minuto = bcd2bin( rtc.Minutes10, rtc.Minutes);
    segundo = bcd2bin( rtc.Seconds10, rtc.Seconds);
  BoilerDelay = hora*3600+minuto*60+segundo + deltaBoiDel + 1;
  CalefDelay = hora*3600+minuto*60+segundo + deltaCalDel + 1;
  Pulsado = 0;

}

void loop()
{
   int sensorValue = analogRead(voltSensor);
   T = micros();
  Tp = millis();
  if ((sensorValue >0 )  and ( V0 == 0)){ // inicio da sinusoide
    TiniA = Tini;
    Tini = T;
      }
  if ((sensorValue >0 )  or ( V0 > 0)){
    if ( T < T0 ) {
      deltaT =(Xt - T0)+T;
      } else  deltaT = T - T0;
    Vmedio = V0 + sensorValue; 
    if (sensorValue > Vmax) Vmax = sensorValue;
    area =  deltaT*Vmedio;
    V0 = sensorValue;
    T0 = T;
    Area += area;
    K = K + 1;
    } else  T0 = micros();
 
  if (( sensorValue == 0) and (Area > 0.0)) {
    if (TiniA > Tini) Ciclo = 1000000/(Xt-TiniA+Tini); else  Ciclo = 1000000.0/(Tini-TiniA);
     if ((VmaxUltimo > 70) and (Ciclo > 30) and (Ciclo < 70)) {
       if (Vmax > VmaxUltimo) Vmax = VmaxUltimo;
       }
    Vefetivo = Vmax*GainPico;
    TKK += K;
    V0 = 0;
    T0 = micros();
    Area = 0.0;
    VmaxUltimo = Vmax;
    VmaxD = Vmax;
    Vmax = 0;
    I = I + 1;
    K = 0;
    delay(5); // espera atÃ© terminar o meio ciclo
  }
  if ( I > 3) {
    count++;
    KK = TKK / 4.0;
    VmaxUltimo=0;
    I = 0;
    TKK =0;
    temp = analogRead(tempSensor);
   temp = 0.5+(temp * 0.488);
    ds1302_struct rtc;
    DS1302_clock_burst_read( (uint8_t *) &rtc);
    hora = bcd2bin( rtc.h24.Hour10, rtc.h24.Hour);
    minuto = bcd2bin( rtc.Minutes10, rtc.Minutes);
    segundo = bcd2bin( rtc.Seconds10, rtc.Seconds);
    Th = hora*3600+minuto*60+segundo;
    pulsado = 0;
    apaga = 0;
    if (Pulsado == 0) {pulsado = analogRead(pulsadoSensor);
    } else apaga = analogRead(pulsadoSensor);
    if ((Pulsado >0) and (apaga > 100)) {
        controlGate2 = 0;
        digitalWrite(gate2,LOW);
        delay(2000);
        Pulsado = 0;
    }
    if (pulsado > 100) {
        PulsadoDelay = Th;// millis();
        Pulsado = 1;
        delay(2000);
     }

if (((hora >= horaIni) and (hora < horaFim) and (temp < tempMax) and (controlGate1 > 0)) or ((Pulsado > 0) and (temp < tempMax) and (controlGate1 > 0))){ //deslig boiler
    controlGate1 = 0;
    digitalWrite(gate1,LOW);
   } else {
     //************** ligar de manha ***************
     if ((hora >= horaIni) and (hora < horaFim)){
       if (temp < tempMax) {
         if (controlGate2 == 0) {
           if ( Th < CalefDelay ) {
              deltaCalef =(24*36 - CalefDelay)+Th;
           } else deltaCalef = Th - CalefDelay;
           if ((Vefetivo > VoltMin) and (deltaCalef > deltaCalDel)) { 
             controlGate2 = 1023;
             digitalWrite(gate2,HIGH);
           } 
         }
       } else {
       if (controlGate2 > 0) {
          controlGate2 = 0;
          digitalWrite(gate2,LOW);
       }
       }
     }
     // ligar pulsando
     if (Pulsado > 0) {
       if (controlGate2 == 0) {
         if ( Th < CalefDelay ) {
              deltaCalef =(24*36 - CalefDelay)+Th;
         } else deltaCalef = Th - CalefDelay;
         if ((Vefetivo > VoltMin) and (deltaCalef > deltaCalDel)) { 
             controlGate2 = 1023;
             digitalWrite(gate2,HIGH);
         }
       } else {
          if ( Th < PulsadoDelay ) {
              deltaCalef =(24*3600 - PulsadoDelay)+Th;
          } else deltaCalef = Th - PulsadoDelay;
          if ((temp > tempMax) or (deltaCalef > deltaCalLig)) { 
             controlGate2 = 0;
             digitalWrite(gate2,LOW);
             Pulsado = 0;
          }
       }
     }
     // ligar boiler
     if ( Th < BoilerDelay ) {
              deltaBoiler =(24*3600 - BoilerDelay)+Th;
     } else deltaBoiler = Th - BoilerDelay;
     if ((controlGate1 == 0) and (controlGate2 == 0) and (Vefetivo > VoltMin) and (deltaBoiler > deltaBoiDel) and (Pulsado == 0)) {
       controlGate1 = 1023;
       digitalWrite(gate1,HIGH);
     }
     if (Vefetivo < (VoltMin - DeltaVolt)) {
    Serial.print("Voltagem abaixo do minimo, Volt:");
    Serial.print(Vefetivo);
    Serial.print(" Hz:");
    Serial.print(Ciclo);
    Serial.println(" ");

controlGate1 = 0;
         controlGate2 = 0;
//         Pulsado=0;
         BoilerDelay = Th;
         CalefDelay = Th;
         digitalWrite(gate1,LOW);
         digitalWrite(gate2,LOW);
     } 
  }
  if (count > 30) {
    count = 0;
    Serial.print("K:");
    Serial.print(KK);
    Serial.print(" Hz:");
    Hz = Ciclo+0.5;
    Serial.print(Hz);
    Serial.print(" V:");
    int Ve = Vefetivo+0.5;
    Serial.print(Ve);
    Serial.print(" G1:");
    Serial.print(controlGate1);
    Serial.print(" G2:");
    Serial.print(controlGate2);
    Serial.print(" hora:");
    Serial.print(hora);
    Serial.print(":");
    Serial.print(minuto);
    Serial.print(":");
    Serial.print(segundo);
    Serial.print(" Pulsado:");
    Serial.print(Pulsado);
    Serial.print(" Vmax:");
    Serial.print(VmaxD);
    Serial.print(" Temp:");
    Serial.print(temp);
    Serial.println(" ");
  }
 }
}

Componentes

1 Atmega328P microcontrolador
1 Cristal 12 Mhz
2 Capacitores de 22pF
1 DS1302 clock
1 LM35 sensor de temperatura
1 trafo fonte e censor voltagem (110/220 input, output 2x12)
2 BTA12-600 Triac´s (max 12 A)
1 LM7805 reg. de voltagem
2 MOC3021 optoisoladores.
1 1N4007 diodo retificador (D1)
1 zener 5.1 V (Z1)
2 1N4148 diodos (D3 e D4)
2 Capacitores de 220mF (C1 e C2)
1 Capacitor de 2.2mf (C3)
2 Resistores 1 kΩ (R1 e R8)
1 Resistor 2.2 kΩ (R2)
2 Resistores 820 Ω (R3 e R4)
2 Resistores 330 Ω (R5)
2 Resistores 220 Ω (R6)
1 Resistor 470 Ω (R7)