Hilfe beim MPPT.

[Robert M. (andro86)]

Hallo zusammen, ich benötige eure Hilfe bei meinem MPPT. Ich soll einen 
MPPT mittels SEPIC-Wandler Topologie (Topologie ist vorgegeben) für 
einen Thermogenerator bauen mit dem eine Batterie geladen werden soll. 
Im Anhang ist der dazu entworfene Schaltplan. Dabei habe ich L1 und L2 
auf einen gemeinsamen Eisenpulver Ringkern gewickelt.
Für den MPPT Algorithmus benutze ich die Methode der steigenden 
Konduktanz (Incremental Conductance). Der entsprechende µC Code folgt.

/***********************************************************************************************
 * MPPTAlgorithmus.c
 * 
 * Used µC       : ATmega32U4 
 * Compiler      : AVR Studio 6.1 
 * Configuration : External oscillator with 16 MHz.
 **********************************************************************************************/
  
   
/***********************************************************************************************
************************************* Adjusted Fuse-Bits ***************************************
***********************************************************************************************/  
 
/*
  Notice: [x] means programmed (enabled or 0), while [] means unprogrammed (diasabled or 1)!

  BODLEVEL  [4V3]
  HWBE    [x]
  OCDEN    []
  JTAGEN    []  ...  need to be disabled because of the ADC pins
  SPIEN    [x]  ... never disable this fuse otherwise the µC becomes not programmable!!!
  WDTON    []
  EESAVE    []
  BOOTSZ    [2048W_3800]
  BOOTRST    []
  CKDIV8    []  ... [x] => clock prescaler = 8:  [] => clock prescaler = 1.
  CKOUT    []
  SUT_CKSEL  [EXTXOSC_8MHz_XX_258CK_65MS]

*/
  

/***********************************************************************************************
**************************************** Header-files ******************************************
***********************************************************************************************/

// <avr/io.h> integrates all the necessary PORT and register names.
#include <avr/io.h>
//<util/delay.h> Header file with summary of waiting functions.
#include <util/delay.h>
//<stdint.h> Integer types with predefined width such as uint8_t or int16_t.
#include <stdint.h>


/***********************************************************************************************
************************************ Variable Definition ***************************************
************************************       Global        ***************************************
***********************************************************************************************/


volatile int8_t duty_cycle = 127;

/***********************************************************************************************
********************************  Declaration of functions  ************************************  
********************************       "Function head"      ************************************
***********************************************************************************************/

  void ADC_Initialization(void);
  
  void Set_DutyCycle(uint8_t duty_cycle);
  
  uint32_t ADC_Read_Value(uint8_t pin_channel);
  
  uint32_t ADC_Read_AvarageValue(uint8_t pin_channel, uint8_t samples);
  

/***********************************************************************************************
**************************************** Main Routine ******************************************
***********************************************************************************************/
  
int main(void)
{

  
  int32_t u_in = 0;
  int32_t i_in = 0;
  
  int32_t u_in_previous = 0;
  int32_t i_in_previous = 0;
  
  int32_t delta_u_in = 0;
  int32_t delta_i_in = 0;
  
    // set Pin F4-7 as Input (ADC Input Channels).
  DDRF &= ~((1<<DDF4)|(1<<DDF5)|(1<<DDF6)|(1<<DDF7));
    // deactivate Pull-Up Resistor on Pin F4-7.
  PORTF &= ~((1<<PF4)|(1<<PF5)|(1<<PF6)|(1<<PF7));

/***********************************************************************************************
*************************************** Timer/Counter ******************************************
*************************************** PWM-generator ******************************************
***********************************************************************************************/  
                                                         
    TCCR0A|=(1<<WGM01)|(1<<WGM00); // Setting fast-PWM mode.                        
     TCCR0A|=(1<<COM0A1);       /* OC0A become low at a match and high at top.*/

                                                                                           
       // PWM-frequency = timer clock/(Prescaler * 256)= 16 MHz/(1*256) = 62.5 kHz 
  TCCR0B|=(1<<CS00);        // Prescaler = 1. Datasheet Page 105.
     TCCR0B &=~(1<<WGM02);      // TCNT0 run continuous after match until TOP reaches.                                     
                                                                                                                                                           
     Set_DutyCycle(duty_cycle);    // Clock ratio/ trigger the PWM.                                                      
                                                                                      
    DDRB|=(1<<PB7);    // Set Pin P7 for OC0A as output.        

/***********************************************************************************************
*************************************** Initialize ADC *****************************************
***********************************************************************************************/  
  
  ADC_Initialization();
  
/***********************************************************************************************
***************************************** While Loop *******************************************
************************************************************************************************/

    while(1)
    {
    _delay_ms(2);
    
      //Sampling the current and voltage values
    u_in = ADC_Read_AvarageValue(4,10);
    i_in = ADC_Read_AvarageValue(5,10);
   
/***********************************************************************************************
********************************** Incremental Conductance  ************************************  
**********************************        Algorithm         ************************************
***********************************************************************************************/       
        
      delta_u_in = u_in-u_in_previous;
      delta_i_in = i_in-i_in_previous;
     
      if(delta_u_in == 0 )
      {//Yes branch delta_u_in == 0
        
        if(delta_i_in == 0)
        { 
          // Yes branch do nothing. MPP is found.
                            
        }
        else // No branch delta_i_in == 0
        { 
          if(delta_i_in > 0)
          {
            -- duty_cycle;
          }
          else
          {
            if(delta_i_in < 0)
            {          
              ++ duty_cycle;
            }            
          }                           
        }            
      }
      else // No branch delta_u_in == 0
      {
        if((1000*delta_i_in)/delta_u_in == - (1000*i_in)/u_in)
        {
          // Yes branch do nothing. MPP is found.
        }
        else // No branch delta_i_in/delta_u_in == - i_in/u_in.
        {
          if((1000*delta_i_in)/delta_u_in > - (1000*i_in)/u_in)
          {
            -- duty_cycle;
          }
          else
          {
            if((1000*delta_i_in)/delta_u_in < - (1000*i_in)/u_in)
            {
              ++ duty_cycle;
            }            
          }                
        }          
      }
     
      u_in_previous = u_in;
      i_in_previous = i_in;
      
      
      Set_DutyCycle(duty_cycle);
  }
}
/***********************************************************************************************
******************************* Definition of the functions  ***********************************  
*******************************       "Functionbody"         ***********************************
************************************************************************************************/      

  void ADC_Initialization(void)
  {
    ADMUX|=(1<<REFS0);              // Set reference voltage to AVcc.

    ADCSRA|=(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);  // Set prescaler to 128.
    ADCSRA|=(1<<ADEN);              // Activate converter.
      //AD conversion is started
    ADCSRA|=(1<<ADSC);    
    while (ADCSRA & (1<<ADSC) )        // Wait for completion of the conversion.
    {  
     }
     /* ADCW must be read once, otherwise the result of the next conversion is not 
        taken. */
    (void) ADCW;    
  
  }    
  
  uint32_t ADC_Read_AvarageValue(uint8_t pin_channel, uint8_t samples)
  {
    uint32_t sum = 0;
      
    for (uint8_t i = 0; i < samples; ++i ) 
    {
      sum += ADC_Read_Value( pin_channel );
    }  
    
    return ( sum / samples );
  }  
  
  uint32_t ADC_Read_Value(uint8_t pin_channel)
  {
    ADMUX = (ADMUX & ~(0x1F)) | (pin_channel & 0x1F);
    ADCSRA |= (1<<ADSC);          // one Conversion "single conversion"
    while (ADCSRA & (1<<ADSC) ) 
    {                    // Wait for completion of the conversion
    }
    return ADCW;
  }
  
  void Set_DutyCycle(uint8_t duty_cycle)
  {
      OCR0A =  duty_cycle;  
  }

Meinen MPPT sollte ich ursprünglich am Thermogenerator selber testen, 
doch es gab einige Komplikationen und somit bin ich auf 2 Netzteile 
umgestiegen. Eingangsseitig habe ich den TEG durch ein Leistungsnetzteil 
ersetzt, das mir eine Spannung im Bereich von 1-10 V und einen Srom von 
0.1 - 1 A liefert. Ausgangsseitig habe ich als Batterieersatzt ein 
weiteres Netzteil an die U_Out Klemmen geschaltet, das schon einige Watt 
Leistung aufnehmen kann und mir immer konstante 12 V liefert. Dieser 
ganze Messaufbau dient einzig und allein dazu um zu testen, ob mein 
gebauter MPPT vom Prinzip her funktioniert. Den Wandler betreibe ich mit 
einer Schaltfrequenz von 62.5 kHz.
Was oben im Schaltplan nicht zu sehen ist, ist ein zusätzlicher 
Widerstand in Reihe geschaltet zwischen eingangsseitigem 
Leistungsnetzteil und Eingang SEPIC Wandler. Er soll den internen 
Widerstaden des TEG darstellen und hat einen Wert von 1.5 Ohm. Ich hab 
diesen hier gewählt, weil das der niedrigste Wert war, den ich hier 
finden konnte, der zudem auch noch einpaar Watt Leistung verträgt.

Zur Theorie: Wenn mein Tracker den MPP gefunden hat, so müsste sich am 
Eingang meines Wandlers doch die halbe Leerlaufspannung meines 
Leistungsnetzteiles einstellen oder nicht? Genau dann hab ich doch meine 
Widerstandsanpassung und kann die größte Leistung entnehmen?

Zur Praxis: Mein Tracker verhält sich total chaotisch und macht nicht 
wirklich das was er machen soll. Mal schwingt sich die Eingangsspannung 
des Wandlers auf keinen Wert ein und wenn doch, dann liegt er um etwa 
0.5 bis 0.7 V unter der errechneten MPP Spannung. Und selbst dann bleibt 
er nicht immer auf diesen Wert, sondern fängt nach einer Zeit wieder an 
zu schwingen.
Ich bin auch mal mit der Schaltfrequenz runter auf 7 kHz gegangen und da 
schien es besser zu funktionieren. Der MPP wurde für kleinere Spannungen 
getroffen, doch je höher ich mit der Netzteilspannung ging, desto weiter 
lief der Arbeitspunkt dem MPP davon.

Ich weis gerade nicht wie ich das zum laufen bringen könnte, von daher 
wäre ich über jede Anregung und Hilfestellung dankbar.

[MaWin (Gast)]

> Wenn mein Tracker den MPP gefunden hat, so müsste sich am
> Eingang meines Wandlers doch die halbe Leerlaufspannung meines
> Leistungsnetzteiles einstellen oder nicht

Nö, Leerlaufspannung und Belastungsspannung eines Netzteils sind nahezu 
identisch.

>  Genau dann hab ich doch meine Widerstandsanpassung

Dazu musst du erst zwischen Netzteilausgang udn Wandlereingang einen 
Leistungsiwderstand schalten, um den Innenwiderstand des Netzteils 
künstlich zu erhöhen.

[MaWin (Gast)]

> Was oben im Schaltplan nicht zu sehen ist, ist ein zusätzlicher
> Widerstand in Reihe geschaltet zwischen eingangsseitigem
> Leistungsnetzteil und Eingang SEPIC Wandler

Aha, und Elkos davor und dahinter (nach Masse) ?

[Robert M. (andro86)]

MaWin schrieb:
>> Wenn mein Tracker den MPP gefunden hat, so müsste sich am
>> Eingang meines Wandlers doch die halbe Leerlaufspannung meines
>> Leistungsnetzteiles einstellen oder nicht
>
> Nö, Leerlaufspannung und Belastungsspannung eines Netzteils sind nahezu
> identisch.
>
>>  Genau dann hab ich doch meine Widerstandsanpassung
>
> Dazu musst du erst zwischen Netzteilausgang udn Wandlereingang einen
> Leistungsiwderstand schalten, um den Innenwiderstand des Netzteils
> künstlich zu erhöhen.

Genau dazu habe ich ja meinen 1.5 Ohm Widerstand dorthin geschaltet. Es 
sieht wie folgt aus:

Leistungsnetzteil----Leistungswiderstand----Wandler.

[MaWin (Gast)]

Bei 10V/1A Netzteil liegt der MPP am 1.5 Ohm Widerstand doch bei vollem 
Strom, also 1A, also wird der MPP mit der Strombegrenzung des Netzteils 
kollidieren. Mindestens 5 Ohm wären wohl nötig.

[Robert M. (andro86)]

MaWin schrieb:
> Bei 10V/1A Netzteil liegt der MPP am 1.5 Ohm Widerstand doch bei vollem
> Strom, also 1A, also wird der MPP mit der Strombegrenzung des Netzteils
> kollidieren. Mindestens 5 Ohm wären wohl nötig.

Der würde auch schon bei 3 V in die Begrenzung gehen, wenn sich mein 
Wandlerwiderstand den 1.5 Ohm anpassen würde. Fakt ist jedoch, ich kann 
mit der Spannung schon bis 8 V hoch gehen und ich komme damit nicht 
wirklich oft in die Begrenzung des Netzteiles. Und jetzt weis ich nicht, 
ob es an meiner Leistungselektronik, an meinem Code oder an Beidem 
liegt.