/*******************
Eens hij aan het algoritme begonnen is, gaat hij het blijven volhouden tot hij klaar is met laden tenzij de state aangepast wordt.
*******************/
int charge_NiMH(int socLoad){
int V_bat;
int sleepTime,sleepTime_fin;
init_V_max();
setCurrentCharger(C);
// Slaaptijd tussen opeenvolgende metingen, in milliseconden
sleepTime = 100;
sleepTime_fin =5000;
while (getLoadFactor()>0) {
setLEDS(getLoadFactor());
if (isAtChargeLimit(socLoad)) return 2;
V_bat=getVoltage();
if(V_max<V_bat){
V_max=V_bat;
}
if(V_bat<V_max*0.9975){
//hoe kan je controleren of dit 5 sec lang zo blijft (andere tijdsduur is ook goed, maar men stelt 5 sec voor)
usleep(sleepTime_fin*1000);
if(V_bat<V_max*0.9975){
return 1;
}
}
usleep(sleepTime*1000);
}
return 0;
}
/*********************
Hier gaan we de batterij ontladen.
**********************/
void dischargeAlgorthm(){
while(getLoadFactor() < 0 && getStateOfCharge() > (specs.volt_max_cell*specs.nr_of_cells)*MINMARGE){
setLEDS(-1*getLoadFactor());
// Stel de stroom in op 1 x C
current = 1*specs.capacity;
setCurrentCharger(-1*getLoadFactor());
usleep(3000000);//we slapen drie seconden
}
}
void I2C_EE_Upload(void)
{
int percentage;
uint8_t byte;
unsigned int LEDbackup;
int i;
LEDbackup=LEDbyte;
clear();
write('S');
write('e');
write('n');
write('d');
write('i');
write('n');
write('g');
for (i=CONFIGLENGTH;i<EEPROM_BYTES;i++)
{
if((i%100)==0){
setCursor(0,1);
percentage = (100*i)/(EEPROM_BYTES-CONFIGLENGTH);
writenumber(percentage);
// write('0'+(i/(EEPROM_BYTES-CONFIGLENGTH)*100)/100);
// write('0'+((i/(EEPROM_BYTES-CONFIGLENGTH)*100)/10)%10);
// write('0'+(i/(EEPROM_BYTES-CONFIGLENGTH)*100)%10);
write('%');
write(' ');
write(' ');}
LEDbyte = LEDGripple[(i/80)%10];
setLEDS();
I2C_EE_BufferRead(&byte, i, 1);
UART_send_byte(byte);
}
clear();
delay_ms(2000);
clear();
standby();
LEDbyte=LEDbackup;
setLEDS();
}
void I2C_EE_Erase(void)
{
int percentage;
unsigned int LEDbackup;
int i;
clear();
write('E');
write('R');
write('A');
write('S');
write('I');
write('N');
write('G');
for (i=CONFIGLENGTH;i<EEPROM_BYTES;i++)
{
I2C_EE_BufferWrite(blank, i, 1);
// I2C_EE_ByteWrite(blank, i);
if((i%100)==0){
setCursor(0,1);
percentage = (100*i)/(EEPROM_BYTES-CONFIGLENGTH);
writenumber(percentage);
write('%');
write(' ');
write(' ');}
LEDbyte = LEDRripple[(i/80)%10];
setLEDS();
}
clear();
complete();
delay_ms(2000);
clear();
standby();
LEDbyte=LEDbackup;
setLEDS();
}
//Main function (execution starts here after startup file)
int main(void)
{
int i;
int e;
uint16_t temperature;
init_GPIO_pins();
//Short delay during which we can communicate with MCU via debugger even if later user code causes error such as sleep state with no wakeup event that prevents debugger interface working
//THIS MUST COME BEFORE ALL USER CODE TO ENSURE CHIPS CAN BE REPROGRAMMED EVEN IF THEY GET STUCK IN A SLEEP STATE LATER
for (i = 0; i < 1000000; i++)
{
LED_on();
}
GPIO_Init_Mode(GPIOA,GPIO_Pin_0,GPIO_Mode_IN_FLOATING); //User button.
GPIO_Init_Mode(GPIOC,GPIO_Pin_11,GPIO_Mode_IN_FLOATING); //Accelerometer interrupt.
delay_init();
LED_off();
LCDINIT();
home();
clear();
display(); //Surely some of these can be commented out.
noCursor();
noBlink();
standby();
UART_init();
humidity_init();
ADC_init();
I2C_EEPROM();
I2C_ACCEL_INIT();
I2C_EE_LoadConfig();
logging_timer_init();
// I2C_EE_BufferWrite(Test_Buffer, EEPROM_WriteAddress1, 100);
//I2C_EE_BufferRead(buffer, 0, 100);
/*while(1){
if(LEDbyte==512){LEDbyte=1;}
else {LEDbyte=LEDbyte<<1;}
setLEDS();
setCursor(0,1);
temperature=getTemperature();
writenumber( temperature/100);
write('.');
writenumber((temperature/10)%10);
write(' ');
write(0xDF);
write('C');
setCursor(0,0);
writenumber(readhumidity(24)); //Needs real temperature
write(' ');
write('%');
write('R');
write('H');
delay_ms(50);
check_and_process_received_command();
}*/
//currentstate=UPLOADING;
while(1)
{
switch (currentstate){
case WAITING:
if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)) //Polling is probably ok here, since the loop will be very very fast.
{
currentstate=LOGGING;
clear();
write('S');
write('t');
write('a');
write('r');
write('t');
write('i');
write('n');
write('g');
delay_ms(2000);
clear();
I2C_EE_StartLog();
TIM4->CNT=0;
}
break;
case LOGGING:
if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)){currentstate=WAITING;I2C_EE_FinishLog();break;} //Polling is probably ok here, since the loop will be very very fast.
LEDbyte|= 1<<8;
setLEDS();
if (TIM_GetFlagStatus(TIM3, TIM_FLAG_Update) != RESET)
{
TIM_ClearFlag(TIM3, TIM_IT_Update);
temperature = getTemperature();
LogBuffer[0]=(temperature>>8)&0xFF;
LogBuffer[1]=temperature&0xFF;
LogBuffer[2]=readhumidity(LogBuffer[0]);
I2C_ACCEL_READ();
I2C_EE_Log(LogBuffer);
setCursor(0,1);
writenumber(temperature/100);
write('.');
writenumber(temperature%100);
write(' ');
write(0xDF);
write('C');
write(' ');
setCursor(0,0);
writenumber(25); //Needs real temperature
write(' ');
write('%');
write('R');
write('H');
write(' ');
LEDbyte&= ~(1<<8);
setLEDS();
}
break;
case UPLOADING:
currentstate=WAITING;
I2C_EE_Upload();
break;
case ERASING:
currentstate=WAITING;
I2C_EE_Erase();
break;
case STREAMING:
if (TIM_GetFlagStatus(TIM3, TIM_FLAG_Update) != RESET)
{
TIM_ClearFlag(TIM3, TIM_IT_Update);
temperature = getTemperature();
LogBuffer[0]=(temperature>>8)&0xFF;
LogBuffer[1]=temperature&0xFF;
LogBuffer[2]=readhumidity(LogBuffer[0]);
I2C_ACCEL_READ();
// I2C_EE_Log(LogBuffer);
for (e=0;i<ENTRYBYTES;i++)
{
UART_send_byte(LogBuffer[e]);
}
setCursor(0,1);
writenumber(temperature/100);
write('.');
writenumber(temperature%100);
write(' ');
write(0xDF);
write('C');
write(' ');
setCursor(0,0);
writenumber(25); //Needs real temperature
write(' ');
write('%');
write('R');
write('H');
write(' ');
LEDbyte&= ~(1<<8);
setLEDS();
}
break;
}
/*******************
Het oplaadalgoritme voor de lipo batterij zit hier geimplementeerd.
*******************/
int charge_LiPo(battery* spec, int socLoad){
// Definitie van variabelen
int k;
int voltage;
int current;
int sleepTime;
// Slaaptijd tussen opeenvolgende metingen, in milliseconden
sleepTime = 100;
// Initialisatie
k = 1;
// Eerste fase:
// Legt een constante stroom aan zolang de spanning onder de V_treshold blijft.
do {
setLEDS(getLoadFactor());
// Stopconditie
if (charging == 0||load<=0) return 0;
if (isAtChargeLimit(socLoad)) return 2;
// Meet huidige spanning
voltage = getVoltage();
// Stel de stroom in op 1 x C
current = 1*spec->capacity;
setCurrentCharger(current);
// Wacht enkele milliseconden vooraleer volgende meting uit te voeren.
usleep(sleepTime*1000);
} while (voltage < (spec->volt_max_cell*spec->nr_of_cells)*MARGE);
// Meet nu zowel stroom als spanning
voltage = getVoltage();
current = getCurrent();
// Tweede fase:
// Laat de stroom afnemen.
// Wacht totdat de spanning terug V_threshold is en herhaal
// Stroom neemt per iteratie 10% af
while (current > (1-MARGE)*spec->capacity) {
// Stopconditie
if (charging == 0||getLoadFactor()<=0) return 0;
if (isAtChargeLimit(socLoad)) return 2;
// Als spanning ongeveer V_threshold is, verlaag de stroom
if (voltage > (spec->volt_max_cell*spec->nr_of_cells)*MARGE) k++;
// Stel stroom in
current = spec->capacity*(1-(k/10));
setCurrentCharger(current);
// Meet de nieuwe spanning
voltage = getVoltage();
// Wacht enkele milliseconden tot volgende meting
usleep(sleepTime*1000);
}
// Opladen voltooid
return 1;
}
