Regulator MPPT

[marek1707]

Moim zdaniem przesunięcie pomiaru napięcia wejściowego za opornik pomiarowy jest błędem (a nawet drobnym oszustwem). Ogniwo słoneczne oddaje swoją moc na swoich zaciskach i to ta moc Cię interesuje, to jest wejście do Twojego systemu. Dalej jest przetwornica a oporniki szeregowe są smutną koniecznością jej istnienia i działania. Są w niej ukryte tak jak tranzystor i powinny być wliczane do jej sprawności (tj. pogarszać ją). Dlatego powinieneś mierzyć napięcie na wejściu, już chyba o tym rozmawialiśmy. Jeśli chcesz poprawić sprawność całości przez inny pomiar prądu to zrób to (kiedyś..), ale nie udawaj że tych 0.1Ω tam nie ma albo że w tym układzie mogłoby ich nie być.

Dlaczego nie ustawiasz po prostu

krok = 1;

lub = -1, przecież za każdym razem od nowa go wyznaczasz i może być tylko -1 lub +1. Po co te inkrementacje ++, od jakiej wartości inkrementujesz, od poprzedniej? On ma się jakoś z czasem powiększać?

Sprawność >80% to całkiem nieźle jak na taką konstrukcję, naprawdę. To zasługa dobrego tranzystora i dużych dławików. Jeszcze ta dioda na wyjściu - robi bardzo złe wrażenie (szczególnie tu, przy małych napięciach) i pozbycie się jej w następnej wersji byłoby wyczynem, choć niełatwym. Pomyśl co ze sprawnością gdybyś V_out miał zawsze o 0.3-0.5V wyższe.. Miodzio, prawda? No ale do tego trzeba zastąpić ją drugim MOSFETem i to bardzo sprytnie sterowanym. Przemyśl w wolnej chwili kiedy musiałby przewodzić a kiedy trzeba by go wyłączać.

To teraz, gdy pomiary już działają i są skalibrowane, czas na algorytm. Jak zamierzasz go uruchomić zakładając, że z programem jakoś sobie poradzisz? Możesz opisać swoje stanowisko pomiarowe i pomysł na testy?

Po co funkcja ustawiania PWM jest typu int i oddaje odczyt z rejestru? Przecież i tak będziesz wyświetlał wchodzący do niej współczynnik odniesiony do 256 i pokazany w %. Nigdzie nie powinieneś potrzebować zwrotnej zawartości OCR2A.

Jak zrobiłeś opornik 46k?

Na wyjściu podłączyłeś 10Ω? Z czego to zasilasz? Podając jakieś wyniki pomiarów zawsze opisuj jak to zmierzyłeś, w jakich warunkach.

[Yggas]

W sumie masz racje chyba przekombinowałem z pomiarem napięcia wejściowego :/

Tam był rezystor 47k, źle wpisałem przez pośpiech, już poprawiłem.

Teraz poprawiłem kod i dodałem poprawkę na szybkość zmiany jeżeli krok będzie taki sam:

  //MPPT P&O
 delta_V = V_in - V_in_poprzednie ;
 delta_P = P_in - P_in_poprzednie ;

 if(delta_P != 0)
   {
     if(delta_P > 0)
       {
        if(delta_V > 0)
          {
          wzrost=1;

          } 
        else
         wzrost=-1;
       }
     else
       if(delta_V > 0)
       {
         wzrost=-1;
       }
       else
         wzrost=1;
   }

 if( wzrost == wzrost_poprzedni )
   factor++;
 else
   factor = 1;

 krok = wzrost * factor;
 pwm += krok;

 ustaw_pwm(pwm);

 V_in_poprzednie = V_in ;
 P_in_poprzednie = P_in;
 wzrost_poprzedni = wzrost;

Układ zasilany był z zasilacza: wydajność 500mA, zaczepy napięciowe 3V, 4.5V, 6V, 7.5V, 9V i 12V.

Tak na wyjściu był rezystor 10 Ohm, 5W. Potem jeszcze sprawdzałem jak to zadziała na silniczku DC i też było elegancko. Jeszcze na baterii nie sprawdzałem (nie chcę jej popsuć jeżeli algorytm będzie zły).

Próbowałem zasilać to z mojego ogniwa i oświetlać je lampką ale marny efekt. W domu jak byłem na wsi to oświetlałem żarówką 100W to dopiero jakiś tam efekt był widoczny. Tutaj mam tylko jakieś energooszczędne w lampce. Dlatego się zastanawiam czy z zasilacza wystarczy na "pokaz". Wypadało by jeszcze móc regulować prąd np jakimś potencjometrem ale to bez sensu bo mam same 10kR a tu raczej by był potrzebny jakiś potencjometr mocy w okolicach 10R. Możliwe, że uda mi się skorzystać z zasilacza laboratoryjnego w instytucie ale chyba jest mała szansa.

Jeszcze jedna kwestia co do algorytmu. Po podłączeniu baterii, która nie może przekroczyć 4.2V napięcia ładowania to czy algorytm ten zauważy to czy trzeba jakoś go programowo ograniczyć?

EDIT:

Ogólnie algorytm nie startuje :/

1.Podłączam zasilanie Arduino

2.Podłączam zasilanie wejściowe z PV (tutaj z zasilacza)

I nie nie dzieje się nic :/ Zmienna pwm ani drgnie.

Tutaj cały kod:

http://wklej.org/id/3370009/

Dodatkowo jest jeszcze problem taki, że jak odejmuje pwm to trafić się może przypadek gdzie od 0 odejmie się 1 i wtedy do zmiennej się ładuje liczba 255 :/

[marek1707]

Już pisałem - ładowarka to osobny problem, zostaw to na później, nie zrobisz tego wszystkiego od razu.

Teraz sam widzisz, że to nie jest takie proste, nawet samo MPPT. Zatrzymaj się na chwilę i pomyśl. Sama funkcja MPPT nie zadziała w jakiś magiczny sposób. Robisz całe urządzenie współpracujące z pewnym otoczeniem, myśl całościowo. Jak ona startuje gdy ma moc "poprzednią" i "aktualną" na zero? Co wtedy robi?

Na początku musisz zastanowić się nad stanami tego urządzenia. Załóżmy, że Twoje ogniwo słoneczne będzie dawać maks. 5.5V/0.5A. Moim zdaniem można to rozpisać jakoś tak:

1. Układ dopiero co podłączony, lub po resecie procesora. Nie pracuje przetwornica, PWM=0, nie ma mowy o żadnym MPPT. Program powinien w tym stanie mierzyć wyłącznie napięcie wejściowe. Jeśli jest mniejsze niż powiedzmy 3.5V, w ogóle nie ma co zaczynać zabawy w DCDC, mocy będzie na pewno za mało - pamiętasz charakterystyki ogniw słonecznych? Przypomnij sobie, bo to zaczyna być ważne. W stanie 1 kręcisz się w kółko, co np. 1s mierząc Vin. Wypisujesz jakiś sensowny komunikat typu "No input power" czy jakoś tak.

2. Gdy napięcie wzrosło powyżej jakiegoś progu (wymyśl coś, te 3.5V to tylko przykład, poprawny próg napięcia startu wyjdzie później z pomiarów mocy ogniwa), wchodzimy do stanu soft-start. Delikatnie zaczynasz np. od PWM=5. Np. po 100ms od załączenia PWM mierzysz napięcie wejściowe. Jeśli spadło poniżej progu, Słońca nie ma, wyłączasz PWM i wracasz do pkt. 1. Wypisz jakiś komunikat, może "Start failed, back to the darkness..". Jeśli Vin jest sensowne, przyjmujesz zmierzoną moc wejściową jako "poprzednią", startujesz MPPT, wypisujesz "Start successfull" i goto pkt 3.

3. W tym trybie juz MPPT pracuje i powinien "wspiąć się" powoli do warunków ustalonych. Niezależnie od tego, za każdym razem analizujesz czy MPPT nie zeszło z PWM do jakiegoś progu sensowności (5? 10?) albo czy Vin nie spadło poniżej progu z pkt 1. Wtedy reagujesz wyłączeniem przetwornicy bo:

- albo algorytm jest za wolny i nie nadążył za szybkimi zmianami i zarżnął ogniwo zbyt dużym wypełnieniem (musisz popracować nad lepszym/szybszym śledzeniem mocy),
- albo zmiana była szybsza niż najszybsza którą przewidziałeś i na to samo wychodzi (zawsze będzie coś szybszego niż algorytm, np. odłączenie/uszkodzenie ogniwa, przygotuj się na to). Możesz wypisać komunikat "Kto zgasił światło?" itp.

W obu przypadkach wracasz do pkt. 1 i jazda od początku.

Musisz tu też kontrolować, czy MPPT nie wymyśliło czegoś głupiego, nie zdryfowało na mieliznę a PWM nie urósł powyżej jakiegoś górnego progu sensowności. Na razie przyjmij powiedzmy 150 (przy 10Ω na wyjściu i założonej baterii słonecznej powinno wystarczyć), potem wyjdzie Ci z pomiarów jaka jest maksymalna moc Twojego ogniwa i coś tam ustalisz. Gdy jesteś już pod sufitem, dalszy wzrost PWM powinien być zabroniony. Może wtedy wypisywać coś w rodzaju "Max. input power!".

Czy to jakoś do Ciebie przemawia? Wyobrażaj sobie co Twoje urządzenie robi w każdych warunkach, wymyślaj mu podchwytliwe sytuacje i kombinuj z kodem tak by się z nich dobrze wydobywało. Kiedyś Ciebie zabraknie (np. pójdziesz na zajęcia) i będzie musiało sobie radzić z pogodą samo.

Moim zdaniem zasilacz laboratoryjny z regulacją napięcia i ograniczenia prądowego jest warunkiem koniecznym do poprawnego uruchomienia MPPT. Musisz go mieć nawet gdybyś musiał go sobie zrobić.

EDIT: Popraw linię modyfikującą PWM tak, by nigdy nie zrobiło kroku w dół od zera ani kroku w górę od 255. A nawet od 150.

[Yggas]

jak to jest z tymi zmiennymi i funkcjami?

w deklaracji funkcji deklaruje się w nawiasie zmienne pobierane z zewnątrz czy nowe zmienne, które są tylko w tej funkcji?

nie jestem pewien co do tego dlatego pomiary są w różnych miejscach...

http://wklej.org/id/3370144/

W tej chwili zrobiłem coś takiego. Teraz MPPT leci mi ciągle do zera :/

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[marek1707]

Tak, w deklaracji funkcji umieszczasz nazwy "nowych" zmiennych, które to nazwy potem możesz używać wewnątrz funkcji. To są tylko jej (funkcji) lokalne zmienne, nie mają nic wspólnego z (być może nawet tak samo nazywającymi się) zmiennymi na zewnątrz funkcji. Ta lista w nawiasie to tzw. parametry formalne. Funkcja używa jakichś swoich zmiennych lokalnych - zarówno tych z listy parametrów formalnych, których wartości zostały przekazane z zewnątrz jak i tych zadeklarowanych w niej jawnie, które mają albo wartości przypadkowe (zmienne tzw. automatyczne) albo jakieś określone (deklaracja z wartością początkową) albo poprzednie (zmienne statyczne). Dopóki w funkcji nie sięgniesz do zmiennej użytej gdzieś w całym programie (zmiennej globalnej) i zadeklarowanej gdzieś wyżej w kodzie, dopóty na zewnątrz nie widać działalności funkcji a jedyną możliwością otrzymania od niej wyników jest jej wartość, oddawana przez return.

Podczas wywołania funkcji parametry formalne dostają wartości takie, jakie wartości mają odpowiednie argumenty w chwili wywołania - tzw. parametry aktualne w kolejności umieszczenia na liście. Nie zachodzą żadne uzgodnienia nazw. Parametry aktualne nie muszą być zmiennymi, mogą być np. stałymi liczbowymi itp.

Wygląda, że Twój algorytm podejmuje złe decyzje co do kierunku kroku. Przyjrzyj się uważnie mocom, nawet gdy nowa moc jest większa niż poprzednia (czyli krok był w dobrym kierunku) to algorytm tego nie uwzględnia i postanawia zmodyfikować PWM w złą stronę. Spróbuj pamiętać poprzedni kierunek i gdy przyniósł pozytywny rezultat (wzrost mocy), próbować go powtórzyć.

Nie wiem jak Ty, ale program chyba zbyt optymistycznie ocenił sytuację pisząc "Softstart się powiódł" gdy moc zdechła do zera. Może wypisuj sobie więcej rzeczy, np. wielkości porównywanych mocy, decyzje MPPT z wnętrza jego funkcji. Wtedy będziesz lepiej rozumiał co się tam dzieje. Masz jeszcze dużo rzeczy do poprawienia, no ale tak właśnie powstają nietrywialne programy. Żaden nie działa od razu. Powodzenia.

EDIT: I nie kopiuj kawałków kodu w różne miejsca tylko twórz funkcje. Zamiast powtarzać w kilku miejscach:

Digital_V_in = analogRead(A1);
V_in = Digital_V_in * 3.20862 * (5.0/1024.0);

Od razu gdy tylko uruchomiłeś poprawne pomiary, zrób cztery funkcje. Przykład jednej:

float zmierz_Vin(void)
{
  return (analogRead(A1) * 3.20862 * (5.0/1024.0));
}

a potem używaj tego gdziekolwiek, np:

float aktualne_Vin = zmierz_Vin();

Program robi się o wiele bardziej czytelny niż jakieś dziwne współczynniki co chwila. Poza tym jedna magiczna liczba jest w jednym miejscu. Teraz gdy zmienisz dzielnik, musisz znaleźć w kodzie wszystkie pomiary Vin a jeśli coś pominiesz przy zmianie, wtedy dopiero się zacznie szukanie dlaczego tak dziwnie działa.

EDIT2: I jeszcze jedna uwaga ogólna: pisz proste programy, nie wrzucaj do kodu od razu wszystkiego co Ci przyjdzie do głowy. Jeżeli masz jakieś zręby MPPT, to zrób na początek krok tylko +/-1 lub +/-2 bez żadnej progresji wielkości kroku. To zrobisz później, gdy decyzje podstawowe będą Ok i zaczniesz szlifować prędkość reakcji. Skupiaj się na jednym problemie, rozwiązuj go, uruchom i przetestuj kod tak by działał na wielu przypadkach i dopiero wtedy dodawaj kolejne funkcjonalności. Jeśli natłukłeś kodu kilka stron a jeszcze (jak się okazuje) nie bardzo czujesz język, to stajesz przed ścianą mnóstwa zależności. Proste funkcje, kilkulinijkowe, dobrze nazwane, nie robiące niczego dziwnego ze zmiennymi globalnymi. Wrzucasz im jakieś argumenty - dostajesz jasny wynik. Im bardziej zagmatwasz swój kod (bo szybciej jest skopiować jakiś fragment w inne miejsce niż wydzielić ładną funkcję) tym później wszystko zadziała i będzie gorzej sprawdzone.

[marek1707]

Hop hop, co tam w temacie? Wyszedłeś z tej bitwy z tarczą czy poległeś pod naporem terminów? Co zadziałało a co nie? Plany dokończenia? Rozbudowy? Praktycznego wykorzystania nowej wiedzy? Napaliłeś się na coś większego/lepszego/innego? Zniechęciłeś?

[Yggas]

Całą noc siedziałem nad tym ale nie dałem rady ogarnąć algorytmu. Od 4 rano postanowiłem przerobić prezentację na to co mam. Oddałem projekt w poniedziałek jako płytkę samodzielnie zrobioną z kodem poniżej. Potencjometrem sobie ustawiam napięcie potrzebne. Taki niby zasilacz lab lub coś. Teraz mam tydzień wolnego przed nowym semestrem to się obijam 😋

Wieczorem może coś wrzucę bardziej przemyślanego z algorytmem MPPT bo w sumie fajnie by było to mieć na lato.

http://wklej.org/id/3372000/

[marek1707]

Ech, zabrakło pewnie jeszcze jednej nocy.. Szkoda, ale grunt to się nie poddawać. I tak wiele rzeczy zrobiłeś a SEPIC lub buck zostaną w głowie na długo 🙂

Jeżeli nie masz w zasadzie pomysłu jak to ugryźć, nie pisz kolejnych programów tylko myśl nad algorytmem i zachowaniem układu. Spisz sobie co po kolei powinno być robione. To nie musi być rysunek/grafika ze szkolnymi prostokątami operacji i rombami wyborów. Wystarczą ponumerowane punkty. Prześledź ten przepis jakbyś to Ty był przetwornicą i był sterowany takim algorytmem - taka symulacja w głowie. Do tego wcale nie jest potrzebny komputer. Zastanów się gdzie są pułapki i zmieniaj zapisy do woli - na etapie kartki i ołówka to nic nie kosztuje. Gdy już siadasz do IDE, jesteś w pułapce myślenia językiem programowania. Pozwól sobie na spokojne przemyślenia przy herbacie, czy co tam teraz się pije.. Popatrz kiedy mierzysz wielkości, kiedy coś zmieniasz a kiedy trzeba chwilę poczekać na odpowiedź układu po zmianie. Przyjmij na razie krok ±N, niech będzie na razie stały, ale definiowany gdzieś na początku żeby było łatwo go modyfikować. Ja zajrzę tymczasem do moich starych kodów jak to kiedyś udało mi się zrobić. Pamiętam, że standardowy P&O nie był zbyt "lotny" i coś tam kombinowałem, ale w swojej podstawowej wersji na pewno także działa(ł).

Czy masz jakiś zasilacz do prób? Jaki? Może warto mu dospawać na zewnątrz kilka elementów by lepiej udawał źródło ograniczonej mocy? Bez tego MPPT będzie zawsze opierał się o własny limit P_in (jeśli taki mu wbudujesz) lub o możliwości zasilacza, a praca na granicy jego przeciążenia to nie jest dobry pomysł.

[Yggas]

Testowałem kod ten taki podstawowy bez żadnych bajerów w niedzielę, akurat było trochę słońca by coś działało na moim 3.5W panelu słonecznym 😋

  float V_in = 0;
 float V_out = 0;
 float I_in = 0;
 float I_out = 0;
 float P_in = 0;
 float P_out = 0;
 float n = 0;
 float delta_V = 0;
 float delta_P = 0;
 float V_in_poprzednie = 0;
 float P_in_poprzednie = 0;
 uint8_t pwm  = 30;
 uint8_t krok = 0;
 uint8_t last_pwm = 0;
 unsigned long czas = 0;

void setup()
{

 //Ustawienie sygnału prostokątnego na pin11 o częstotliwości 62500Hz

 pinMode(11, OUTPUT);
 OCR2A = 255; 
 TCCR2A = _BV(WGM21) | _BV(WGM20) | _BV(COM2A1) | _BV(COM2A0); 
 TCCR2B = _BV(CS20);

 //Uruchomienie komunikacji przez USART
 Serial.begin(9600);

}

//Funkcja przeładowania rejestru nową wypracowaną zmienną
uint8_t ustaw_pwm (uint8_t pwm)
 {
   return (255 - pwm);
 }

//Funkcja do pomiaru napięcia ogniwa
float pomiar_napiecia_ogniwa ()
{
 float napiecie_ogniwa;
 napiecie_ogniwa = analogRead(A1) * 3.20862 * ( 5.0 / 1024.0 );
 return napiecie_ogniwa;
}


void loop() {

 czas = millis();

 //Przeliczenie wartości cyfrowych na analogowe
 V_in = analogRead(A1) * 3.20862 * (5.0/1024.0);
 V_out = analogRead(A3) * 3.2316 * (5.0/1024.0); 
 I_in = analogRead(A0) * (1.04/1024.0); 
 I_out = analogRead(A2) * (1.04/1024.0); 

 //Obliczanie mocy i sprawności
 P_in = V_in * I_in * 1000;
 P_out = V_out * I_out * 1000;
 n = P_out / P_in * 100;
 delta_V = V_in - V_in_poprzednie ;
 delta_P = P_in - P_in_poprzednie ;

 if(delta_P >= 300)
   if(delta_V >= 0.01)
     krok = 2;
     else
     krok = -2;
 else
   if(delta_V >=0.01)
     krok = -2;
     else
     krok = 2;

 pwm = pwm + krok;

 if(V_out >= 4.18)
   pwm = last_pwm;

 if(pwm >= 160)
   pwm = last_pwm;

 OCR2A = ustaw_pwm(pwm);
 V_in_poprzednie = V_in;
 P_in_poprzednie = P_in;
 last_pwm = pwm;

 //Wyświetlanie wyników

 Serial.print(czas/1000);
 Serial.print(" ");
 Serial.print(V_in,3);
 Serial.print(" ");
 Serial.print(V_out,3);
 Serial.print(" ");
 Serial.print(I_in,3);
 Serial.print(" ");
 Serial.print(I_out,3);
 Serial.print(" ");
 Serial.print(P_in);
 Serial.print(" ");
 Serial.print(P_out);
 Serial.print(" ");
 Serial.print(n,1);
 Serial.print(" ");
 Serial.println(pwm);


 delay(1000);
 }

Obciążeniem była 1W dioda LED, pewnie trochę lipa bo jest super nieliniowa i lepszy był by ten rezystor no ale jak zaczęło się zliczanie danych to zostawiłem. (zbyt długo to słońce nie świeciło). Napięcie wyjściowe ograniczyłem programowo do 4.18V oraz pwm by nie rosło nie wiadomo ile. Co zauważyłem to jak ograniczę pwm z góry to nigdy nie zejdzie poniżej 0 co da od razu 255 itp ale tego jeszcze nie jestem pewien potrzebne parę testów 😋 Pomiary były robione co sekundę. Jak słońce świeciło ostro to pwm był maksymalny lecz pod końcem trochę głupiał jak słońce się ledwo przebijało przez chmury.

Testować układ mogę tylko weekendami :/ Może jakieś wskazówki co w ten weekend przetestować?