File content as of revision 1:19d350e383e6:

#include "mbed.h"

LocalFileSystem local("local");                  //Flashdrive for config file
FILE *fp;                                        //Local Config File

#define USR_POWERDOWN    (0x104)                 //Power Down Mbed Interface (save 50% or 45 mA)

bool mosfet1_open  = true ;
bool mosfet1_close = false;

DigitalOut myled  (LED1);
DigitalOut myled1 (LED2);
DigitalOut myled2 (LED3);
DigitalOut myled3 (LED4);

DigitalOut purge  (p33);
DigitalOut pump   (p34);
DigitalOut mosfet1(p35);
DigitalOut mosfet2(p36);
DigitalIn  In1    (p30);
DigitalIn  In2    (p29);
DigitalIn  In3    (p28);
DigitalIn  In4    (p27);
AnalogIn   AI1    (p17);
AnalogIn   AI2    (p18);
AnalogIn   bz_in  (p19);
AnalogIn   cap_in (p20);


Serial pc(USBTX, USBRX);
Ticker PC_OUT_timer;
Ticker LED_timer;
Ticker PUMPE_timer;

Timer t;

float bz_off     =  16.0;    //Brennstoffzellen Spannung min. Laden beenden
float bz_on      =  17.0;    //Brennstoffzellen Spannung für Ladefreigabe)
float bz_max     =  18.0;    //Brennstoffzellen Spannung Abs. max.
float cap_max    =  13.0;    //CAP Spannung max. (Abschaltung)
float cap_min    =   9.0;    //CAP Spannung min. (Zelle an)
int  pwm_cycle   =    60;    //ms für PWM Period
int  pwm_lo      =    40;    //ms für PWM high
float purge_start=  60.0;    //s before starting purch
float purge_end  =  60.2;    //s after finishing purch
float boost_time =   0.2;    //s Pump runup with 100% Duty Cycle
int  boost       =    25;    //Number of PWM-Cycles for Pump runup boost
int  debug       =     1;    //Serial Output on (1)
float gate_on    =   3.5;    //Mosfet opt. Gate Drain [V]
float gate_off   =   2.8;    //Mosfet min. Gate Drain [V]
float sample     =     5;    //Serial Output Samples per Second
bool pump_on     = false;    //Pumpenzustand

float bz;
float cap;
unsigned int counter;


void load_cfg()
{
 char read[16][16];

 char  i = 0;
 char  j = 0;
 int   c = 0;
 float  temp;
 
 for (j = 0; j<16; j++)
  {
   for (i = 0; i<16; i++)
    {
     read[j][i] = '\0';
    }
  }
  
  i=0;
  j=0;
  
    fp = fopen("/local/power.cfg", "r");
    if ( fp != NULL )
     {
         while((c != EOF) && (c !=10))
          { 
           c = fgetc(fp);
           if (c == ';'){read[j][0] = i; i = 0; j++;} 
           else {i++; read[j][i] = c;}
          }
       fclose(fp);
      
       
       sscanf(&read[ 0][1], "%f", &temp); bz_on       = temp;
       sscanf(&read[ 1][1], "%f", &temp); bz_off      = temp;
       sscanf(&read[ 2][1], "%f", &temp); bz_max      = temp;
       sscanf(&read[ 3][1], "%f", &temp); cap_min     = temp;
       sscanf(&read[ 4][1], "%f", &temp); cap_max     = temp;
       sscanf(&read[ 5][1], "%f", &temp); gate_on     = temp;
       sscanf(&read[ 6][1], "%f", &temp); gate_off    = temp;
       sscanf(&read[ 7][1], "%f", &temp); purge_start = temp;
       sscanf(&read[ 8][1], "%f", &temp); purge_end   = temp;
       sscanf(&read[ 9][1], "%f", &temp); boost_time  = temp;
       sscanf(&read[10][1], "%f", &temp); pwm_cycle   = temp;
       sscanf(&read[11][1], "%f", &temp); pwm_lo      = temp;
       sscanf(&read[12][1], "%f", &temp); debug       = temp;
       sscanf(&read[13][1], "%f", &temp); sample      = temp;
       
        
       
       boost = (boost_time * 1000) / pwm_cycle;
       
    }
    
    pc.printf("\n\r");
    pc.printf("Brennstoffzellenregler V0.5 \n\r");
    pc.printf("___________________________ \n\r" );
    pc.printf("BZ  max   [V] : %4.1f \n\r",bz_max);
    pc.printf("BZ  on    [V] : %4.1f \n\r",bz_on);
    pc.printf("BZ  off   [V] : %4.1f \n\r",bz_off);
    pc.printf("CAP min   [V] : %4.1f \n\r",cap_min);
    pc.printf("CAP max   [V] : %4.1f \n\r",cap_max);
    pc.printf("Gate On   [V] : %4.1f \n\r",gate_on);
    pc.printf("Gate Off  [V] : %4.1f \n\r",gate_off);
    pc.printf("Purch on  [s] : %4.1f \n\r",purge_start);
    pc.printf("Purch off [s] : %4.1f \n\r",purge_end);
    pc.printf("Boost     [s] : %4.1f \n\r",boost_time);
    pc.printf("PWM cycle [ms]: %4d \n\r"  ,pwm_cycle);
    pc.printf("PWM lo    [ms]: %4d \n\r"  ,pwm_lo);
    pc.printf("Serial        : %4d \n\r"  ,debug);
    pc.printf("Sample    [Hz]: %4.0f \n\r",sample);
    pc.printf("___________________________ \n\r" );
    pc.printf("\n\r");
}

int semihost_powerdown() 
{
 uint32_t arg;
 return __semihost(USR_POWERDOWN, &arg); 
}

void SEND()
{
 mosfet1 = mosfet1_open;
 if (debug == 1) pc.printf("BZ: %4.1f/%4.1f-%4.1f+%4.1f CAP: %4.1f/%4.1f-%4.1f   Purge %4.1f/%4.1f-%4.1f\n\r"
          ,bz,bz_off,bz_on,bz_max,cap,cap_min,cap_max,float(counter)/(1000/pwm_cycle),purge_start,purge_end);
}


void LED()
{
  if (bz  < bz_off )            myled  = 1; else myled  = 0;                //LED = Spannung an der BZ IO
  if (cap > cap_min)            myled1 = 1; else myled1 = 0;                //LED = Spannung an den Cap´s IO 
  if (mosfet1 == mosfet1_close) myled2 = 1; else myled2 = 0;                //LED = Gate Zustand Mosfet 1
  if (pump == 1)                myled3 = 1; else myled3 = 0;                //LED = Pumpe an
}


void PUMPE()
{
 if (((cap <= cap_min) || (pump_on == true)) 
     && (bz < bz_max) && (cap < cap_max))                                   //Pumpe Einschaltbedingung
  {
   pump_on = true;
   if (t.read_ms() > pwm_lo)  pump = 1 ;                                    //Set PWM from low to high 
                                        
   if (t.read_ms() >= pwm_cycle)                                            //End PWM cycle
    {
     counter++;
     t.reset();         
     if (boost > 0) boost--;
     
     if ((counter < (1000 / pwm_cycle) * purge_start) || (boost <= 0) || (In1 == 0))  
      {   
       pump  = 0;                                                           //PWM Betrieb
       purge = 0;                                     
      }
     else
      {
       if (pump == 1) purge   = 1;                                          //Purge Betrieb
      }
             
     if (counter > (1000 / pwm_cycle) * purge_end)                          //Purge Ende 
      {
       counter = 0; 
       purge = 0; 
       pump = 0;
      }    
    }      
  }
 else
  {
   pump_on = 0; pump = 0; purge = 0;                                       //Pumpe aus
   boost = (boost_time * 1000) / pwm_cycle;                                // Boost für nächsten Start setzen
  }

}

int main() 
{
    
    int gate_pwm = 0;     
    pc.baud(115200);                                                     //config Serial Port
    load_cfg();                                                          //init config File
    semihost_powerdown();                                                //Mbed Interface powerdown
    PC_OUT_timer.attach(&SEND  , (1/sample));                            //Serial output Timer
    LED_timer.attach   (&LED   , 0.200     );                            //LED Status    Timer
    PUMPE_timer.attach (&PUMPE , 0.001     );                            //Pumpen PWM    Timer
    t.start();                                                           //Timer für PWM starten
    
    while(1) 
    {
     //bz  = ((bz_in  * 92.0) + bz )/3;                                             //BZ  RAW in Spannung umrechnen
     //cap = ((cap_in * 92.0) + cap)/3;                                             //CAP RAW in Spannung umrechnen
               
     if (((bz-cap) >= gate_on) && (bz > bz_on) && (In2 == 0))                     //Überspannung (> gate_on) oder Ladespannung der BZ in die Caps laden ***(cap > 13)
      {     
      // if (gate_pwm%2==0) mosfet1 = mosfet1_close;                                //Spule einkoppeln (mit PWM anteil für StepDown)
      //  else mosfet1 = mosfet1_close;                                             //Spule auskoppeln                                      
      mosfet1 = !mosfet1;
      }  
     
     if ((bz < bz_off) || ((bz-cap) < gate_off))                                  //Ladereglung Unterspannung Zelle / Gate-Mosfet
      {
       //mosfet1 = mosfet1_open;                                                    //Zelle trennen
       mosfet1 = !mosfet1;
      }
     
     if (gate_pwm > 99) gate_pwm = 0; else gate_pwm++; 
    }

}