Arduino laad ontlaad en meet inrichting

[Hanneman Profiel Privébericht]

volgens mij 4 en 5, 10 is ook in gebruik

[Hanneman Profiel Privébericht]

Alleen pin 10 denk ik, in de handleiding staat dat de analoge pin 4 en 5 nodig zijn voor de RTC. Vandaar dat er een spanning op staat

[nicoverduin Profiel PrivéberichtWebsite]

Volgens mij gebruikt de SD kaart SPI en dan zit je op pinnen 10,11,12 en 13. Tenzij je een andere library gebruikt waarbij SoftSPI worrdt toegepast en dat heb ik niet gezien. Dus ben je bezig SPI om zeep te helpen....

[Hanneman Profiel Privébericht]

Ah jah, dat is het denk ik idd, ff andere pinnen kiezen dan

[Hanneman Profiel Privébericht]

pin 12, naar pin 5 verhuisd en nu werkt het goed. Ik had

Code: Alles selecteren

 if (voltage < LAAD_DREMPEL) {
verwerkAccu(laden);
 
}
if (voltage > ONTLAAD_DREMPEL){
verwerkAccu(ontladen); 
}

niet in de loop zitten dus dat functioneerde niet :S hahaha hoe dom

[shooter Profiel Privébericht]

de beide drempel goed ver van elkaar afzetten want anders krijg je een mooie dimmer.

[Hanneman Profiel Privébericht]

AAARGGHH!!!

Ik dacht dat het lekker werkte nu, maar dat blijkt niet zo te zijn

Bij het ontladen gaat het prima,
maar bij het laden gaat de spanning omhoog, omlaag en vaak zelfs NUL.

HELP!

analogReference staat op INTERNAL
De gemiddeldes heb ik er voor het gemak even uit gelaten.

De opamp is volgens onderstaande schema's gemaakt. In plaats van een lm358 heb ik een lm2904 gebruikt, maar dat is ongeveer hetzelfde dacht ik.

en


het filmpie:
http://youtu.be/xJ1SEbzWkX8

en de code:

Code: Alles selecteren

// ============== LCD PART ================
// include the library code:
#include <LiquidCrystal.h>
// ============== LCD PART END ============

#include "Arduino.h"

#include <SPI.h>

#include "SD.h" //for the card
#include <Wire.h>
#include "RTClib.h" //for the clocktimer

// A simple data logger for the Arduino analog pins

// ========== !!!Important!!! ============
// how many milliseconds between grabbing data and logging it. 1000 ms is once a second
//#define LOG_INTERVAL 1800000 // mills between entries (reduce to take more/faster data)
#define LOG_INTERVAL  1000 //600000
// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to
// the last 10 reads if power is lost but it uses less power and is much faster!

//#define SYNC_INTERVAL 1800000 // mills between calls to flush() - to write data to the card
#define SYNC_INTERVAL    1000     //600000
uint32_t syncTime = 0; // time of last sync()
// ========== !!!Important!!! ============

#define ECHO_TO_SERIAL 1 // echo data to serial port 1=on 0=off
#define WAIT_TO_START 1 // Wait for serial input in setup()1=on 0=off (when on it needs you to send a caracter to serial port)
// the digital pins that connect to the LEDs
#define redLEDpin     2
#define greenLEDpin   3

// The analog pins that connect to the hardware that sends the voltages to Arduino
#define voltagereadPin 0          // analog 5 (A5)
#define currentDischargereadPin 1           // analog 1 (A1)
#define currentChargereadPin 2          // analog 3 (A3)
// Analog pins 4 and 5 are in use by the datalogging card, so they are unavailable for measuring

#define LADEN                  5

#define ONTLADENRODELED        8

#define LADENGROENELED         7

#define ONTLADEN               6

RTC_DS1307 RTC; // define the Real Time Clock object
         
// for the data logging shield, we use digital pin 10 for the SD cs line
const int chipSelect = 10;
     
// the logging file
File logfile;
     
void error(char *str)
{
Serial.print("error: ");
Serial.println(str);
// red LED indicates error
digitalWrite(redLEDpin, HIGH);
while(1);
}


// ============== Data logger shield PART END ===============

// ============== LCD PART ================
// #define LCD_CS 9 // The Enable/'latch' pin for the circuit.
LiquidCrystal lcd(9);
// ============== LCD PART END ============

#define AAN                   HIGH                // Hoog is aan bij relais

#define UIT                   LOW                 // Laag is uit bij relais

// ================== !!! Laad / ontlaad drempels !!! ===========================

#define LAAD_DREMPEL          0.70                // Als de spanning lager is dan deze waarde dan laden

#define ONTLAAD_DREMPEL       0.99               // Als de spanning hoger is dan deze waarde dan ontladen

// ================ *** Laad / ontlaad drempels einde ===========================


//

// global variables

//

unsigned int voltagereading;                         // gemeten analoge waarde

float voltage;                                    // analoge waarde naar spanning

unsigned int currentDischargereading;                         // gemeten analoge waarde

float currentDischarge;                                    // analoge waarde naar spanning

unsigned int currentChargereading;                         // gemeten analoge waarde

float currentCharge;                                    // analoge waarde naar spanning

// ==================== Schakelen Relais ====================

// Voor de werking van de relais
void verwerkAccu(uint8_t);

// Aanpassen naar een half uur!!!

#define VERTRAGING_ONTLADEN       1800 //000                // vertraging tussen schakelen relais

// Aanpassen naar een uur!!!!

#define VERTRAGING_VOL            3600 //000                // vertraging tussen schakelen relais

 
// ============ *** Schakelen Relais einde *** ==============

//

// enumeratie accu laad acties

//

enum {

      laden,

      ontladen,
     
      nietsdoen,

};

/**

* @name setup()

* initialiseren programma

*/

// ============== Laad / Ontlaad part END ===============
void setup(void)
{
analogReference(INTERNAL); // select internal 1.1 volt reference
Serial.begin(9600);
Serial.println();
lcd.print("Measuring System");


// use debugging LEDs

pinMode(redLEDpin, OUTPUT);

pinMode(greenLEDpin, OUTPUT);

      pinMode(LADEN     , OUTPUT);                 // pin 12 voor laden als uitgang instellen

      pinMode(ONTLADEN  , OUTPUT);                 // pin 6 voor ontladen als uitgang instellen

      pinMode(LADENGROENELED     , OUTPUT);                 // pin 7 voor laden als uitgang. Weergave door Blauwe LED instellen
     
      pinMode(ONTLADENRODELED  , OUTPUT);                   // pin 8 voor ontladen als uitgang. Weergave door Rode LED instellen
      //

      // noch laden noch ontladen

      //

     digitalWrite(LADEN     , UIT);
     digitalWrite(ONTLADEN  , UIT);
     digitalWrite(LADENGROENELED   , UIT);
     digitalWrite(ONTLADENRODELED  , UIT);
//

// SD Kaart

//

#if WAIT_TO_START
Serial.println("Type any character to start");
while (!Serial.available());
#endif //WAIT_TO_START

// initialize the SD card
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
error("Card failed, or not present");
}
Serial.println("card initialized.");

// create a new file
char filename[] = "ALUM1000.CSV"; // Logged filenames
for (uint8_t i = 0; i < 100; i++) {
filename[6] = i/10 + '0';
filename[7] = i%10 + '0';
if (! SD.exists(filename)) {
// only open a new file if it doesn't exist
logfile = SD.open(filename, FILE_WRITE);
break; // leave the loop!
}
}
if (! logfile) {
error("couldnt create file");
}
Serial.print("Logging to: ");
Serial.println(filename);
   
// connect to RTC
Wire.begin();
if (!RTC.begin()) {
logfile.println("RTC failed");
#if ECHO_TO_SERIAL
Serial.println("RTC failed");
#endif //ECHO_TO_SERIAL
}
     
logfile.println("uS,millis,Tijd,Spanning,Stroom");
#if ECHO_TO_SERIAL
Serial.println("uS,millis,Tijd,Spanning,Stroom");
#endif //ECHO_TO_SERIAL


// If you want to set the aref to something other than 5v
//analogReference(EXTERNAL);

// =========== LCD PART ======================== 
// set up the LCD's number of columns and rows:

lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("Volt  Disc  Char"); 

// ============LCD PART END ====================

}
void(* resetFunc) (void) = 0; //declare reset function @ address 0
void loop(void)
{
 
if (voltage < LAAD_DREMPEL) {
verwerkAccu(laden);
 
}
if (voltage > ONTLAAD_DREMPEL){
verwerkAccu(ontladen); 
}

// ============== Data logger shield PART ===============
DateTime now;
     
// delay for the amount of time we want between readings
delay((LOG_INTERVAL -1) - (millis() % LOG_INTERVAL));

digitalWrite(greenLEDpin, HIGH);
     
// log milliseconds since starting
uint32_t m = millis();
logfile.print(m); // milliseconds since start
logfile.print(", ");
#if ECHO_TO_SERIAL
Serial.print(m); // milliseconds since start
Serial.print(", ");
#endif
     
 // fetch the time
  now = RTC.now();
  // log time
  logfile.print(now.unixtime()); // seconds since 1/1/1970
  logfile.print(", ");
  logfile.print('"');
  logfile.print(now.year(), DEC);
  logfile.print("/");
  logfile.print(now.month(), DEC);
  logfile.print("/");
  logfile.print(now.day(), DEC);
  logfile.print(" ");
  logfile.print(now.hour(), DEC);
  logfile.print(":");
  logfile.print(now.minute(), DEC);
  logfile.print(":");
  logfile.print(now.second(), DEC);
  logfile.print('"');
#if ECHO_TO_SERIAL
  Serial.print(now.unixtime()); // seconds since 1/1/1970
  Serial.print(", ");
  Serial.print('"');
  Serial.print(now.year(), DEC);
  Serial.print("/");
  Serial.print(now.month(), DEC);
  Serial.print("/");
  Serial.print(now.day(), DEC);
  Serial.print(" ");
  Serial.print(now.hour(), DEC);
  Serial.print(":");
  Serial.print(now.minute(), DEC);
  Serial.print(":");
  Serial.print(now.second(), DEC);
  Serial.print('"');
#endif //ECHO_TO_SERIAL
// ============== Data logger shield PART END ===============

voltagereading = analogRead(voltagereadPin);
voltage  = (float)voltagereading * (1.1 / 1024.0);   

currentDischargereading = analogRead(currentDischargereadPin);
currentDischarge = (float)currentDischargereading * (1.1 / 1024.0);

currentChargereading = analogRead(currentChargereadPin);
currentCharge = (float)currentChargereading * (1.1 / 1024.0);


logfile.print(", ");
logfile.print(voltage);
logfile.print(", ");
logfile.print(currentDischarge);
logfile.print(", ");
logfile.print(currentCharge);
logfile.print(", ");
logfile.print(voltagereading);
logfile.print(", ");
logfile.print(currentDischargereading);
logfile.print(", ");
logfile.print(currentChargereading);
logfile.print(", ");
#if ECHO_TO_SERIAL
Serial.print(", ");
Serial.print(voltage);
Serial.print(", ");
Serial.print(currentDischarge);
Serial.print(", ");
Serial.print(currentCharge);
Serial.print(", ");
Serial.print(voltagereading);
Serial.print(", ");
Serial.print(currentDischargereading);
Serial.print(", ");
Serial.print(currentChargereading);
Serial.print(", ");

#endif //ECHO_TO_SERIAL

logfile.println();
#if ECHO_TO_SERIAL
Serial.println();
#endif // ECHO_TO_SERIAL

digitalWrite(greenLEDpin, LOW);

  // Now we write data to disk! Don't sync too often - requires 2048 bytes of I/O to SD card
  // which uses a bunch of power and takes time
  if ((millis() - syncTime) < SYNC_INTERVAL) return;
  syncTime = millis();
 
  // blink LED to show we are syncing data to the card & updating FAT!
  digitalWrite(redLEDpin, HIGH);
  logfile.flush();
  digitalWrite(redLEDpin, LOW);

// =========== LCD PART ========================
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// =========== LCD PART END========================
 
// print out the value you read:

lcd.print(voltage);
lcd.print("  ");
lcd.print(currentDischarge);
lcd.print("  ");
lcd.print(currentCharge);
// bool bl = true;
// for (uint8_t i = 0; i < 20; i++)
   //{
   //  bl = !bl;
   // lcd.enableBackLight(bl); // Enable Backlight
   // }

}

void verwerkAccu(uint8_t laadInstructie) {

      switch (laadInstructie) {

      case laden:
     
      //delay(1000);
      //delay(3600000);
     
            digitalWrite(ONTLADEN ,UIT);
            digitalWrite(ONTLADENRODELED ,UIT);
     
             delay(VERTRAGING_ONTLADEN);
             
             digitalWrite(LADEN         ,AAN);
             digitalWrite(LADENGROENELED         ,AAN);
         
             break;
             
      case ontladen:
     
     // delay(1000);
     
      //delay(3600000);
     
              digitalWrite(LADEN    ,UIT);
              digitalWrite(LADENGROENELED    ,UIT);
     
             delay(VERTRAGING_VOL);
                               
             digitalWrite(ONTLADEN ,AAN);
             digitalWrite(ONTLADENRODELED ,AAN);
                             
             break;
                         
      case nietsdoen:

            digitalWrite(ONTLADEN ,UIT);
            digitalWrite(ONTLADENRODELED ,UIT);
           
            digitalWrite(LADEN    ,UIT);
            digitalWrite(LADENGROENELED   ,UIT);
           
            break;
                             
      default:

             break;

      }
}

[nicoverduin Profiel PrivéberichtWebsite]

en heb je al eens gemeten op de uitgang van de opamp zelf? Of een simple programma die alleen meet met laden en alle andere rotzooi ff weglaten.

[Hanneman Profiel Privébericht]

De uitgang van de opamp komt goed uit de bus met de multimeter.

Ik zal mijn programma eens strippen en dan nog eens testen.

[nicoverduin Profiel PrivéberichtWebsite]

Als de opamp het goed doet, dan gewoon een simpel programmatje maken die ALLEEN die opamp meet. Gaat dat goed..... dan weet je het antwoord al.......