Simplificare schema

[Gilbert Sparios]

Sursa schemei, și alte informații le puteti găsii aici.

 

Schema se vrea a fi un incarcator solar. Dar eu as vrea sa stiu daca Nu ar merge si simplificand schema prezentata acolo.

 

schema originala este

 

 

modificare asa:

 

de ce nu ar merge fara IR2104 si sursa ei aferenta ?

 

 

codul postat de creeator:

//ARDUINO MPPT SOLAR CHARGE CONTROLLER (Version-3)
//Author: Debasish Dutta/deba168
//          www.opengreenenergy.in
// This code was wrote for an arduino Nano based Solar MPPT charge controller.
// This code is a modified version of sample code from www.timnolan.com
// updated 06/07/2015
// Adapted for Arduino Pro mini on my project on 11/2016
 
#include "TimerOne.h"
#include "LiquidCrystal_I2C.h"
#include "Wire.h" 
 
// A0 - Voltage divider (solar)
// A1 - ACS 712 Out
// A2 - Voltage divider (battery)
// A4 - LCD SDA
// A5 - LCD SCL
// D5 - LCD back control button
// D6 - Load Control
// D8 - 2104 MOSFET driver SD
// D9 - 2104 MOSFET driver IN
// D11- Green LED
// D12- Blue LED
// D13- Red LED
 
#define LOAD_ALGORITHM 0
#define SOL_VOLTS_CHAN 0
#define BAT_VOLTS_CHAN 1
#define SOL_AMPS_CHAN 2
#define AVG_NUM 8
#define SOL_VOLTS_SCALE 0.024900275
#define BAT_VOLTS_SCALE 0.024926075
#define SOL_AMPS_SCALE  0.024506081
#define PWM_PIN 9
#define PWM_ENABLE_PIN 8
#define PWM_FULL 1023
#define PWM_MAX 100
#define PWM_MIN 60
#define PWM_START 90
#define PWM_INC 1
#define TRUE 1
#define FALSE 0
#define ON TRUE
#define OFF FALSE
#define TURN_ON_MOSFETS digitalWrite(PWM_ENABLE_PIN, HIGH)
#define TURN_OFF_MOSFETS digitalWrite(PWM_ENABLE_PIN, LOW)
#define ONE_SECOND 50000
#define LOW_SOL_WATTS 5.00
#define MIN_SOL_WATTS 1.00
#define MIN_BAT_VOLTS 11.00
#define MAX_BAT_VOLTS 14.10
#define BATT_FLOAT 13.60
#define HIGH_BAT_VOLTS 13.00
#define LVD 11.5
#define OFF_NUM 9
#define LED_GREEN 11
#define LED_BLUE 12
#define LED_RED 13
#define LOAD_PIN 6
#define BACK_LIGHT_PIN 5      
 
byte battery_icons[6][8]=
{{
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b00000,
},
{
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11111,
  0b00000,
},
{
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b11111,
  0b11111,
  0b11111,
  0b00000,
},
{
  0b01110,
  0b11011,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b00000,
},
{
  0b01110,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b00000,
},
{
  0b01110,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b00000,
}};
#define SOLAR_ICON 6
byte solar_icon[8] =
{
  0b11111,
  0b10101,
  0b11111,
  0b10101,
  0b11111,
  0b10101,
  0b11111,
  0b00000
};
#define PWM_ICON 7
byte _PWM_icon[8]=
{
  0b11101,
  0b10101,
  0b10101,
  0b10101,
  0b10101,
  0b10101,
  0b10111,
  0b00000,
};
byte backslash_char[8]=
{
  0b10000,
  0b10000,
  0b01000,
  0b01000,
  0b00100,
  0b00100,
  0b00010,
  0b00000,
};
float sol_amps;
float sol_volts;
float bat_volts;
float sol_watts;
float old_sol_watts = 0;
unsigned int seconds = 0;
unsigned int prev_seconds = 0;
unsigned int interrupt_counter = 0;
unsigned long time = 0;
int delta = PWM_INC;
int pwm = 0;
int back_light_pin_State = 0;
boolean load_status = false;
enum charger_mode {off, on, bulk, bat_float} charger_state;
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  
 
void setup()
{
  pinMode(PWM_ENABLE_PIN, OUTPUT);
  TURN_OFF_MOSFETS;
  charger_state = off;
  lcd.begin(20,4);
  lcd.backlight();
  for (int batchar = 0; batchar < 6; ++batchar)
  {
    lcd.createChar(batchar, battery_icons[batchar]);
  }
  lcd.createChar(PWM_ICON,_PWM_icon);
  lcd.createChar(SOLAR_ICON,solar_icon);
  lcd.createChar('\\', backslash_char);
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);
  Timer1.initialize(20);
  Timer1.pwm(PWM_PIN, 0);
  Timer1.attachInterrupt(callback);
  Serial.begin(9600);
  pwm = PWM_START;
  pinMode(BACK_LIGHT_PIN, INPUT);
  pinMode(LOAD_PIN,OUTPUT);
  digitalWrite(LOAD_PIN,LOW);
  digitalWrite(BACK_LIGHT_PIN,LOW);
  lcd.setCursor(0, 0);
  lcd.print("SOL");
  lcd.setCursor(4, 0);
  lcd.write(SOLAR_ICON);
  lcd.setCursor(8, 0);
  lcd.print("BAT");
}
 
void loop()
{
  read_data();
  run_charger();
 // print_data();
  load_control();
  led_output();
  lcd_display();
}
 
int read_adc(int channel)
{
  int sum = 0;
  int temp;
  int i;
 
  for (i=0; i<AVG_NUM; i++) { temp = analogRead(channel); sum += temp; delayMicroseconds(50); } return(sum / AVG_NUM); } void read_data(void) { sol_amps = (read_adc(SOL_AMPS_CHAN) * SOL_AMPS_SCALE -13.51); sol_volts = read_adc(SOL_VOLTS_CHAN) * SOL_VOLTS_SCALE; bat_volts = read_adc(BAT_VOLTS_CHAN) * BAT_VOLTS_SCALE; sol_watts = sol_amps * sol_volts ; } void callback() { if (interrupt_counter++ > ONE_SECOND)
  {
    interrupt_counter = 0;
    seconds++;
  }
}
 
void set_pwm_duty(void)
{
 
  if (pwm > PWM_MAX)
  {
    pwm = PWM_MAX;
  }
  else if (pwm < PWM_MIN)
  {
    pwm = PWM_MIN;
  }
  if (pwm < PWM_MAX)
  {
    Timer1.pwm(PWM_PIN,(PWM_FULL * (long)pwm / 100), 20);
  }
  else if (pwm == PWM_MAX)
  {
    Timer1.pwm(PWM_PIN,(PWM_FULL - 1), 20);
}
}   
 
void run_charger(void)
{
  static int off_count = OFF_NUM;
  switch (charger_state)
  {
    case on:
      if (sol_watts < MIN_SOL_WATTS) { charger_state = off; off_count = OFF_NUM; TURN_OFF_MOSFETS; } else if (bat_volts > (BATT_FLOAT - 0.1))
      {
        charger_state = bat_float;
      }
      else if (sol_watts < LOW_SOL_WATTS)
      {
        pwm = PWM_MAX;
        set_pwm_duty();
      }
      else
      {
        pwm = ((bat_volts * 10) / (sol_volts / 10)) + 5;
        charger_state = bulk;
      }
      break;
 
    case bulk:
      if (sol_watts < MIN_SOL_WATTS) { charger_state = off; off_count = OFF_NUM; TURN_OFF_MOSFETS; } else if (bat_volts > BATT_FLOAT)
      {
        charger_state = bat_float;
      }
      else if (sol_watts < LOW_SOL_WATTS) { charger_state = on; TURN_ON_MOSFETS; } else { if (old_sol_watts >= sol_watts)
        {
          delta = -delta;
        }
        pwm += delta;
        old_sol_watts = sol_watts;
        set_pwm_duty();
      }
      break;
 
    case bat_float:
      if (sol_watts < MIN_SOL_WATTS) { charger_state = off; off_count = OFF_NUM; TURN_OFF_MOSFETS; set_pwm_duty(); } else if (bat_volts > BATT_FLOAT)
      {
        TURN_OFF_MOSFETS;
        pwm = PWM_MAX;
        set_pwm_duty();
      }
      else if (bat_volts < BATT_FLOAT)
      {
        pwm = PWM_MAX;
        set_pwm_duty();
        TURN_ON_MOSFETS;
        if (bat_volts < (BATT_FLOAT - 0.1)) { charger_state = bulk; } } break; case off: TURN_OFF_MOSFETS; if (off_count > 0)
      {
        off_count--;
      }
      else if ((bat_volts > BATT_FLOAT) && (sol_volts > bat_volts))
      {
        charger_state = bat_float;
        TURN_ON_MOSFETS;
      }
      else if ((bat_volts > MIN_BAT_VOLTS) && (bat_volts < BATT_FLOAT) && (sol_volts > bat_volts))
      {
        charger_state = bulk;
        TURN_ON_MOSFETS;
      }
      break;
    default:
      TURN_OFF_MOSFETS;
      break;
  }
}
 
void load_control()
{
#if LOAD_ALGORITHM == 0
  load_on(sol_watts < MIN_SOL_WATTS && bat_volts > LVD);
#else
  load_on(sol_watts > MIN_SOL_WATTS && bat_volts > BATT_FLOAT);
#endif
}
 
void load_on(boolean new_status)
{
  if (load_status != new_status)
  {
    load_status = new_status;
    digitalWrite(LOAD_PIN, new_status ? HIGH : LOW);
  }
}
 
void print_data(void)  // you can skip this part)
{
  Serial.print(seconds,DEC);
  Serial.print("      ");
  Serial.print("Charging = ");
  if (charger_state == on) Serial.print("on   ");
  else if (charger_state == off) Serial.print("off  ");
  else if (charger_state == bulk) Serial.print("bulk ");
  else if (charger_state == bat_float) Serial.print("float");
  Serial.print("      ");
 
  Serial.print("pwm = ");
  if(charger_state == off)
  Serial.print(0,DEC);
  else
  Serial.print(pwm,DEC);
  Serial.print("      ");
 
  Serial.print("Current (panel) = ");
  Serial.print(sol_amps);
  Serial.print("      ");
 
  Serial.print("Voltage (panel) = ");
  Serial.print(sol_volts);
  Serial.print("      ");
 
  Serial.print("Power (panel) = ");
  Serial.print(sol_volts);
  Serial.print("      ");
 
  Serial.print("Battery Voltage = ");
  Serial.print(bat_volts);
  Serial.print("      ");
 
  Serial.print("\n\r");
  //delay(1000);
}
 
void light_led(char pin)
{
  static char last_lit;
  if (last_lit == pin)
      return;
  if (last_lit != 0)
      digitalWrite(last_lit, HIGH);
  digitalWrite(pin, LOW);
  last_lit = pin;
}
 
void led_output(void)
{
  static char last_lit;
  if(bat_volts > 14.1 )
      light_led(LED_BLUE);
  else if(bat_volts > 11.9)
      light_led(LED_GREEN);
  else
      light_led(LED_RED);
}
void lcd_display()
{
  static bool current_backlight_state = -1;
  back_light_pin_State = digitalRead(BACK_LIGHT_PIN);
  if (current_backlight_state != back_light_pin_State)
  {
    current_backlight_state = back_light_pin_State;
    if (back_light_pin_State == HIGH)
      lcd.backlight();
    else
      lcd.noBacklight();
  }
 
  if (back_light_pin_State == HIGH)
  {
    time = millis();
  }
 
 lcd.setCursor(0, 1);
 lcd.print(sol_volts);
 lcd.print("V ");
 lcd.setCursor(0, 2);
 lcd.print(sol_amps);
 lcd.print("A");
 lcd.setCursor(0, 3);
 lcd.print(sol_watts);
 lcd.print("W ");
 lcd.setCursor(8, 1);
 lcd.print(bat_volts);
 lcd.setCursor(8,2);
 
 if (charger_state == on)
 lcd.print("on   ");
 else if (charger_state == off)
 lcd.print("off  ");
 else if (charger_state == bulk)
 lcd.print("bulk ");
 else if (charger_state == bat_float)
 {
 lcd.print("     ");
 lcd.setCursor(8,2);
 lcd.print("float");
 }
 
 int pct = 100.0*(bat_volts - 11.3)/(12.7 - 11.3);
 if (pct < 0) pct = 0; else if (pct > 100)
     pct = 100;
 
 lcd.setCursor(12,0);
 lcd.print((char)(pct*5/100));
 
 lcd.setCursor(8,3);
 pct = pct - (pct%10);
 lcd.print(pct);
 lcd.print("%  ");
 
 lcd.setCursor(15,0);
 lcd.print("PWM");
 lcd.setCursor(19,0);
 lcd.write(PWM_ICON);
 lcd.setCursor(15,1);
 lcd.print("   ");
 lcd.setCursor(15,1);
 if( charger_state == off)
 lcd.print(0);
 else
 lcd.print(pwm);
 lcd.print("% ");
 
 lcd.setCursor(15,2);
 lcd.print("Load");
 lcd.setCursor(15,3);
 if (load_status)
 {
    lcd.print("On  ");
 }
 else
 {
   lcd.print("Off ");
 }
 spinner();
 backLight_timer();
}
 
void backLight_timer()
{
  if((millis() - time) <= 15000)
      lcd.backlight();
  else
      lcd.noBacklight();
}
void spinner(void)
{
  static int cspinner;
  static char spinner_chars[] = { '*','*', '*', ' ', ' '};
  cspinner++;
  lcd.print(spinner_chars[cspinner%sizeof(spinner_chars)]);
}

 

Editat Aprilie 29, 2020 de Gilbert Sparios

[UDAR]

Pentru că nu poți comanda MOS-ul de sus . Mă rog, nici cel de jos nu se simte prea bine comandat direct din controler.

Editat Aprilie 29, 2020 de UDAR

[Gilbert Sparios]

Acum 18 minute, UDAR a spus:

Pentru că nu poți comanda MOS-ul de sus . Mă rog, nici cel de jos nu se simte prea bine comandat direct din controler.

 

dar..sunt logic level (IRL540N).. in versiunea prezentata modificata..

nici asa nu se simt in largul lor ? pentru ca eu am comandat destui cu sarcini relativi mari fara nici macar vreun alt tranzistor sau driver...adevarat ca in frecventa redusa dar, nu stiu..

Editat Aprilie 29, 2020 de Gilbert Sparios

[UDAR]

Să le luăm pe rând . LogicLevel înseamnă că are nevoie de 3-4V pe POARTĂ față de SURSĂ . Când MOS-ul de sus conduce sursa lui se află aproape la tensiunea de intrare deci poarta trebuie să fie cu 3-4V deasupra . Dacă ai 50V saă zicem Uintrare poarta trebuie să fie la peste 50V ca să conducă MOS-ul.

Acum curentul necesar . Timpul de comutare al MOS-ului este aproximativ invers proporțional cu curentul pe care i-l poate da driverul . Poți comanda un MOS din microcontroler dar va comuta probabil în zeci de µs ( dacă e de putere cum e cazul aici ) .

[Gilbert Sparios]

mda. eu credeam ca Q2 clar cu el. are masa, are tensiune pe poarta suficient cat sa deschida.

Q1 in mintea mea isi lua masa prin baterie. Si recunosc ca m-am cam zapacit..

Nu prea inteleg nici acum modul de functionare a schemei, dar poate o sa inteleg dupa ce o construiesc si analizez softul mai mult.

 

Ok, deci ramane ca NU. Dar tranzistorii aia IRF520 as putea sa-i inlocuiesc cu IRL540N sau IRF540N ? (am in casa mai multi si n-as mai cumpara) si ca parametrii par chiar mai bine decat IRF520. Ma refer pentru situatia de fata.

Editat Aprilie 29, 2020 de Gilbert Sparios

[UDAR]

Clar IRF540 va cere mai multă putere de comandă decât IRF520 iar IR2104 nu este foarte potent . Poți pune IR2110 sau altele similare , nu stau acum să recalculez schema . Dacă frecvența nu e prea mare s-ar putea să meargă și așa. Nu știu să citesc din codul ăla frecvența PWM .

[Gilbert Sparios]

e setat la 50kHz frecventa cu dutty variabil. nu e asa mare.

[UDAR]

M-ai păcălit cu modificarea și n-am fost atent . Semnalele din controler nu sunt Hi si LO ci IN si SD . Deci cu atat mai mult nu poti renunta la IR2104 . 

[Gilbert Sparios]

de fapt din controler pe pinul 8 & 9 iasa 0/1 logic. chiar daca pwm. nu face citiri..

oricum, nu mai ma avant sa modific schema, o las cum este, eventual incerc sa schimb IR2104 cu ceva mai potent, pentru ca sa am putere mai mare.

cred ca actual e calculat la vreo 3-4A iar eu vreau vreo 8A. 

 

daca nu cer prea mult..as vrea sa inteleg ce face IR21XX acolo..ridica tensiunea pentru comanda.. ? 

 

Editat Aprilie 30, 2020 de Gilbert Sparios

[Bandi Szasz]

Este o idee pentru experimente insa nu o sa ajungi departe, m-am chinuit eu cateva saptamani bune cu ceva similar si sunt multe probleme. In primul rand acel convertor buck nu va functiona din mai multe motive: mosfet-ul de sus vede pe Source tensiunea acumulatorului cand este inchis iar cand se deschide apare tensiunea panoului si este greu de controlat, apoi pentru ca IR21xx sa functioneze cu pin-ul de bootstrap (VB) tensiunea pe iesire trebuie sa cada spre 0 in momentele de OFF la tine nu are cum sa cada ca ai bateria legata de +12V legata la iesire. Dupa care ajunge sa ai un moment in care sa ramana ambele mosfeturi deschide si face poc. 

 

Tipul de la care ai luat schema "Debasish Dutta" a avut alte doua modele V1, V2 de incarcator solar care aveau niste defecte de nu avea cum sa functioneze schema aia... a primit de la mine cateva sfaturi pe instructables si vad ca acuma a iesit cu V3 si tot nu a inteles ca convertorul ala buck nu are cum sa functioneze corect in schema aia. Acuma vad ca a adaugat si o dioda pe iesire inainte de baterie, inainte nu era si se plangea lumea ca face poc mosfetul de jos.. ca era deschis prea mult si face scurt intre acumulator si masa.

 

Eu am ajuns la concluzia ca MPPT in regim DIY nu este usor si o sa ajungi la niste performante mediocre mult sub un amarat pe PWM. Daca vrei sa faci o treaba cauta-l pe "Julian Ilett" pe youtube are cateva video-uri bune si explica cum sunt comutate acele mosfeturi in incarcatoarele solare. Are si el un incarcator solar  PWM, se chema PWM5 parca si explica foarte bine cum functioneaza si cum a ajuns la acel circuit, este corect facut si merge... te poti inspira de la el, nu iti mai pierde timpul cu Debasish ca tipul e paralel cu electronica.

Editat Aprilie 30, 2020 de Bandi Szasz

[UDAR]

Da, acest gen de drivere (IR21xx dar și altele ) fac două funcții : prima , esențială - o translație de nivel astfel încât dacă tu îi aplici 5V față de masă el aplică 5-10V față de sursa MOSFET-ului de sus , indiferent de potențialul la care s-ar afla aceasta ( între niște limite desigur ) . Apoi , atât pentru MOS-ul de sus cât și pentru cel de jos se asigură o ”amplificare” de curent astfel încât aceștia să fie comandați corespunzător respectiv să comute suficient de rapid. 

Atenție , schemele logice ale driverelor pot fi diferite - unele au intrări separate pentru SUS și JOS, altele au o singură intrare care se aplică direct SUS și inversat JOS , etc. De asemenea capabilitățile de curent sunt diverse. 

 

Altfel, da IRF520 e cam la limita de jos pentru 8A . Există tranzistoare mai moderne decât seria IRF5xx care să asigure curentul necesar și să fie și ușor de comandat dar nu cred că stă cineva să reproiecteze o schemă ( căci asta înseamnă această ”mică” modificare) doar ca să puște cu ce ai tu prin sertare . Deci , cum ți-am sugerat, pune IRF540 dacă tot le ai și cu IR2110 - atenție la modificările de logică !

Sau altfel .....

[Gilbert Sparios]

Acum 1 oră, Bandi Szasz a spus:

cauta-l pe "Julian Ilett" pe youtube are cateva video-uri bune si explica cum sunt comutate acele mosfeturi in incarcatoarele solare. Are si el un incarcator solar  PWM, se chema PWM5 parca si explica foarte bine cum functioneaza si cum a ajuns la acel circuit, este corect facut si merge... te poti inspira de la el, nu iti mai pierde timpul cu Debasish ca tipul e paralel cu electronica.

 

cica aceasta schema ar fi facuta de Julian Ilett.

spune-mi te rog, diferentele care apar in schema, crezi ca ar face diferenta ?..

 

 

tot ma invart pe aici sa gasesc ceva testat...dar cu PWM...mi-a intrat in cap ca se pierde mult curent in pauzele PWM-ului. Ma rog..

 

 

L.E: pana la urma cred ca o smecherie de-asta Buck-Boost face mai mult decat toate incercarile. 

Editat Aprilie 30, 2020 de Gilbert Sparios

[Bandi Szasz]

Nu pot sa iti 100% pentru ca nu prea m-am jucat foarte mult cu convertoare buck DIY, insa cand ma jucam eu pe vremea respectiva am cam inteles ca cu schemele astea sunt 2 probleme:

 

  Primul este driver-ul in sine, ca sa deschida mosfet-ul de sus trebuie sa ridice tensiunea pe poarta cu x volti peste sursa, in mod normal asta se intampla cu ajutorul lui c4 asa zisul bootstrap (e un fell de charge pump) insa ca acest lucru sa se poata intampla pe durata de OFF pe pinul VS (asa zisul output) tensiunea trebuia sa scada cat mai mult spre 0, in scheme astea nu are cum pentru ca tu acolo legi terminalul pozitiv al bateriei si o sa ai in continu 12-14V si driverul nu va putea deschide calumea mosfetul si vei avea pierderi mari. 

  Dupa care urmeaza mosfet-ul de jos, daca ramane prea mult timp deschis si inductorul isi pierde tot campul magnetic acumulat el devine o sarma simpla si mosfet-ul de jos face scurt direct a terminalului pozitiv al bateriei si masa -> rip mosfet, trebuie definit stric cat timp poate acesta ramane deschis si sa te asiguri ca in nici un caz nu se va depasi acel timp care nu e chiar usor ca poate il apuca pe arduino nebunia si se blocheaza softul si cam atat iti trebuie sa zboara mosfetul.

 

  Cu cele PWM se pierde ceva dar nu chiar atat cat crezi tu, daca bateria este dimensionata corect poti tine PWM 100% sa incarci acumulatorul pentru ca panoul find o sursa de curent limitata in momentul in care acumulatorul va trage 10A si panoul este doar de 7A tensiunea pe panou o sa scada la tensiunea bateriei astfel tensiunea de iesire din panou va fi dictat de baterie. Cu PWM-ul intrii cand acumulatorul e incarcat si faci ori topping ori floating sa mentii pe el tensiunea de 13.7V  Problema cu PWM-ul este chiar asta ca tensiunea pe panou este dictata de acumulator si panoului nu ii prea place si isi pierde din eficienta, panoul depiteaza cel mai mult in punctul MMP (Maximum Power Point) care este undeva la 70% din tensiunea deschisa a panoului insa acesta variaza mult de conditiile meteo (cum apare o umbra pe panou fie si pe un coltisor asa se muta si acel MMP). Acuma ce fac acele MPPT -uri este sa se foloseasca de convertorul acela Buck pentru a mentine tensiunea de intrare (pe panou) fix in acel punct de MPP folosind diversi algoritmi si masuratori. Problema este ca chiar daca iti iese acel converter buck iti trebuie un algoritm solid pentru a gasi si urmarii acel punct de MPP astfel pierzi mai multa putere decat daca ai pune panoul direct la baterie cum fac incarcatoarele PWM...  Eu am panouri de 100W cu iesirea in scurt de 5.72 A, daca le leg direct la acumulatorul descarcat la 50% trag din ele  4.75 - 4.9A deci am o pierdere undeva de 15%. Cand experimentam cu MPPT-ul meu avea momente cand softul de urmarire o lua razna si imi tinea PWM-ul la valori foarte mici tragand abia 1A din panou... pai acolo e pierderea si da aia zic ca nu e usor de implementat MPPT DIY pentru ca in spate exista si un soft destul de complex daca chiar vrei sa obtii un avantaj mare fata de un banal PWM.

Editat Aprilie 30, 2020 de Bandi Szasz

[Gilbert Sparios]

multumesc pentru informatii. pana la urma cred ca voi face schema simpla a lui PWM5.

 

din soft PUMP1 & PUMP2 este un semnal PWM la 15kHz factor de umplere 45.88 respectiv 53.72.

pe intrarea pwm se aplica alt semnal PWM la 1.95kHz factor de umplere variabil 0 - 100 in functie de diferenta de tensiune in jurul unei tensiuni prestabilite (13.8)

 

sper sa fie ok schema pentru ca nu o prea inteleg. mai exact nu inteleg faza cu pompa.. 

 

Editat Aprilie 30, 2020 de Gilbert Sparios

[UDAR]

Dacă PUMP1 și PUMP2 sunt legate direct la microcontroler încerci pe răspunderea ta .