Projekt Datenlogger 32 Batterien

International Deutsch
1

Hallo,
ich Programiere zur Zeit au8f den Arduino Mega ein Projekt für das Loggen 32 Batterien a12V die in Reihe geschalten sind.
Hardware mäßig kommt an den Arduino zwei Relaisschealds mit 12V Relais zum Einsatz.
Es wird nur immer eine Batterie abgefragt. Da ich die Max Spannung von Batt 1 zu 32 450V (im Lademodus) vermeiden möchte.
Ablauf im Arduino:
Relais 1 zieht an Spannung wird Abgefragt und im String gespeichert. Relais 1 aus Relais 2 an und die Spannung abfragen ind den selben String mit dazu schreiben usw. bis alle 32 Batterien gemessen wurden.
Dann gesammten String auf eine SD_karte schreiben.
Nach einer gewisser Zeit 8 Minuten oder auch länger das ganze wieder Messen und in die SD-Karte mit anhängen.
Als Sicherheit frage ich die Spannung am Eingang ab das nicht 2 Batterien gleichzeitig gemessen werden. Es gibt an den Aschlusseingang auch nochmals Feinsicherungen dass im Fehlerfalle kein Überstrom entstehen kann.
Der Spannungsteilöer ist Vorgefertigt kann von 0-50V Spannung einlesen und an den Arduino senden.
In der Späteren Programierung soll noch ein Drehencoder mit Taster drann um die Abfrage zeit zu deffienieren.
Meine Frage ist ob der Code so in den Anfängen Passt oder ob da schon gravierende Fehler sind?
Zu Unübersichtlich oder teile können zusammen gefasst weden.
Danke Euch schon einmal für die Menungen und Anregungen.

#include <SPI.h>

#include <SD.h>

#include <LiquidCrystal.h>

#include <TimeLib.h>   // second , minute , hour , day , year

int counter_time;




const int chipSelect = 4;

float ratio = 3.6;  // Calculated from Vin / Vout

//Relaisausgänge deffinieren:
int Relais_1 = 22, Relais_2 = 23, Relais_3 = 24, Relais_4 = 25, Relais_5 = 26, Relais_6 = 27, Relais_7 = 28, Relais_8 = 29, Relais_9 = 30, 
Relais_10 = 31, Relais_11 = 32, Relais_12 = 33, Relais_13 = 34, Relais_14 = 35, Relais_15 = 36, Relais_16 = 37, Relais_17 = 38, Relais_18 = 39, Relais_19 = 40,
Relais_20 = 41, Relais_21 = 42, Relais_22 = 43, Relais_23 = 44, Relais_24 = 45, Relais_25 = 46, Relais_26 = 47, Relais_27 = 48, Relais_28 = 49, 
Relais_29 = 62, Relais_30 = 63, Relais_31 = 64, Relais_32 = 65, Relais_33 = 66, Relais_34 = 67, Relais_35 = 68, Relais_36 = 69;

//Spannungseingang Batterie deffinieren:
float Spannung_1 = A7;
int Spannung_11;

// Referenzspannung am Arduino auslesen:
long readVcc() {
  // Read 1.1V reference against AVcc
  // set the reference to Vcc and the measurement to the internal 1.1V reference
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
     ADMUX = _BV(MUX5) | _BV(MUX0) ;
  #else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #endif  
 
  delay(2);                       // Wait for Vref to settle
  ADCSRA |= _BV(ADSC);            // Start conversion
  while (bit_is_set(ADCSRA,ADSC)); // measuring
 
  uint8_t low  = ADCL;            // must read ADCL first - it then locks ADCH  
  uint8_t high = ADCH;            // unlocks both
 
  long result = (high<<8) | low;
 
  result = 1125300L / result;     // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
  return result;                  // Vcc in millivolts
}




void setup() {
  Serial.begin(9600);
  // Achtung wird nur einmalig ausgeführt als Grund deklaration:
//Relais deklarieren:
pinMode(Relais_1, OUTPUT); pinMode(Relais_2, OUTPUT); pinMode(Relais_3, OUTPUT); pinMode(Relais_4, OUTPUT); pinMode(Relais_5, OUTPUT); pinMode(Relais_6, OUTPUT);
pinMode(Relais_7, OUTPUT); pinMode(Relais_8, OUTPUT); pinMode(Relais_9, OUTPUT); pinMode(Relais_10, OUTPUT); pinMode(Relais_11, OUTPUT); pinMode(Relais_12, OUTPUT);
pinMode(Relais_13, OUTPUT); pinMode(Relais_14,OUTPUT); pinMode(Relais_15, OUTPUT); pinMode(Relais_16, OUTPUT); pinMode(Relais_17, OUTPUT); pinMode(Relais_18, OUTPUT);
pinMode(Relais_19, OUTPUT); pinMode(Relais_20, OUTPUT); pinMode(Relais_21, OUTPUT); pinMode(Relais_22, OUTPUT); pinMode(Relais_23, OUTPUT); pinMode(Relais_24, OUTPUT); 
pinMode(Relais_25, OUTPUT); pinMode(Relais_26, OUTPUT); pinMode(Relais_27, OUTPUT); pinMode(Relais_28, OUTPUT); pinMode(Relais_29, OUTPUT); pinMode(Relais_30, OUTPUT); 
pinMode(Relais_31, OUTPUT); pinMode(Relais_32, OUTPUT); pinMode(Relais_33, OUTPUT); pinMode(Relais_34, OUTPUT); pinMode(Relais_35, OUTPUT); pinMode(Relais_36, OUTPUT); 

//alle Relais auf low setzen:
digitalWrite(Relais_1, LOW);digitalWrite(Relais_2, LOW);digitalWrite(Relais_3, LOW);digitalWrite(Relais_4, LOW);digitalWrite(Relais_5, LOW);digitalWrite(Relais_6, LOW);
digitalWrite(Relais_7, LOW);digitalWrite(Relais_8, LOW);digitalWrite(Relais_9, LOW);digitalWrite(Relais_10, LOW);digitalWrite(Relais_11, LOW);digitalWrite(Relais_12, LOW);
digitalWrite(Relais_13, LOW);digitalWrite(Relais_14, LOW);digitalWrite(Relais_15, LOW);digitalWrite(Relais_16, LOW);digitalWrite(Relais_17, LOW);digitalWrite(Relais_18, LOW);
digitalWrite(Relais_19, LOW);digitalWrite(Relais_20, LOW);digitalWrite(Relais_21, LOW);digitalWrite(Relais_22, LOW);digitalWrite(Relais_23, LOW);digitalWrite(Relais_24, LOW);
digitalWrite(Relais_25, LOW);digitalWrite(Relais_26, LOW);digitalWrite(Relais_27, LOW);digitalWrite(Relais_28, LOW);digitalWrite(Relais_29, LOW);digitalWrite(Relais_30, LOW);
digitalWrite(Relais_31, LOW);digitalWrite(Relais_32, LOW);digitalWrite(Relais_33, LOW);digitalWrite(Relais_34, LOW);digitalWrite(Relais_35, LOW);digitalWrite(Relais_36, LOW);



pinMode(Spannung_1, INPUT);

// Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial){
    ; // wait for serial port to connect. Needed for native USB port only
  }
Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");
}


void loop() {
  // put your main code here, to run repeatedly:

float  B1PV=0.0; float  B2PV=0.0; float  B3PV=0.0; float  B4PV=0.0;float  B5PV=0.0; float  B6PV=0.0; float  B7PV=0.0; float  B8PV=0.0;float  B9PV=0.0; float  B10PV=0.0; float  B11PV=0.0; float  B12PV=0.0;
float  B13PV=0.0; float  B14PV=0.0; float  B15PV=0.0; float  B16PV=0.0;float  B17PV=0.0; float  B18PV=0.0; float  B19PV=0.0; float  B20PV=0.0;float  B21PV=0.0; float  B22PV=0.0; float  B23PV=0.0; 
float  B24PV=0.0; float  B25PV=0.0; float  B26PV=0.0; float  B27PV=0.0; float  B28PV=0.0;float  B29PV=0.0; float  B30PV=0.0; float  B31PV=0.0; float  B32PV=0.0;float  B33PV=0.0; float  B34PV=0.0;

float RealB1V=0; float RealB2V=0; float RealB3V=0; float RealB4V=0;float RealB5V=0; float RealB6V=0; float RealB7V=0; float RealB8V=0;float RealB9V=0; float RealB10V=0; float RealB11V=0; float RealB12V=0;
float RealB13V=0; float RealB14V=0; float RealB15V=0; float RealB16V=0;float RealB17V=0; float RealB18V=0; float RealB19V=0; float RealB20V=0;float RealB21V=0; float RealB22V=0; float RealB23V=0; 
float RealB24V=0;float  RealB25V=0; float RealB26V=0; float RealB27V=0;float RealB28V=0; float RealB29V=0; float RealB30V=0; float RealB31V=0;float RealB32V=0; float RealB33V=0; float RealB34V=0;

//Datenaufnahme Sd-Karte
 String dataString = "";
 
// Zeitschleife begin
if ((counter_time != minute()) && (minute() % 8 == 0) ){  
    counter_time = minute(); 
   // Serial.println(counter_time);
  




// Begin Batterie 1
//Spannungseingang auf 0V Abfragen da sonst Überspannung!!!
  Spannung_11=analogRead (Spannung_1);
  if ( Spannung_11 << 1) {
    //Battarie 1 abfragen:
  float vccValue=readVcc()/1000.0;        //Arduino Spannung am Board
                                            

                digitalWrite(Relais_1,HIGH);              //Relais einschalten
                delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
                B1PV = analogRead(Spannung_1);         // Spannung einlesen
                RealB1V= (B1PV * vccValue/1024) * ratio;
                digitalWrite(Relais_1,LOW);              //Relais ausschalten
                delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen
                
                } else {                   
                  
digitalWrite(Relais_1, LOW);digitalWrite(Relais_2, LOW);digitalWrite(Relais_3, LOW);digitalWrite(Relais_4, LOW);digitalWrite(Relais_5, LOW);digitalWrite(Relais_6, LOW);
digitalWrite(Relais_7, LOW);digitalWrite(Relais_8, LOW);digitalWrite(Relais_9, LOW);digitalWrite(Relais_10, LOW);digitalWrite(Relais_11, LOW);digitalWrite(Relais_12, LOW);
digitalWrite(Relais_13, LOW);digitalWrite(Relais_14, LOW);digitalWrite(Relais_15, LOW);digitalWrite(Relais_16, LOW);digitalWrite(Relais_17, LOW);digitalWrite(Relais_18, LOW);
digitalWrite(Relais_19, LOW);digitalWrite(Relais_20, LOW);digitalWrite(Relais_21, LOW);digitalWrite(Relais_22, LOW);digitalWrite(Relais_23, LOW);digitalWrite(Relais_24, LOW);
digitalWrite(Relais_25, LOW);digitalWrite(Relais_26, LOW);digitalWrite(Relais_27, LOW);digitalWrite(Relais_28, LOW);digitalWrite(Relais_29, LOW);digitalWrite(Relais_30, LOW);
digitalWrite(Relais_31, LOW);digitalWrite(Relais_32, LOW);digitalWrite(Relais_33, LOW);digitalWrite(Relais_34, LOW);digitalWrite(Relais_35, LOW);digitalWrite(Relais_36, LOW);
 } // Ende Batterie 1

 // Begin Batterie 2
//Spannungseingang auf 0V Abfragen da sonst Überspannung!!!
  Spannung_11=analogRead (Spannung_1);
  if ( Spannung_11 << 1) {
    //Battarie 2 abfragen:
  float vccValue=readVcc()/1000.0;        //Arduino Spannung am Board
                                            

                digitalWrite(Relais_2,HIGH);              //Relais einschalten
                delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
                B1PV = analogRead(Spannung_1);         // Spannung einlesen
                RealB1V= (B1PV * vccValue/1024) * ratio;
                int sensor = int(RealB1V);                //Messwert in String schreiben für spätere Speicherung
                dataString += "Batterie 1 "; 
                dataString += String(sensor); 
                dataString += ";"; 
                digitalWrite(Relais_2,LOW);              //Relais ausschalten
                delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen
                Spannung_11=analogRead (Spannung_1);
                 if ( Spannung_11 << 1){
                                      
digitalWrite(Relais_1, LOW);digitalWrite(Relais_2, LOW);digitalWrite(Relais_3, LOW);digitalWrite(Relais_4, LOW);digitalWrite(Relais_5, LOW);digitalWrite(Relais_6, LOW);
digitalWrite(Relais_7, LOW);digitalWrite(Relais_8, LOW);digitalWrite(Relais_9, LOW);digitalWrite(Relais_10, LOW);digitalWrite(Relais_11, LOW);digitalWrite(Relais_12, LOW);
digitalWrite(Relais_13, LOW);digitalWrite(Relais_14, LOW);digitalWrite(Relais_15, LOW);digitalWrite(Relais_16, LOW);digitalWrite(Relais_17, LOW);digitalWrite(Relais_18, LOW);
digitalWrite(Relais_19, LOW);digitalWrite(Relais_20, LOW);digitalWrite(Relais_21, LOW);digitalWrite(Relais_22, LOW);digitalWrite(Relais_23, LOW);digitalWrite(Relais_24, LOW);
digitalWrite(Relais_25, LOW);digitalWrite(Relais_26, LOW);digitalWrite(Relais_27, LOW);digitalWrite(Relais_28, LOW);digitalWrite(Relais_29, LOW);digitalWrite(Relais_30, LOW);
digitalWrite(Relais_31, LOW);digitalWrite(Relais_32, LOW);digitalWrite(Relais_33, LOW);digitalWrite(Relais_34, LOW);digitalWrite(Relais_35, LOW);digitalWrite(Relais_36, LOW);
delay(800);  
 } } // Ende Batterie 2
 
// Begin Batterie 2
//Spannungseingang auf 0V Abfragen da sonst Überspannung!!!
  Spannung_11=analogRead (Spannung_1);
  if ( Spannung_11 << 1) {
    //Battarie 1 abfragen:
  float vccValue=readVcc()/1000.0;        //Arduino Spannung am Board
                                            

                digitalWrite(Relais_2,HIGH);              //Relais einschalten
                delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
                B1PV = analogRead(Spannung_1);         // Spannung einlesen
                RealB1V= (B1PV * vccValue/1024) * ratio;
                int sensor = int(RealB1V);                //Messwert in String schreiben für spätere Speicherung
               dataString += "Batterie 2 "; 
    dataString += String(sensor); 
               dataString += ";";
                digitalWrite(Relais_2,LOW);              //Relais ausschalten
                delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen
                Spannung_11=analogRead (Spannung_1);
               if ( Spannung_11 << 1){
                                      
digitalWrite(Relais_1, LOW);digitalWrite(Relais_2, LOW);digitalWrite(Relais_3, LOW);digitalWrite(Relais_4, LOW);digitalWrite(Relais_5, LOW);digitalWrite(Relais_6, LOW);
digitalWrite(Relais_7, LOW);digitalWrite(Relais_8, LOW);digitalWrite(Relais_9, LOW);digitalWrite(Relais_10, LOW);digitalWrite(Relais_11, LOW);digitalWrite(Relais_12, LOW);
digitalWrite(Relais_13, LOW);digitalWrite(Relais_14, LOW);digitalWrite(Relais_15, LOW);digitalWrite(Relais_16, LOW);digitalWrite(Relais_17, LOW);digitalWrite(Relais_18, LOW);
digitalWrite(Relais_19, LOW);digitalWrite(Relais_20, LOW);digitalWrite(Relais_21, LOW);digitalWrite(Relais_22, LOW);digitalWrite(Relais_23, LOW);digitalWrite(Relais_24, LOW);
digitalWrite(Relais_25, LOW);digitalWrite(Relais_26, LOW);digitalWrite(Relais_27, LOW);digitalWrite(Relais_28, LOW);digitalWrite(Relais_29, LOW);digitalWrite(Relais_30, LOW);
digitalWrite(Relais_31, LOW);digitalWrite(Relais_32, LOW);digitalWrite(Relais_33, LOW);digitalWrite(Relais_34, LOW);digitalWrite(Relais_35, LOW);digitalWrite(Relais_36, LOW);
delay(800);  
 } } // Ende Batterie 2

// ... usw

File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
} // Zeitschleife ende


Serial.println();
Serial.println(RealB1V); //Print battery voltage on arduino serial monitor
Serial.println(RealB2V);
Serial.println(RealB3V);
Serial.println(RealB4V);               

} //end of Proramm //
2

Du solltest Dich mit Arrays beschäftigen, um nicht alles 36 Mal zu schreiben.

Gruß Tommy

3

Ok gute Idee.
Ich habe Kentnisse mit Delphi ubd C++ aber an Arry hatte ich noch garnicht gedacht.
Danke

4

Nur mal grob auf die Schnelle als Vorschlag, ohne Prüfung auf Richtigkeit aber wie @Thomm56 angesprochen hat, macht ein Array das Programm wesentlich kürzer und übersichtlicher:

#include <SPI.h>

#include <SD.h>

#include <LiquidCrystal.h>

#include <TimeLib.h>   // second , minute , hour , day , year

int counter_time;

const int chipSelect = 4;

float ratio = 3.6;  // Calculated from Vin / Vout

//Relaisausgänge deffinieren:
/*
  int Relais_1 = 22, Relais_2 = 23, Relais_3 = 24, Relais_4 = 25, Relais_5 = 26, Relais_6 = 27, Relais_7 = 28, Relais_8 = 29, Relais_9 = 30,
  Relais_10 = 31, Relais_11 = 32, Relais_12 = 33, Relais_13 = 34, Relais_14 = 35, Relais_15 = 36, Relais_16 = 37, Relais_17 = 38, Relais_18 = 39, Relais_19 = 40,
  Relais_20 = 41, Relais_21 = 42, Relais_22 = 43, Relais_23 = 44, Relais_24 = 45, Relais_25 = 46, Relais_26 = 47, Relais_27 = 48, Relais_28 = 49,
  Relais_29 = 62, Relais_30 = 63, Relais_31 = 64, Relais_32 = 65, Relais_33 = 66, Relais_34 = 67, Relais_35 = 68, Relais_36 = 69;
*/


// Relais Index
enum  RelaisNr : byte {RELAIS1 = 0,  RELAIS2,  RELAIS3,  RELAIS4,  RELAIS5,  RELAIS6,  RELAIS7,  RELAIS8,  RELAIS9,  RELAIS10, RELAIS11, RELAIS12,
                       RELAIS13, RELAIS14, RELAIS15, RELAIS16, RELAIS17, RELAIS18, RELAIS19, RELAIS20, RELAIS21, RELAIS22, RELAIS23, RELAIS24,
                       RELAIS25, RELAIS26, RELAIS27, RELAIS28, RELAIS29, RELAIS30, RELAIS31, RELAIS32, RELAIS33, RELAIS34, RELAIS35, RELAIS36
                      };
constexpr byte MAX_RELAIS_COUNT {36};

// Relaispins
byte Relais[MAX_RELAIS_COUNT] {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
       46, 47, 48, 49, 62, 63, 64, 65, 66, 67, 68, 69
};

//Spannungseingang Batterie deffinieren:
float Spannung_1 = A7;              //  <- Warum float bei einer PIN Definition byte reicht
int Spannung_11;

// ALLE! Relais  auf LOW schalten
void relaisOff() {
  for (auto &relais : Relais) {
    digitalWrite(relais, LOW);
  }
}

// Referenzspannung am Arduino auslesen:
long readVcc() {
  // Read 1.1V reference against AVcc
  // set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
  ADMUX = _BV(MUX5) | _BV(MUX0) ;
#else
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

  delay(2);                       // Wait for Vref to settle
  ADCSRA |= _BV(ADSC);            // Start conversion
  while (bit_is_set(ADCSRA, ADSC)); // measuring

  uint8_t low  = ADCL;            // must read ADCL first - it then locks ADCH
  uint8_t high = ADCH;            // unlocks both

  long result = (high << 8) | low;

  result = 1125300L / result;     // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
  return result;                  // Vcc in millivolts
}

void setup() {
  Serial.begin(9600);
  // Achtung wird nur einmalig ausgeführt als Grund deklaration:
  //Relais deklarieren:
  for (auto &relais : Relais) {
    pinMode(relais, OUTPUT);
  }
  relaisOff();

  pinMode(Spannung_1, INPUT);

  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");
}


void loop() {
  // put your main code here, to run repeatedly:

  float  B1PV = 0.0; float  B2PV = 0.0; float  B3PV = 0.0; float  B4PV = 0.0; float  B5PV = 0.0; float  B6PV = 0.0; float  B7PV = 0.0; float  B8PV = 0.0; float  B9PV = 0.0; float  B10PV = 0.0; float  B11PV = 0.0; float  B12PV = 0.0;
  float  B13PV = 0.0; float  B14PV = 0.0; float  B15PV = 0.0; float  B16PV = 0.0; float  B17PV = 0.0; float  B18PV = 0.0; float  B19PV = 0.0; float  B20PV = 0.0; float  B21PV = 0.0; float  B22PV = 0.0; float  B23PV = 0.0;
  float  B24PV = 0.0; float  B25PV = 0.0; float  B26PV = 0.0; float  B27PV = 0.0; float  B28PV = 0.0; float  B29PV = 0.0; float  B30PV = 0.0; float  B31PV = 0.0; float  B32PV = 0.0; float  B33PV = 0.0; float  B34PV = 0.0;

  float RealB1V = 0; float RealB2V = 0; float RealB3V = 0; float RealB4V = 0; float RealB5V = 0; float RealB6V = 0; float RealB7V = 0; float RealB8V = 0; float RealB9V = 0; float RealB10V = 0; float RealB11V = 0; float RealB12V = 0;
  float RealB13V = 0; float RealB14V = 0; float RealB15V = 0; float RealB16V = 0; float RealB17V = 0; float RealB18V = 0; float RealB19V = 0; float RealB20V = 0; float RealB21V = 0; float RealB22V = 0; float RealB23V = 0;
  float RealB24V = 0; float  RealB25V = 0; float RealB26V = 0; float RealB27V = 0; float RealB28V = 0; float RealB29V = 0; float RealB30V = 0; float RealB31V = 0; float RealB32V = 0; float RealB33V = 0; float RealB34V = 0;

  //Datenaufnahme Sd-Karte
  String dataString = "";

  // Zeitschleife begin
  if ((counter_time != minute()) && (minute() % 8 == 0) ) {
    counter_time = minute();
    // Serial.println(counter_time);

    // Begin Batterie 1
    //Spannungseingang auf 0V Abfragen da sonst Überspannung!!!
    Spannung_11 = analogRead (Spannung_1);
    if ( Spannung_11 << 1) {
      //Battarie 1 abfragen:
      float vccValue = readVcc() / 1000.0;    //Arduino Spannung am Board


      digitalWrite(Relais[RelaisNr::RELAIS1], HIGH);             //Relais einschalten
      delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
      B1PV = analogRead(Spannung_1);         // Spannung einlesen
      RealB1V = (B1PV * vccValue / 1024) * ratio;
      digitalWrite(Relais[RelaisNr::RELAIS1], LOW);             //Relais ausschalten
      delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen

    } else {
      relaisOff();
    } // Ende Batterie 1

    // Begin Batterie 2
    //Spannungseingang auf 0V Abfragen da sonst Überspannung!!!

    Spannung_11 = analogRead (Spannung_1);
    if ( Spannung_11 << 1) {
      //Battarie 2 abfragen:
      float vccValue = readVcc() / 1000.0;    //Arduino Spannung am Board


      digitalWrite(Relais[RelaisNr::RELAIS2], HIGH);             //Relais einschalten
      delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
      B1PV = analogRead(Spannung_1);         // Spannung einlesen
      RealB1V = (B1PV * vccValue / 1024) * ratio;
      int sensor = int(RealB1V);                //Messwert in String schreiben für spätere Speicherung
      dataString += "Batterie 1 ";
      dataString += String(sensor);
      dataString += ";";
      digitalWrite(Relais[RelaisNr::RELAIS2], LOW);             //Relais ausschalten
      delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen
      Spannung_11 = analogRead (Spannung_1);
      if ( Spannung_11 << 1) {
        relaisOff();


        delay(800);
      }
    } // Ende Batterie 2

    // Begin Batterie 2
    //Spannungseingang auf 0V Abfragen da sonst Überspannung!!!
    Spannung_11 = analogRead (Spannung_1);
    if ( Spannung_11 << 1) {
      //Battarie 1 abfragen:
      float vccValue = readVcc() / 1000.0;    //Arduino Spannung am Board


      digitalWrite(Relais[RelaisNr::RELAIS2], HIGH);             //Relais einschalten
      delay(400);                         //Warten auf Schaltverzögerung je nach Relaistyp längere Pause einstellen
      B1PV = analogRead(Spannung_1);         // Spannung einlesen
      RealB1V = (B1PV * vccValue / 1024) * ratio;
      int sensor = int(RealB1V);                //Messwert in String schreiben für spätere Speicherung
      dataString += "Batterie 2 ";
      dataString += String(sensor);
      dataString += ";";
      digitalWrite(Relais[RelaisNr::RELAIS2], LOW);             //Relais ausschalten
      delay(400);                             //Warten bis Kontakt abgefallen ist je nach Relaistyp längere Pause einstellen
      Spannung_11 = analogRead (Spannung_1);
      if ( Spannung_11 << 1) {
        relaisOff();
        delay(800);
      }
    } // Ende Batterie 2

    // ... usw

    File dataFile = SD.open("datalog.txt", FILE_WRITE);

    // if the file is available, write to it:
    if (dataFile) {
      dataFile.println(dataString);
      dataFile.close();
      // print to the serial port too:
      Serial.println(dataString);
    }
    // if the file isn't open, pop up an error:
    else {
      Serial.println("error opening datalog.txt");
    }
  } // Zeitschleife ende


  Serial.println();
  Serial.println(RealB1V); //Print battery voltage on arduino serial monitor
  Serial.println(RealB2V);
  Serial.println(RealB3V);
  Serial.println(RealB4V);

} //end of Proramm //
5

Sorry, aber der Code ist ja fast noch grauenvoller, als das Original.
Warum verwendest Du ein Array, wenn Du dann doch über das rein gequälte enum jedes Relais einzeln ausprogrammierst?

Mal als Vorschlag (ungetestet):

constexpr bool AUS {LOW};  // an Relais anpassen
constexpr bool EIN {HIGH};
constexpr byte MAX_RELAIS_COUNT {36};

// Relaispins
byte Relais[MAX_RELAIS_COUNT] {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
       46, 47, 48, 49, 62, 63, 64, 65, 66, 67, 68, 69
};

void messen(byte num) {
  if (num > 0) digitalWrite(Relais[num - 1], AUS);
  delay(10); // Umschaltzeit
  digitalWrite(Relais[num],EIN);
  messenAnalog(num); // Messroutine mit Wegschreiben
}

...
for(byte i=0; i<MAX_RELAIS_COUNT;i++)  messen(i);

Gruß Tommy

6

Immer gleich so rüde. Passt zu Deinem Avatar. Immer druff Herr Wikinger. Anscheinend ist ja das Enum das Einzige das dich quält.

Hinter dem Enum stand die Idee dass ein digitalWrite(Relais[RelaisNr::RELAIS1], HIGH); klarer zu lesen ist ist als ein digitalWrite(relais(num), HIGH);. Ersteres lässt keinen Zweifel daran aufkommen, dass es sich um Relais 1 handelt. Es war ja nur ein Vorschlag, keine Anweisung es so zu tun... ich habe das ja auch so geschrieben.

Um die Relais der Reihe nach zu schalten, ist das mit der Funktion die Du vorstellst natürlich besser. Da braucht man es ja auch nicht.

7

Ich rede nicht um den Brei rum und bin für klare Ansagen.
Nein, das enum ist nur eine Randerscheinung.
Das der Code für jedes Relais wiederholt wird (wie beim OP) ist das Problem und im Zusammenhang mit dem enum schlechter, als das Original. Ich hätte mehr von Dir erwartet. Evtl. hatte ich aus dieser Enttäuschung heraus schärfer formuliert.

Gruß Tommy

8

Ich hatte mit meiner Antwort nicht den Anspruch den Code gleich komplett umzuschreiben. Ich habe lediglich auf den Einsatz eines Arrays abgezielt.

9

In den Setup-Funktionalitäten hast Du es ja auch gemacht.
In der Hauptroutine hast Du das Array wie Relais_1, Relais_2 usw. benutzt.
Das empfand ich als grausam.

Gruß Tommy

10

Dein Vorhaben ist extrem Gefährlich (Lebensgefährlich, Brandgefährlich).
Und Du wirst Probleme haben geeignete (genügend Spannungsfeste) Relais und Netzteile zu finden.

  1. brauchst Du Relais die mindestens 600V an den Kontakten vertragen.
  2. Wenn2 Relais gleichzeitig anziehen dann sind 2 oder mehrere Batterien kurzgeschlossen.
  3. Du hast ein Potential von bis zu 450V auf dem Arduino.

Ich weiß jetzt nicht ob die Gleichspannung geerdet ist oder ob sie von Erde/Masse/Gehäuse isoliert ist. Du schaltest durch die Relais die Spannung der Batterien auf Masse des Arduino. Darum könntest Du hohe Spannugen gegenüber Erde haben die die Isolierung des Netzteils überfordern, bzw auf Bedienelemente (Taster, Encoder Display, SD-Kartenhalter ecc) haben.
Ist das der Fall ist die Schaltung lebensgefährlich.

Erste wichtige Frage:
Ist ein Pol der Batterie geerdet? Masse auf Erde oder Minuspol des Ladenetzteils auf Erde?

Was ist an der Batterie angeschlossen?

Was für eine Chemie haben die Batterien? (Blei, FeS, Li?)

Ich sehe die einzige sichere Realisierung des Projekts die Messung an jeder Batterie vorzunehmen und die Messergebnisse über Funkt, Optoisolatoren oder Lichtleiter an den Logger übertragen.
Wenn die Meßhardware genügend stromsparend aufgebaut ist kann diese von der Batterie selbst versorgt werden.

Grüße Uwe

11

Ist doch gar nicht so schwer...

#include <SPI.h>
#include <SD.h>
#include <LiquidCrystal.h>
#include <TimeLib.h>   // second , minute , hour , day , year

const byte chipSelect = 4;
//Relaisausgänge deffinieren:
const byte battNums = 36;
const byte relaisPin[battNums] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                                  40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 62, 63, 64, 65, 66, 67, 68, 69
                                 };

const float ratio = 3.6;  // Calculated from Vin / Vout

//Spannungseingang Batterie deffinieren:
const byte voltagePin = A7;
float realBattVoltage[battNums] = 0;
byte counter_time;


void setup()
{
  Serial.begin(9600);
  allRelaisOff()
  for (byte b = 0; b < battNums; b++)
  { pinMode(Relais[b], OUTPUT); }
  pinMode(spannungPin, INPUT);
  // Open serial communications and wait for port to open:
  while (!Serial)
  { Serial.print(F("Initializing SD card...")); }
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect))
  {
    Serial.println(F("Card failed, or not present"));
    // don't do anything more:
    while (1);
  }
  Serial.println(F("card initialized."));
}


void loop()
{
  // put your main code here, to run repeatedly:
  // Zeitschleife begin
  if ((counter_time != minute()) && (minute() % 8 == 0) )
  {
    
    readVoltageValue();
    writeData2Sd();
    serialPrintData();
    counter_time = minute();
  }
}
//

:slight_smile:
Im Übrigen hatte ich erst eine Variante mit einem Struct für den relaisPin, den VoltagWert im sinne und das Struct dann wieder an ein Array zu binden.... Aber das wäre dann zuviel des Guten.

12

Hast ja recht. Ih habe die Hauptroutine halt so gelassen wie im Original und lediglich die DigitalWrite Anweisungen angepasst, damit es sich compilieren lässt ... Das ist alles.

Es ist das Programm vom TO. Er kann es auch fertig programmieren....

13

@my_xy_projekt : Du bis hier sehr aktiv... und scheint manchmal so, als ob Du nichts anderes tätest , als den TOs ihre Software zu entwickeln :slight_smile: . Die freuen sich bestimmt. Ich bin da etwas sparsamer und sicher auch nicht so fingerfertig wie Du und andere hier im Forum.

Allerdings denke ich, dass die TOs ihre Software selber scheiben sollen. Darum beschränke ich mich auf Hinweise, wenn ich der Meinung bin, etwas beitragen zu können ...

14

Dann wären die beiden Setup-Routinen, die über for arbeiten allein als Denkanstoß sehr gut geeignet gewesen. Die hätten den TO das Prinzip aufgezeigt.

Gruß Tommy

15

Hallo Uwe,
es wird pro Batterie zwei Relais eingesetzt.
Ich bin gelernter Elektriker/Elektroniker ich mache mir über Kurzschluß und Überspannug schon meine Gedanken.
Es wird immer pro Relais-Kanal zwei Relais für Batt1 + und Batt1 - Angesteuert. Alle anderen Relais sind aus. Ein Relais kann am Eingang 250V schalten da aber nur 12V anliegen reicht das locker.
Aber Danke für die Anregung

16

Wie willst Du sicher Programmierfehler ausschließen?
Beantworte bitte auch die Frage nach der GND-Verbindung.

Gruß Tommy

17

Wie sind die Batterien gegenüber Erde verschaltet?

18

Hallo
ich hab das noch nicht ganz verstanden. Wenn die Akkus eigentlich alle in Reihe geschaltete sind , und Du mit dem Arduino jeweils einen Akku messen willst , dann benötigst Du meiner Meinung nach jeweils 2 Relais. Eines auf der minus Seite und eines auf der plus Seite von jedem Akku. Damit hast Du immer zwei Relais geschlossen und kannst die Spannung von nur einem Akku zu messen. Für Akku1 die Relais 1 und 2 , für den zweiten Akku das die Relais 2 und 3 usw. ganz allgemein n-1 und n für Akku_n.
GND vom Arduino darf natürlich nicht direkt mit 0V der Reihenschaltung verbunden sein, nur über das Relais 1.

Heinz
Nachtrag
hatte sich inzwischen gelöst

19

Hallo,
Digital Out Relais1= auf externer Platine Relais 1 und 2.
Digital Out Relais2= auf externer Platine Relais 3 und 4.
Digital Out Relais3= auf externer Platine Relais 5 und 6.
usw.

20

Da irrst Du dich gewaltig.
Du hast jeweils am Minus Pol jeder Batterie einen Relaiskontakt nach Masse des Arduino und am Pluspol der Batterie zum Spannungsteiler der Spannungsmessung. Also 32 Relaiskontakte an Masse und 32 am Spannungsteiler.

Wenn Du jetzt zB die Relais an der ersten Batterie zu hast dann hast Du am Minuspol der 32.Batterie 436V gegenüber dem Minuspol der ersten Batterie. Genau dies Spannung hast Du am Kontakt des Relais der 32. Batterie.

Also brauchst Du Relais mit Kontakten die 436V vertragen also mindestens 600V.

Grüße Uwe