Schaltplan Kennlinien-Laderegler:

Funktionsaufbau:

Der vom Generator erzeugte Wechselstrom (3 Phasen) wird zunächst über den Brücken-Gleichrichter in Gleichstrom umgewandelt, der alle weiteren Komponenten versorgt und schließlich zur Batterieladung verwendet wird. 

Das zentrale Element der Schaltung ist der große Step-Down-Converter in der Mitte links. Er transformiert die variable Generatorspannung auf die Ladeschlussspannung der Batterie und lässt somit den Generator möglichst effizient mit hoher Spannung und geringer Stromstärke laufen.
Am Spannungswandler befinden sich zwei Potentiometer. Mit dem einen lässt sich eine feste Ausgangsspannung einstellen (Ladeschlussspannung), mit dem anderen ein konstanter Widerstand, der den Stromfluss und damit die Belastung des Generators bzw. die Ladeleistung bestimmt. Da der Generator jedoch sehr unterschiedliche  Leistungen liefert, muss die Belastung permanent angepasst werden, weshalb das ursprüngliche Potentiometer durch ein ansteuerbares, digitales Potentiometer ersetzt wird. Über den Microcontroller (Arduino Uno) lassen sich somit beliebige Widerstandswerte einstellen, durch die alle Formen der Leistungssteuerung ermöglicht werden. 

Der Microcontroller selbst wird direkt vom Generator mit Strom versorgt. Da seine Versorgungsspannung nur bei 5V liegt, wird ein kleiner Step-Down-Wandler dazwischengeschaltet, der die schwankende Generatorspannung herunter transformiert und stabil hält. Der Regler wird also nur dann gestartet, wenn auch tatsächlich Strom vom Windrad produziert wird. 
 

Nachdem die Generatorspannung den Messbereich des Microcontrollers übersteigt (0-5V) , kommt ein Spannungsteiler zum Einsatz, der die aktuelle Generatorspannung verkleinert und über den analogen Eingang des Arduino A0 messbar wird. 

Sobald der Generator eine Spannung über 5V erzeugt, schaltet sich der Microcontroller ein, setzt den digitalen Widerstand auf den Startwert und ist sofort startklar. Sobald die Generatorspannung über der Batteriespannung liegt, wird das Relais 2 geschlossen und die Ladung beginnt. Sobald die Spannung unter die Akkuspannung sinkt, wird der Stromkreis zur Batterie wieder getrennt. Bei weiterer Spannungssenkung unter die Arduino Betriebsspannung schaltet der Regler komplett aus. Eine Entladung der Batterie ist somit ausgeschlossen, was bei vielen Ladereglern nicht der Fall ist. Bei (tage-) langen Windpausen können dadurch relativ große Stand-By-Verluste vermieden werden. 



Kennlinienregelung:

Im Falle der Kennlinienregelung wird die Generatorbelastung dadurch bestimmt, dass verschiedenen Generatorspannungen konkrete Potentiometer-Werte zugeordnet werden. Je größer der Wert, desto größer ist der Stromfluss, die Ladeleistung und die Bremswirkung auf den Rotor. Diese Zuordnungen müssen vorab experimentell bestimmt werden und können je nach Windlage auch jederzeit nachjustiert werden. 

Arduino Programmcode:

Das gesamte Programm ist im Vergleich zur MPPT-Regelung sehr kurz und einfach. Neben den Variablen-Deklarationen und Funktionen (siehe Programmcode unten) findet der eigentliche Algorithmus innerhalb der sich permanent wiederholenden Loop-Schleife statt. 

Sobald die eingelesene Generatorspannung die festgelegte Ladespannung überschreitet, wird das Relais zur Batterie freigeschaltet. Nun erfolgt eine einfache Zuordnung der aktuellen Generatorspannung mit den entsprechenden Potentiometer-Ziel-Werten. 




Unterscheiden sich die Zielwerte von den Ist-Werten, werden diese innerhalb einer kleinen Do-While-Schleife schrittweise solange erhöht oder vermindert, bis beide übereinstimmen. 

 

Die Abfrage der Generatorspannung am Ende der Loop_Schleife entscheidet schließlich darüber, ob das Relais zur Batterie bei Unterschreiten der Ladespannung wieder getrennt, und ein eventueller Reset des Potentiometers durchgeführt wird. 
Um im Grenzbereich ein Relais-Rasseln zu vermeiden, werden zwei leicht unterschiedliche Grenzspannungen (start-voltage, stop_voltage) verwendet.

 Sobald die Generatorspannung die Bremsspannung (break_voltage) übersteigt, wird über das zweite Potentiometer der Bremswiderstand zugeschaltet.

Hier ist der komplette Programm-Code aufgelistet und kann ganz einfach mittels Copy/Paste in den Arduino Compiler eingefügt werden. Der Code ist ein erster Prototyp und wurde noch nicht unter Realbedingungen getestet.


#define ANALOG_IN_PIN_A1 A1

#define ANALOG_IN_PIN_A0 A0


#define CS 12

#define UD 10

#define INC 11

#define PIN8 8

#define PIN9 9


int pot_position = 0;

int pot_target_position = 0;

int max_pot_pos = 40;

int min_pot_pos = 1;

bool pot_reset = 0;



float R1 = 11;

float R2 = 1;


float ref_voltage = 5.0;

int adc_value = 0;

double voltage = 0;

float adc_voltage = 0;


float stop_voltage = 13;

float start_voltage = 14;

float break_voltage = 40;


void setup() 

{

  // set pin mode

  pinMode(INC, OUTPUT);

  pinMode(CS, OUTPUT);

  pinMode(UD, OUTPUT);

  pinMode(PIN8, OUTPUT);

  pinMode(PIN9, OUTPUT);


  // open serial monitor

  Serial.begin(9600);

  Pot_Reset();

}


void Pot_Reset() 

{

  Serial.print("Resetting potentiometer please wait...");

  for (int i = 0; i <= 102; i++)

    Down();

  pot_position = 0;


  for (int i = 1; i <= min_pot_pos; i++)

    Up();

  pot_reset = 1;

  Serial.println("Ok!");

}


void Show_Values() 

{

  Serial.print("voltage:  ");

  Serial.println(voltage);

  Serial.println("");

  Serial.print("pot_position:  ");

  Serial.println(pot_position);

  Serial.println("");

  Serial.println("");

 // delay(200);

}


void Up() 

{

  pot_position++;

  digitalWrite(CS, LOW);

  digitalWrite(UD, HIGH);

  delay(5);

  digitalWrite(INC, HIGH);

  digitalWrite(INC, LOW);

  delay(5);

  pot_reset = 0;

}


void Down() 

{

  pot_position--;

  digitalWrite(CS, LOW);

  digitalWrite(UD, LOW);

  delay(5);

  digitalWrite(INC, HIGH);

  digitalWrite(INC, LOW);

  delay(5);   

  pot_reset = 0;

}


void Get_Voltage()

{

  adc_value = analogRead(ANALOG_IN_PIN_A1);

  adc_voltage = (adc_value * ref_voltage) / 1024.0;

  voltage = adc_voltage / (R2 / (R1 + R2));

  voltage = voltage - 0.2;

}



void loop() 

{ Get_Voltage();


  if (voltage > start_voltage)

  { digitalWrite(PIN9, LOW);

    if (voltage > 14) pot_target_position = 1;

    if (voltage > 15) pot_target_position = 2;

    if (voltage > 16) pot_target_position = 2;

    if (voltage > 17) pot_target_position = 2;

    if (voltage > 18) pot_target_position = 3; 

    if (voltage > 19) pot_target_position = 3; 

    if (voltage > 20) pot_target_position = 4;

    if (voltage > 21) pot_target_position = 5;

    if (voltage > 22) pot_target_position = 6;

    if (voltage > 23) pot_target_position = 7;

    if (voltage > 24) pot_target_position = 8;    

    if (voltage > 25) pot_target_position = 9;

    if (voltage > 26) pot_target_position = 11;

    if (voltage > 27) pot_target_position = 12;

    if (voltage > 28) pot_target_position = 14;

    if (voltage > 29) pot_target_position = 16;

    if (voltage > 30) pot_target_position = 18; 

    if (voltage > 31) pot_target_position = 20; 

    if (voltage > 32) pot_target_position = 23;

    if (voltage > 33) pot_target_position = 23;

    if (voltage > 34) pot_target_position = 26;

    if (voltage > 35) pot_target_position = 29;

    if (voltage > 36) pot_target_position = 31;    

    if (voltage > 37) pot_target_position = 34;

    if (voltage > 38) pot_target_position = 37;

    if (voltage > 39) pot_target_position = 40;

  

    do

    { if (pot_target_position > pot_position) Up();

      if (pot_target_position < pot_position) Down();

    } while (pot_position != pot_target_position);

  }


  if (voltage < stop_voltage)

  { digitalWrite(PIN9, HIGH);

    delay (50);

    if (pot_position >= min_pot_pos && pot_reset == 0)

    Pot_Reset();

  }


  if (voltage > break_voltage)

  { digitalWrite(PIN8, LOW);

    delay (50);   

  }

}