Case am 15. September 2014 um 19:56 Uhr

2014-09-15T19:56:38Z

Case am 15. September 2014 um 19:54 Uhr

2014-09-15T19:54:41Z

Case: Created page with "/* created on 08/04/2014 by Debasish Dutta/deba168 extended on 04.09.2014 by OS/case This code is in the public domain. If you modify please inform me ..."

2014-09-15T19:52:19Z

Created page with "/* created on 08/04/2014 by Debasish Dutta/deba168 extended on 04.09.2014 by OS/case This code is in the public domain. If you modify please inform me ..."

Neue Seite

/* created on 08/04/2014
by Debasish Dutta/deba168

extended on 04.09.2014 by OS/case

This code is in the public domain.
If you modify please inform me
send a modified copy which will be helpfull for me
*/

#include <LiquidCrystal.h>
/*
The LCD-Display circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
*/
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// LEDs
int RED=8; // To indicate discharged condition of battery
int GREEN=7; // Solar or Grid-Power on
int redflag = 0; // make red LED blink
int greenflag = 0; // make green LED blink

// Sampling
float solar_volt =0; // variable for solar panel voltage
float bat_volt=0; // variable for battery voltage
float bat_amp=0; // variable for battery voltage
float old_bat_amp;
float sample1=0; // reading from Arduino pin A0
float sample2=0; // reading from Arduino pin A1
float sample3=0; // reading from Arduino pin A2
int fenster = 100; // Fensterbreite f. gleitenden Durchschnitt
float gleiwin[100]; // gleitender Durchschnitt
//gleiwin = new float[fenster];

// Kalibrierwerte
float vsys = 0.0; // gemessene Systemspannung
float r1 = 0.0; // gemessener 1. Widerstand von Spannungsteiler VBat
float r2 = 0.0; // gemessener 2. Widerstand von Spannungsteiuler VBat
float rel = 0.0;
float onebit;
float rfaktor = 0; // Realitätsfaktor zum Abgleich mit meinem Multimeter

// Charging Values
//float vladeschluss = 6.4; // Max-Voltage per cell 3.2
//float vladeschluss = 6.6; // Max-Voltage per cell 3.3
//float vladeschluss = 7.2; // Max-Voltage per cell 3.6 ==> this defines the upper level if 100% use of cell capacity is wanted
float vladeschluss = 7.1; // Max-Voltage per cell 3.55 ==> this defines the upper level if about 95% use of cell capacity is wanted - its healthier

// float vladeschluss = 7.2; // Max-Voltage per cell 3.55 ==> this defines the upper level if about 95% use of cell capacity is wanted - its healthier

//float cc = 0.5; // constant current , current clamp for CC/CV-charging

float cc = 0.9; // constant current , current clamp for CC/CV-charging

int pwm=6; // pwm out put to mosfet
// float duty = 0.0; // duty cycle prozente
int duty = 0; // duty cycle prozente
int chargingflag = 0;

// Discharging Values
float ventladeschluss = 5.6; // Min-Voltage per cell 2.8 ==> Depth of Discharge (DOD) about 80%
int load=9; //load is connected to pin-9

// Floating Values
// float vfloating_min = 6.8; // In floating-mode discharge until 3.45V per cell then start charging again ==> Hysteresis
float vfloating_min = 6.9; // In floating-mode discharge until 3.45V per cell then start charging again ==> Hysteresis
float cv = vladeschluss; // default value for charging, choose a smaller value for more battery-health
int floatingflag = 0;

// Evaluation
unsigned long timestamp;
int charged_percent =0;
int i = 0;

void setup()
{

TCCR0B = TCCR0B & 0b11111000 | 0x05; // setting prescaar for 61.03Hz pwm
Serial.begin(9600);
pinMode(pwm,OUTPUT);
//pinMode(load,OUTPUT);
pinMode(RED,OUTPUT);
pinMode(GREEN,OUTPUT);

digitalWrite(pwm,LOW);
//digitalWrite(load,LOW);
digitalWrite(RED,LOW);
digitalWrite(GREEN,LOW);

lcd.begin(16, 2); // columns, rows. size of display
lcd.clear(); // clear the screen
/*
lcd.print("Solar-Charger");
lcd.setCursor(0, 1);
lcd.print("V.0.17, by OS 2014");
delay(10);
lcd.clear();
*/

// duty = 50;

}

// void loop_disabled()
void loop()
{
lcd.setCursor(16,1); // set the cursor outside the display count
lcd.print(" "); // print empty character
timestamp = millis();

/////////////////////////// VOLTAGE SENSING ////////////////////////////////////////////
int zaehler = 10;

for(int i=0;i<zaehler;i++)
{
sample1+=analogRead(A1); //read the input voltage from solar panel
sample2+=analogRead(A2); //read the battery voltage
sample3+=analogRead(A0); //read the battery amperage
delay(4);
}
sample1=sample1/zaehler;
sample2=sample2/zaehler;
sample3=sample3/zaehler;

delay(1);

// Kalibrierung
// vsys = 4.200; // gemessene Spannung am Arduino, versorgt durch PC
// rfaktor = 1.1122; // rfaktor bei PC-Versorgung
vsys = 5.003; // gemessene Spannung am BuckBoost-Converter ==> Arduino-5V-Pin (Achtung nicht Vin nehmen, da linearregler >= 7V verlangt !!!)
rfaktor = 1;
// rfaktor = 0.98; // Anpassung an zweites Multimeter
// vsys = 3.95; // gemessene Spannung am Arduino, versorgt durch Batterie mit BuckBoost-Converter
//// rfaktor = 1.10396; // rfaktor bei buckbooster-Betrieb
// rfaktor = 1.106; // rfaktor gemittelt aus PC- und Buckbooster-Betrieb

r1 = 9.96; // gemessener R1 von Spannungsteiler Batterie
r2 = 4.67; // gemessener R2 von Spannungsteiler Batterie

rel = (r1+r2)/r2; // Verhältniss R2 zu R1
onebit = vsys/1023; // 1 Bit entspricht rund 4.89mV (=5.02V / 1024 Bit)

// Spannungsteiler Batterie
bat_volt = sample2*onebit; // tatsächlich durch ADC gemessene VBat - uninterpretiert
bat_volt = bat_volt/rfaktor; // Realitätsfaktor gegenüber Multimetermessung: 1.1122
bat_volt = bat_volt * rel; // umgerechnet in Gesamtvolt

// Spnnungsteiler ExternalInput (z.B. Solar, oder Netzteil)
solar_volt = sample1*onebit; // tatsächlich durch ADC gemessene VBat - uninterpretiert
solar_volt = solar_volt/rfaktor; // Realitätsfaktor gegenüber Multimetermessung: 1.1122
solar_volt = solar_volt * rel; // umgerechnet in Gesamtvolt

/////////////////////////// AMPERAGE SENSING ////////////////////////////////////////////
// Amperemessung Batterie, mittels ACS714
//// sample3 = sample3+36;
//sample3 = sample3+30;
bat_amp = map(sample3, 102, 921, -300, 300)/10.00;
//bat_amp = bat_amp * 0.5; // Anpassung an mein Multimeter Alternative: Amp-Wert ca 1000 mal messen und mitteln, nähert sich dadurch meinem Multimeter an
// bat_amp = bat_amp * 0.76; // Anpassung an mein Multimeter Alternative: Amp-Wert ca 1000 mal messen und mitteln, nähert sich dadurch meinem Multimeter an

double Current = currentSensor(analogRead(0)); // Read analog value
// printDouble(Current, 2);
bat_amp = (float) Current;

// Glättung
/*
old_bat_amp = 0;
for(i=1; i<(fenster-1); i++)
{
gleiwin[i-1] = gleiwin[i];
old_bat_amp = old_bat_amp + gleiwin[i];
}
gleiwin[fenster-1] = bat_amp;
old_bat_amp = old_bat_amp + bat_amp;
bat_amp = old_bat_amp / fenster;
*/
//bat_amp = bat_amp -0.9;
bat_amp = bat_amp +2.9;
bat_amp = bat_amp / 3;

// bat_amp = bat_amp +0.03;
// bat_amp = bat_amp * fenster;

// old_bat_amp = bat_amp + old_bat_amp;
// old_bat_amp = old_bat_amp / 2;

/////////////////////////// DATA OUTPUT ////////////////////////////////////////////
lcd.setCursor(0,0); // set the cursor at 1st col and 1st row
lcd.print("Vs:");
lcd.print(solar_volt);

lcd.setCursor(8,0); // set the cursor at 8st col and 1st row
lcd.print("Vb:");
lcd.print(bat_volt);
//lcd.print(rel);
//lcd.print(sample2);

lcd.setCursor(8,1); // set the cursor at 8st col and 2nd row
lcd.print("Ab: ");
lcd.setCursor(11,1); // set the cursor at 8st col and 2nd row
lcd.print(bat_amp);

lcd.setCursor(0,1); // set the cursor at 8st col and 2nd row
lcd.print("Du: ");
lcd.setCursor(3,1); // set the cursor at 8st col and 2nd row
// lcd.print(duty);
lcd.print(sample3);

Serial.print(bat_volt);
Serial.print(",");
Serial.print(bat_amp);
Serial.print(",");
Serial.print(solar_volt);
Serial.print(",");
Serial.print(chargingflag);
Serial.print(",");
Serial.println(duty);
// Serial.print(",");
// Serial.println(timestamp);

/////////////////////////// State machine ////////////////////////////////////////////////

/*
if((solar_volt > bat_volt) && (bat_volt > 0)) // external voltage input and battery are connected
{
duty = cc / 0.0172; // empirisch gemessen

analogWrite(pwm,2.55 * duty); // float charging

}
else duty = 0;
*/

if((solar_volt > bat_volt) && (bat_volt > 0)) // external voltage input and battery are connected
{
//********* Charge ************************
// duty = 30;

// duty = 25;

if(bat_volt < vladeschluss) // Charging in CurrentClamp-mode (CC)
{
if(chargingflag == 0) // OFF mode
{
if(bat_volt > vfloating_min) chargingflag = 0; // between 3.55 and 3.45 stay off, in floating-mode
else chargingflag = 1; // below 3.45 restart charging, in floating-mode
}
else // chargingflag != 0
{
if(chargingflag == 1)
{
//Serial.print("CC-Charging: ");
duty = cc / 0.0172; // 0.0172 empirisch gemessene charging-rate pro 1% duty
// if(bat_amp > cc && duty > 0) duty = duty-1;
// if(bat_amp == cc) duty = duty; // do nothing
// if(bat_amp < cc && duty < 100) duty = duty+1;
analogWrite(pwm,2.55 * duty); // float charging
}
}
}

if(bat_volt >= vladeschluss) // Charging in VoltageClamp-mode (CV)
{
if(bat_amp > cc/10) // Charging in VoltageClamp-mode (CV)
{
//Serial.print("CV-Charging: ");
if(bat_volt > cv && duty > 0) duty = duty-1;
if(bat_volt == cv) duty = duty; // do nothing
if(bat_volt < cv && duty < 100) duty = duty+1;
analogWrite(pwm,2.55 * duty); // float charging
chargingflag = 2;
}
else // (bat_amp <= cc/10)) // shut down when battery is fully charged
{
// Serial.println("Discharging: ");
duty = 0;
analogWrite(pwm,duty); // stop charging
chargingflag = 0;
}
}

} // endif solar_volt > bat_volt
else // solar_volt <= bat_volt // No external voltage input or no battery is connected
{
// Stop charging anyway
duty = 0;
analogWrite(pwm,0);
chargingflag = 0;

//********************* Discharge **********************
//Serial.print("DisCharging: ");
// Low voltage protection for the Battery
if( bat_volt <= ventladeschluss )
{
chargingflag = 1;

// Verbraucher abklemmen

// Arduino shutdown (or go sleep ?)
}

} // end else

delay(4);

//////////////////////////////LED INDICATION ////////////////////////////////////////

//Red LED will glow when any Solar-Power comes in
if(solar_volt > 0) {
digitalWrite(RED,HIGH);
}
else
{
digitalWrite(RED,LOW);
}

//Green LED will glow when a battery is connected
if(bat_volt > 0) {
digitalWrite(GREEN,HIGH);
}
else
{
digitalWrite(GREEN,LOW);
}

/*
// external voltage is there, but to weak for charging.
if(solar_volt <= bat_volt)
{

digitalWrite(RED,HIGH);
}
*/

if (chargingflag == 1)
{
// Red LED will blink continiously indicating charging is going on
if(redflag == 0)
{
digitalWrite(RED,HIGH);
redflag = 1;
}
else
{
digitalWrite(RED,LOW);
redflag = 0;
}
delay(5);
}

if (chargingflag == 2)
{
// Green LED will blink continiously indicating charging is going on
if(greenflag == 0)
{
digitalWrite(GREEN,HIGH);
greenflag = 1;
}
else
{
digitalWrite(GREEN,LOW);
greenflag = 0;
}
delay(5);
}

} // end loop()

//======================================================================

void test_loop(){

double Current = currentSensor(analogRead(0)); // Read analog value

Serial.print(", VariationFromNull: ");
printDouble(Current, 2); // display Current
Serial.print(" A");
Serial.println("");

delay(1000);

}

// --------------------------------------------------------------------------------------------------------

// Print decimal numbers

void printDouble(double val, byte precision) {

Serial.print (int(val)); // Print int part

if( precision > 0) { // Print decimal part
Serial.print(".");
unsigned long frac, mult = 1;
byte padding = precision -1;
while(precision--) mult *=10;
if(val >= 0) frac = (val - int(val)) * mult; else frac = (int(val) - val) * mult;
unsigned long frac1 = frac;
while(frac1 /= 10) padding--;
while(padding--) Serial.print("0");
Serial.print(frac,DEC) ;
}

}

// Read 1.1V reference against AVcc

long readInternalVcc() {

long result;
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Convert
while (bit_is_set(ADCSRA,ADSC));
result = ADCL;
result |= ADCH<<8;
result = 1126400L / result; // Back-calculate AVcc in mV
return result;

}

// Calculate current with Allegro ACS714

double currentSensor(int RawADC) {

int Sensitivity = 66; // mV/A

long InternalVcc = readInternalVcc();
double ZeroCurrentVcc = InternalVcc / 2;
double SensedVoltage = (RawADC * InternalVcc) / 1024;
double Difference = SensedVoltage - ZeroCurrentVcc;
double SensedCurrent = Difference / Sensitivity;

//Serial.print("ADC: ");
//Serial.print(RawADC);
//Serial.print("/1024");

//Serial.print(", Sensed Voltage: ");
//printDouble(SensedVoltage, 1);
//Serial.print("mV");

//Serial.print(", 0A at: ");
// printDouble(ZeroCurrentVcc, 1);
//Serial.print("mV");

return SensedCurrent; // Return the Current

}

@@ Zeile 1: / Zeile 1: @@
-/* created on 08/04/2014
+<source lang="java">
     by Debasish Dutta/deba168
@@ Zeile 494: / Zeile 496: @@
+}

@@ Zeile 1: / Zeile 1: @@
 <source lang="java">
@@ Zeile 116: / Zeile 118: @@
    lcd.print("Solar-Charger");
    lcd.setCursor(0, 1);
-   lcd.print("V.0.17, by OS 2014");
+   lcd.print("V.0.24, by OS 2014");
    delay(10);
    lcd.clear();

Solarbox Powerbank Firmware V0.24 - Versionsgeschichte

Case am 15. September 2014 um 19:56 Uhr

Case am 15. September 2014 um 19:54 Uhr

Case: Created page with "/* created on 08/04/2014 by Debasish Dutta/deba168 extended on 04.09.2014 by OS/case This code is in the public domain. If you modify please inform me ..."