uC bleibt hängen - Ursache unklar - Fehler nicht reproduzierbar

#include <EEPROM.h> /// zum speichern im EEPROM des Arduino

#include <OneWire.h>

#include "WS2812.h"

////////////////////////////////////////////////

/// Ab hier kann wieder angepasst werden !!! ///

////////////////////////////////////////////////

/* Konstanten

*/

#define UPDATE_TIME_CHECK 500 /// ms zwischen Signal + Avg + Schutz

#define NUM_READ_A 125 /// Anzahl der Messungen Haupt-Stromsensor

#define UPDATE_TIME_A 4 /// ms zwischen den Messungen vom Haupt-Stromsensor

#define NUM_READ_U 20 /// Anzahl der Messungen Nutzer-Stromsensoren

#define UPDATE_TIME_U 25 /// ms zwischen den Messungen vom Spannung(s-Teiler)

#define NUM_READ_V 20 /// Anzahl der Messungen Spannung(s-Teiler)

#define UPDATE_TIME_V 25 /// ms zwischen den Messungen von Nutzer-Stromsensoren

#define OVP_MF_OFF_ID 767 /// ADC-Wert bei 15zu20V

#define OVP_MF_ON_ID 716 /// ADC-Wert bei 14zu20V

#define OVP_MF_TIME 10000 /// 10s nach aus darf ein

#define UVP_WR_OFF_ID 563 /// ADC-Wert bei 11zu20V

#define UVP_WR_ON_ID 588 /// ADC-Wert bei 11,5zu20V

#define UVP_WR_TIME 10000 /// 10s nach aus darf ein

#define OCP_MF_OFF_ID 2046 /// 2x 50A = 2x map(MAX_ADC_USER) = 2x 1023

#define OCP_MF_ON_ID 1637 /// 80A

#define OCP_MF_TIME 10000 /// 10s nach aus darf ein

#define OTP_MF_OFF 80.0 /// °C

#define OTP_MF_ON 70.0 /// °C

#define ADC_NUM 12 /// Anzahl analoge Eingänge

#define PORT_A A0 /// (?) Stromsensor zwischen WR und Bat

#define PORT_LED 13 /// 1x WS2812

#define PORT_MF 11 /// Port um Mosfets zu schalten

#define PORT_TEMP 7 /// Port vom Tempsensor DS18B20Z

#define PORT_U0 A9 /// Stromsensor User 0

#define PORT_U1 A8 /// Stromsensor User 1

#define PORT_U2 A7 /// Stromsensor User 2

#define PORT_U3 A11 /// Stromsensor User 3

#define PORT_U4 A5 /// Stromsensor User 4

#define PORT_U5 A4 /// Stromsensor User 5

#define PORT_U6 A3 /// Stromsensor User 6

#define PORT_U7 A2 /// Stromsensor User 7

#define PORT_U8 A6 /// (?) Stromsensor User 8

#define PORT_U9 A1 /// (?) Stromsensor User 9

#define PORT_V A10 /// Spannungsteiler

#define PORT_WR 5 /// Wechselrichter-Port fürs ein- und ausschalten

#define TIME_MF_OFF_TO_ON 10000 /// ms → nach min. wieviel Zeit wieder ON

#define TIME_WR_OFF_TO_ON 10000 /// ms → nach min. wieviel Zeit wieder ON

#define ALERT_USER_HIGH_W 100.0

#define ALERT_USER_LOW_W 40.0

#define BITBREITE 10 

#define BPS 115200 /// 115200 Bits_Per_Second (Serielle Kommunikation)

#define COUNT_USER 8 /// Nutzeranzahl

#define GAUGE_USER 100.00 /// W für Vollausschlag der Bargraphanzeige

#define KWH_AUSSCHLAG 0.10 /// kWh für Vollausschlag nach jeder Seite der Bargraphanzeige Verbrauch bzw. Erzeugt

#define MAX_ADC_A 921 /// bei +MAX_A_BATT

#define MAX_ADC_V 1023 /// ADC_Wert bei MAX_V

#define MAX_ADC_USER 614 /// (runtergerechneter) ADC_Wert inkl. Offset bei MAX_A_USER

#define MAX_V 20.00 /// Maximale Sensorbereich (Hardware)

#define MAX_A_USER 50.00 /// Maximale theoretische Sensorbereich (Hardware)

#define MAX_A_BATT 100.00 /// Maximale theoretische Sensorbereich (Hardware)

#define MIN_ADC_A 102 /// bei -MAX_A_BATT

#define MIN_ADC_V 0 /// ADC_Wert bei 0 V

#define MIN_ADC_USER 0 /// (runtergerechneter) ADC_Wert inkl. Offset

#define NUTZER_ID "" /// Das ist die Lizenz

#define OFFSET_A 0

#define OFFSET_V 0

#define OFFSET_USER 102 /// 102 rechnerisch (=0,5V)

#define VERSION "2019.10.03" /// vom µC

#define WR_DELAY 1000 /// Zeit jeweis zwischen Ausschalten, Kalibrieren, Einschalten des WR

/* Aufzählungen

 */

enum OPT /// Option für Serial-Event

{

  Mf_On     = 15,

  Mf_Off    = 14,

  Wr_On     = 13,

  Wr_Off    = 12,

  Send_Conf = 11,

  Kali      = 10,

  Send_Data =  9

};

/* RGB-Code für diverse States

 */

cRGB ALERT_PROTECT = {255, 255, 0 }; /// gelb → OCP || OTP || OVP || UVP ist 1

cRGB NO_COLOR = {0, 0, 0 }; /// aus bzw. schwarz bzw. keine Farbe

cRGB NO_PROTECT = {0, 255, 0 }; /// grün → OCP && OTP && OVP && UVP ist >= 2

cRGB OCP_OTP_OVP_UVP = {255, 0, 0 }; /// rot → OCP || OTP || OVP || UVP ist 0

cRGB TIME_ALERT_PROTECT = {255, 0, 0 }; /// lila → Abklingzeit + ALERT_PROTECT

cRGB TIME_NO_PROTECT = {255, 0, 0 }; /// türkis → Abklingzeit + NO_PROTECT

////////////////////////////////////////

/// Ab hier nichts mehr anpassen !!! ///

////////////////////////////////////////

struct Configuration{ /// Das was als Konfiguration über USB gesendet wird

  //short Alert_High_V_Id = OVP_MF_ALERT_ID;

  //short Alert_Low_V_Id = UVP_WR_ALERT_ID;

  float Alert_User_High_W = ALERT_USER_HIGH_W;

  float Alert_User_Low_W = ALERT_USER_LOW_W;

  float Gauge_User = GAUGE_USER;

  float KWh_Ausschlag = KWH_AUSSCHLAG;

  float Max_A_Batt = MAX_A_BATT;

  float Max_A_User = MAX_A_USER;

  float Max_V = MAX_V;

  short Mosfet_High_Id = OVP_MF_OFF_ID;

  short Mosfet_Low_Id = OVP_MF_ON_ID;

  uint8_t ADC_Bitbreite = BITBREITE;

  uint8_t Count_User = COUNT_USER;

  char Kinobox_Version[11] = VERSION;

  char Nutzer_ID[150] = NUTZER_ID;

  uint8_t dummy[17] = {0};

};

struct Daten{ /// Alle analoge Ports

  short adc[ADC_NUM]; /// Port A 0 bis A 11

};

/* Variablen

 */

byte Read_Index_A = 0;

byte Read_Index_V = 0;

byte Read_Index_U = 0;

short Reading_A[NUM_READ_A] = {0};

short Reading_V[NUM_READ_V] = {0};

short Reading_U[ADC_NUM-2][NUM_READ_U] = {0};

long Total_A = 0;

long Total_V = 0;

long Total_U[ADC_NUM-2] = {0};

unsigned long Last_Time_Check = 0;

unsigned long Last_Time_Read_A = 0;

unsigned long Last_Time_Read_V = 0;

unsigned long Last_Time_Read_U = 0;

unsigned long Last_Time_MF_Off = 0;

unsigned long Last_Time_WR_Off = 0;

unsigned long now = 0;

OneWire ds(PORT_TEMP); /// an welchen Port ist der Temperatursensor

byte Temp_Addr[8]; /// Adresse des Temperatursensors

byte Temp_Data[12]; /// Daten des Temperatursensors

int16_t Temp_Raw = 0;

float Temperatur = 0.0;

short adc = 0; /// temporär für Berechnungen usw.

short tempAall = 0; /// gesamt für alle Nutzer für OCP-Schutz

int Analog_Port_Array[ADC_NUM] = {PORT_A, PORT_V, PORT_U0, PORT_U1, PORT_U2, PORT_U3, PORT_U4, PORT_U5, PORT_U6, PORT_U7, PORT_U8, PORT_U9};

Daten Max_ADC = {MAX_ADC_A, MAX_ADC_V, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER, MAX_ADC_USER};

Daten Min_ADC = {MIN_ADC_A, MIN_ADC_V, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER, MIN_ADC_USER};

Daten Offset = {OFFSET_A, OFFSET_V, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER, OFFSET_USER};

Daten Data = {0}; /// Das was über USB gesendet wird

Configuration Conf;

WS2812 LED(1);

cRGB LED_rgb = {0};

byte OVP_State = 0; /// Überspannungsschutz

byte UVP_State = 0; /// Unterspannungsschutz

byte OCP_State = 0; /// Überstromstärkeschutz

byte OTP_State = 0; /// Temperaturschutz

////////////////////////////////////////

/// Ab hier nichts mehr anpassen !!! ///

////////////////////////////////////////

/* Programmstart

 */

void setup()

{

  init_default_led();

  init_default_mosfet();

  init_default_temp();

  init_default_wr();

  zero_reading_data();

  zero_total_data();

  zero_usb_data();

  Verbinden();

  //EEPROM_auslesen(); /// Ggf. in späteren Version aktivieren und erweitern

}

/* Dauerschleife für regelmäßige Aktionen

 */

void loop()

{

  now = millis();

  if( (now - Last_Time_Read_A) >= UPDATE_TIME_A ) /// Haupt-Stromsensor

  {

    Last_Time_Read_A = now;

    Total_A -= Reading_A[Read_Index_A];

    Reading_A[Read_Index_A] = (short)analogRead(Analog_Port_Array[0]);

    Total_A += Reading_A[Read_Index_A];

    Read_Index_A++;

    if( Read_Index_A >= NUM_READ_A ) { Read_Index_A = 0; }

  }

  if( (now - Last_Time_Read_V) >= UPDATE_TIME_V ) /// Spannung(s-Teiler)

  {

    Last_Time_Read_V = now;

    Total_V -= Reading_V[Read_Index_V];

    Reading_V[Read_Index_V] = (short)analogRead(Analog_Port_Array[1]);

    Total_V += Reading_V[Read_Index_V];

    Read_Index_V++;

    if( Read_Index_V >= NUM_READ_V ) { Read_Index_V = 0; }

  }

  if( (now - Last_Time_Read_U) >= UPDATE_TIME_U ) /// Nutzer_Stromsensoren

  {

    Last_Time_Read_U = now;

    for( byte i = 0 ; i < (ADC_NUM-2) ; i++ )

    {

      Total_U[i] -= Reading_U[i][Read_Index_U];

      Reading_U[i][Read_Index_U] = (short)analogRead(Analog_Port_Array[i+2]);

      Total_U[i] += Reading_U[i][Read_Index_U];

    }

    Read_Index_U++;

    if( Read_Index_U >= NUM_READ_U ) { Read_Index_U = 0; }

  }

  if( (now - Last_Time_Check) >= UPDATE_TIME_CHECK ) /// Signal+Avg+Schutz

  {

    Last_Time_Check = now;

    /// Falls keine Verbindung, soll auch OHNE Befehl der

    /// Mittelwert in der USB-Struktur gespeichert werden,

    /// damit die LED weiterhin einen Status geben kann.

    if(!Serial)

    {

      calc_save_avg();

    }

    temperaturschutz();

    ueberstromschutz();

    ueberspannungsschutz();

    unterspannungsschutz();

    update_states(); /// LED, WR und/oder MF beeinflussen

  }

}

/* USB-Data-Struktur mit den Mittelwert aus der 

 * Gesamt_pro_Port-Data-Struktur speichern

 */

inline void calc_save_avg()

{

/// Stromstärke-Batterie-ADC-Wert

  adc = Total_A / NUM_READ_A; /// Mittelwert bilden

  Data.adc[0] = (short)map(adc, Min_ADC.adc[0], Max_ADC.adc[0], -1023, 1023); /// Umwandeln per Verhältnis + speichern

/// Spannung-ADC-Wert

  adc = Total_V / NUM_READ_V; /// Mittelwert bilden

  Data.adc[1] = (short)map(adc, Min_ADC.adc[1], Max_ADC.adc[1], 0, 1023); /// Umwandeln per Verhältnis + speichern

/// Stromstärke-Nutzer-ADC-Wert

  for( int i = 0 ; i < (ADC_NUM-2) ; i++ )

  {

    adc = Total_U[i] / NUM_READ_U; /// Mittelwert bilden

    if(adc >= Offset.adc[i+2]) /// gemessenes größergleich Offset

    {

      adc -= Offset.adc[i+2]; /// adc um offset erleichtern

      Data.adc[i+2] = (short)map(adc, Min_ADC.adc[i+2], Max_ADC.adc[i+2], 0, 1023); /// Umwandeln per Verhältnis + speichern

    }

    else /// gemessenes kleiner als Offset

    {

      Data.adc[i+2] = (short)0; /// abspeichern → Strom/Spannung = 0

    }

  }

}

/* Daten übertragen

*/

inline void daten_senden()

{

    senden( (char*)&Data , (uint8_t)sizeof(Daten) );

}

/* Grundeinstellung vom LED laden

 */

inline void init_default_led()

{

  pinMode( PORT_LED , OUTPUT );

  set_port( PORT_LED , false );

  LED.setOutput(PORT_LED);

  set_led(NO_COLOR);

  LED.set_crgb_at(0, LED_rgb); /// Wert festlegen

  LED.sync(); /// Werte an LEDs übertragen

}

/* Grundeinstellung vom Mosfet laden

 */

inline void init_default_mosfet()

{

  pinMode( PORT_MF , OUTPUT );

  set_port( PORT_MF , true );

}

/* Grundeinstellung vom LED laden

 */

inline void init_default_temp()

{

/// Suchen

  if ( ds.search(Temp_Addr) )

  {

    ds.skip();

  }

  else

  {

    ds.reset_search();

  }

}

/* Grundeinstellung vom Wechselrichter laden

 */

inline void init_default_wr()

{

  pinMode( PORT_WR , OUTPUT );

  set_port( PORT_WR, true );

}

/* Konfiguration übertragen

 */

inline void konfig_senden()

{

/// die Konfiguration dem PC mitteilen

  senden( (char*)&Conf , (uint8_t)sizeof(Configuration) );

}

/* Daten über USB senden und dabei den

 * Eingangspuffer leeren,

 * Daten byte-weise übertragen und

 * Ausgangspuffer leeren

 */

inline void senden(char *structPointer, byte structLength)

{

  while( Serial.available() )

  {

    Serial.read();

  }

  for( int i = 0 ; i < structLength ; i++ )

  {

    Serial.write( structPointer[i] );

  }

  Serial.flush();

}

/* Daten über USB empfangen und

 * dabei das Kommando auswerten und

 * passende Aktion ausführen

 */

void serialEventRun()

{

  if (Serial.available())

  {

    switch(Serial.read())

    {

      case OPT::Mf_On : set_port( PORT_MF , true ); break;

      case OPT::Mf_Off : set_port( PORT_MF , false ); break;

      //case OPT::Wr_On : waiting(WR_DELAY); set_port( PORT_WR , true );  break;

      //case OPT::Wr_Off : waiting(WR_DELAY); set_port( PORT_WR , false );  break;

      case OPT::Send_Conf : konfig_senden();

      //case OPT::Kali : waiting(WR_DELAY); Strom_Kalibri_All();  break;

      case OPT::Send_Data : calc_save_avg(); daten_senden();  break;

    }

  }

}

/* Einen bestimmten digitalen Port einen Wert zuweisen

 */

inline void set_port(int port , bool value)

{

  if( digitalRead( port ) != value ) {

    digitalWrite( port , value ? HIGH : LOW );

  }

}

/* Einer LED einen Farbwert zuweisen

 */

inline void set_led(cRGB value)

{

  if( ( LED_rgb.r != value.r ) || ( LED_rgb.g != value.g ) || ( LED_rgb.b != value.b ) )

  {

    LED_rgb.r = value.r;

    LED_rgb.g = value.g;

    LED_rgb.b = value.b;

    LED.set_crgb_at(0, LED_rgb); /// Wert festlegen

    LED.sync(); /// Werte an LEDs übertragen

  }

}

/* Schutz: Mosfet und Wechselrichter sollen funktionieren, auch ohne PC

 */

inline void temperaturschutz()

{

/// ??????????

  ds.reset(); // RICHTIGE TEMP AKTUALISIERT NICHT

  ds.select(Temp_Addr); // RICHTIGE TEMP AKTUALISIERT NICHT

/// start conversion (, with parasite power on at the end = ds.write(0x44, 1) )

  ds.write(0x44); // RICHTIGE TEMP AKTUALISIERT NICHT

  ds.reset(); // FALSCHE TEMP AKTUALISIERT NICHT

  ds.select(Temp_Addr); // FALSCHE TEMP AKTUALISIERT NICHT

/// Read Scratchpad

  ds.write(0xBE); // FALSCHE TEMP AKTUALISIERT NICHT

/// Lesen 

  for (byte i = 0; i < 9; i++){

    Temp_Data[i] = ds.read();}

  Temp_Raw = (Temp_Data[1] << 8) | Temp_Data[0];

/// Sensortemperatur

  Temperatur = (float)Temp_Raw / 16.0;

/// Temp-Pegel prüfen

  if( Temperatur < OTP_MF_ON ) {

    OTP_State = 2; } /// an + grün

  else if( Temperatur > OTP_MF_OFF ) {

    OTP_State = 0; } /// aus + rot

  else {

    OTP_State = 1; } /// gelb

}

/* Schutz: Mosfet soll funktionieren, auch ohne PC

 */

inline void ueberspannungsschutz()

{

  if( Data.adc[1] < OVP_MF_ON_ID ) {

    OVP_State = 2; } /// an + grün

  else if( Data.adc[1] > OVP_MF_OFF_ID ) {

    OVP_State = 0; } /// aus + rot

  else {

    OVP_State = 1; } /// gelb

}

/* Schutz: Mosfet soll funktionieren, auch ohne PC

 */

inline void ueberstromschutz()

{

  tempAall = 0;

  for(int i=2 ; i<ADC_NUM ; i++)

  {

    tempAall += Data.adc[i];

  }

  if( tempAall < OCP_MF_ON_ID ) {

    OCP_State = 2; } /// an + grün

  else if( tempAall > OCP_MF_OFF_ID ) {

    OCP_State = 0; } /// aus + rot

  else {

    OCP_State = 1; } /// gelb

}

/* Schutz: Wechselrichter soll funktionieren, auch ohne PC

 */

inline void unterspannungsschutz()

{

  if( Data.adc[1] > UVP_WR_ON_ID ) {

    UVP_State = 2; } /// an + grün

  else if( Data.adc[1] < UVP_WR_OFF_ID ) {

    UVP_State = 0; }  /// aus + rot

  else {

    UVP_State = 1; } /// gelb

}

/* USB-Verbindung herstellen

 */

inline void Verbinden()

{

  Serial.begin(BPS);

}

/* Eine bestimmte Dauer abwarten

 */

inline void waiting(unsigned long dauer)

{

  unsigned long jetzt = millis();

  while( ( millis() - jetzt ) < WR_DELAY ){}

}

/* Mittelwert-Data-Struktur auf 0 setzen

 */

inline void zero_reading_data()

{

  for( int i = 0 ; i < NUM_READ_A ; i++ ) { Reading_A[i] = 0; }

  for( int i = 0 ; i < NUM_READ_V ; i++ ) { Reading_V[i] = 0; }

  for( int i = 0 ; i < NUM_READ_U ; i++ ){ 

    for( int j = 0 ; j < (ADC_NUM-2) ; j++ ) { Reading_U[j+2][i] = 0; }

  }

}

/* Gesamt_pro_Port-Data-Struktur auf 0 setzen

 */

inline void zero_total_data()

{

  Total_A = 0;

  Total_V = 0;

  for( int i = 0 ; i < (ADC_NUM-2) ; i++ ) { Total_U[i] = 0; }

}

/* USB-Data-Struktur auf 0 setzen

 */

inline void zero_usb_data()

{

  for( int i = 0 ; i < ADC_NUM ; i++ )

  {

    Data.adc[i] = 0;

  }

}

/* Anhand der Protect_States die LED farblich gestalten und

 * Mosfet bzw. Wechselrichter schalten

*/

void update_states()

{

/// Mindest 1 der States ist 0 → Rot → WR bzw MF ausschalten

  if( !OCP_State || !OTP_State || !OVP_State || !UVP_State ){

    set_led(OCP_OTP_OVP_UVP); /// Rot festlegen

////// Einer der WR-Relevanten States sind 0

    if( !UVP_State ) {

      set_port( PORT_WR , false ); /// Wechselrichter ausschalten

      Last_Time_WR_Off = now;} /// Zeit notieren für Einschaltverzögerung

////// Einer der MF-Relevanten States sind 0

    else{

      set_port( PORT_MF , false ); /// Mosfet ausschalten

      Last_Time_MF_Off = now;} } /// Zeit notieren für Einschaltverzögerung

/// Keins der States ist 0

  else{

////// Alle States sind mindest 2 → Grün üder Türkis

    if( ( OCP_State == 2 ) && ( OTP_State == 2 ) &&

        ( OVP_State == 2 ) && ( UVP_State == 2 ) ){

      if( ( ( now - Last_Time_WR_Off ) >= TIME_WR_OFF_TO_ON ) &&

          ( ( now - Last_Time_MF_Off ) >= TIME_MF_OFF_TO_ON ) ){

///////// Alle WR-Relevanten Stetes sind 2

        set_port( PORT_WR , true ); /// Wechselrichter ausschalten

///////// Alle MF-Relevanten States sind 2

        set_port( PORT_MF , true ); /// Mosfet einschalten

///////// Wartezeit für wieder einschalten abgelaufen

        set_led(NO_PROTECT); } /// Grün festlegen

      else{

///////// Wartezeit für wieder einschalten noch nicht abgelaufen

        set_led(TIME_NO_PROTECT); } } /// Türkis festlegen

////// Mindest 1 der States ist 1 → Gelb oder Lila → für Alarmanzeige

    else{

      if( ( ( now - Last_Time_WR_Off ) >= TIME_WR_OFF_TO_ON ) &&

          ( ( now - Last_Time_MF_Off ) >= TIME_MF_OFF_TO_ON ) ){

///////// Wartezeit für wieder einschalten abgelaufen

        set_led(ALERT_PROTECT); } /// Gelb festlegen

      else{

///////// Wartezeit für wieder einschalten noch nicht abgelaufen

        set_led(TIME_ALERT_PROTECT); } } } /// Lila festlegen

}

/*

 * Funktionen für später

 */

/*

void EEPROM_auslesen()

{

  for(byte i=0; i<(ADC_NUM); i++)

    EEPROM.get(EEPROM_Kalibrierung+(2*i), ADC_Offset[i]);

}

*/

/*

void Strom_Kalibri_All(){}

*/

> while( Serial.available() )

>   {

>     Serial.read();

>   }

>