/*
  Victron1   MPPT 12 V
  Victron2   MPPT 24 V
  Victron3   BMV  24 V

  D5ED   V_MPPT   un16   0.01 V
  D7ED   I_MPPT   un16   0.1  A
  BBED VPV_MPPT   un16   0.01 V
  BCED PPV_MPPT   un32   0.01 W
  0102  CS_MPPT    un8
  D3ED H20_MPPT   un16   0.01 KWH

  8DED   V_BMV    un16   0.01  V
  8CED   I_BMV    un32   0.001 A
  8EED   P_BMV    un16   1     W
  1003 H17_BMV    un32   0.01  KWH
  1103 H18_BMV    un32   0.01  KWH
  0603  H7_BMV    un32   0.01  V
  0703  H8_BMV    un32   0.01  V
  FF0F SOC_BMV    un16   0.01  %

  Checksum:
  :70010003E<LF>     -> Command; checksum 0x55 – 0x7 – 0x0 – 0x10 – 0x0 = 0x3E
  :7001000C80076<LF> -> Response; checksum 0x55 – 0x7 – 0x0 – 0x10 – 0x0 – 0xC8 – 0x0 = 0x76
*/

#include <Wire.h>
#include <stdio.h>
#include <stdlib.h>

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
Adafruit_BME280 bme;

#include <RunningMedian.h>
RunningMedian samples1 = RunningMedian(11);
RunningMedian samples2 = RunningMedian(11);

int interruptPin = 3;
int counter;
int Status;

#include <SoftwareSerial.h>
SoftwareSerial Serial_SIM900(52, 53); // RX, TX

const int vicbuf = 25;
const int sim900buf = 180;
char  vic1_ser[vicbuf];
char  vic2_ser[vicbuf];
char  vic3_ser[vicbuf];
char  sim900_ser[sim900buf];

float vic1_v_mppt;
float vic1_i_mppt;
float vic1_vpv_mppt;
long  vic1_ppv_mppt;
long  vic1_cs_mppt;
long  vic1_h20_mppt;

float vic2_v_mppt;
float vic2_i_mppt;
float vic2_vpv_mppt;
long  vic2_ppv_mppt;
long  vic2_cs_mppt;
long  vic2_h20_mppt;
long  vic2_v_mppt_r;

float vic3_v_bmv;
float vic3_i_bmv;
long  vic3_p_bmv;
float vic3_h17_bmv;
float vic3_h18_bmv;
float vic3_h7_bmv;
float vic3_h8_bmv;
float vic3_soc_bmv;

long  ergebniss;

float temperatur;
float luftfeuchtigkeit;
float luftdruck;

int   ina226_addr = 0x40;
int   shunt;
int   shunt_logger;
int   p_map;
int   p_ueber;
volatile int regel;
int   schalter;
int   error;
int   error_counter;

int   zaehler;
int   messung_1;
int   messung_2;
int   mess;

int   status_absorption;
int   status_float;
int   up_down;

int   ledPin =  LED_BUILTIN;
int   sim900_pin = 9;

int   K1 = 59;
int   K2 = 58;
int   K3 = 57;
int   K4 = 56;

byte  status_K1 = HIGH;
byte  status_K2 = HIGH;
byte  status_K3 = HIGH;
byte  status_K4 = HIGH;

int   p_K1 =  5;  //<<<<----p AN K1 FESTLEGEN
int   p_K2 = 10;  //<<<<----p AN K2 FESTLEGEN
int   p_K3 = 15;  //<<<<----p AN K3 FESTLEGEN
int   p_K4 = 20;  //<<<<----p AN K4 FESTLEGEN

byte  lcd_char_up_down[8] = {B00100, B01110, B10101, B00100, B10101, B01110, B00100, B00000};
byte  lcd_char_up[8]      = {B00100, B01110, B10101, B00100, B00100, B00100, B00100, B00000};
byte  lcd_char_down[8]    = {B00100, B00100, B00100, B00100, B10101, B01110, B00100, B00000};
//****************
void setup()
{
  Serial.begin (19200);        //USB
  Serial1.begin(19200);        //Victron1_MPPT 12 Volt
  Serial2.begin(19200);        //Victron2_MPPT 24 Volt
  Serial3.begin(19200);        //Victron3_BMV  24 Volt
  Serial_SIM900.begin(19200);  //SIM900

  Wire.begin();
  Wire.setClock(400000L);

  //writeRegister(0x00, 0x4E35);
  writeRegister(0x00, 0x4E3D);

  lcd.init();
  lcd.backlight();
  lcd.clear();
  fest_display();

  bme.begin(0x76);

  pinMode(sim900_pin, OUTPUT);
  digitalWrite(sim900_pin, LOW);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  pinMode(K1, OUTPUT);
  pinMode(K2, OUTPUT);
  pinMode(K3, OUTPUT);
  pinMode(K4, OUTPUT);
  relais();

  lcd.createChar(0, lcd_char_up_down);
  lcd.createChar(1, lcd_char_up);
  lcd.createChar(2, lcd_char_down);

  pinMode(interruptPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(interruptPin), nulldurchgang, RISING);
  DDRA |= (1 << PA0);
}
//****************
void loop()
{
  //Serial.print("Ram frei: "); Serial.println(freeRam());  //4014

  vic1_serial();
  vic2_serial();
  vic3_serial();
  sim900_error();

  time1();
  time2();
  time3();
  time4();
}
//****************
int freeRam()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
//****************
void time1()
{
  static unsigned long prev_millis;
  if (millis() - prev_millis > 500)
  {
    vic2_anfragen();
    vic2_display();
    ina_226();
    ueberschuss();
    ueberschuss_display();
    prev_millis = millis();
  }
}
void time2()
{
  static unsigned long prev_millis;
  if (millis() - prev_millis > 750)
  {
    vic1_anfragen();
    vic1_display();
    vic3_anfragen();
    vic3_display();
    prev_millis = millis();
  }
}
void time3()
{
  static unsigned long prev_millis;
  if (millis() - prev_millis > 1000)
  {
    thingspeak();
    bme280();
    bme280_display();
    prev_millis = millis();
  }
}
void time4()
{
  static unsigned long prev_millis;
  if (millis() - prev_millis > 300000)
  {
    lcd.clear();
    fest_display();
    prev_millis = millis();
  }
}
//****************
void vic1_anfragen()
{
  Serial1.println(F(":7D3ED008E"));
}
//****************
void vic2_anfragen()
{
  Serial2.println(F(":7D3ED008E"));
}
//****************
void vic3_anfragen()
{
  Serial3.println(F(":78DED00D4"));
  Serial3.println(F(":78CED00D5"));
  Serial3.println(F(":78EED00D3"));
  Serial3.println(F(":71003003B"));
  Serial3.println(F(":71103003A"));
  Serial3.println(F(":706030045"));
  Serial3.println(F(":707030044"));
  Serial3.println(F(":7FF0F0040"));
}
//****************
void vic1_serial()
{
  static byte index;
  while (Serial1.available())
  {
    char c = Serial1.read();
    if (c == '\n' && index > 0)
    {
      vic1_ser[index] = '\0';
      index = 0;
      if (((strncmp(vic1_ser, ":7", 2) == 0) || (strncmp(vic1_ser, ":A", 2) == 0)) && (strncmp(vic1_ser, "Checksum", 8) != 0))
      {
        vic1_auswerten();
      }
    }
    else if (index < vicbuf - 1)
    {
      vic1_ser[index++] = c;
    }
  }
}
//****************
void vic2_serial()
{
  static byte index;
  while (Serial2.available())
  {
    char c = Serial2.read();
    if (c == '\n' && index > 0)
    {
      vic2_ser[index] = '\0';
      index = 0;
      //Serial.println(vic2_ser);
      if (((strncmp(vic2_ser, ":7", 2) == 0) || (strncmp(vic2_ser, ":A", 2) == 0)) && (strncmp(vic2_ser, "Checksum", 8) != 0))
      {
        vic2_auswerten();
      }
    }
    else if (index < vicbuf - 1)
    {
      vic2_ser[index++] = c;
    }
  }
}
//****************
void vic3_serial()
{
  static byte index;
  while (Serial3.available())
  {
    char c = Serial3.read();
    if (c == '\n' && index > 0)
    {
      vic3_ser[index] = '\0';
      index = 0;
      vic3_auswerten();
    }
    else if (index < vicbuf - 1)
    {
      vic3_ser[index++] = c;
    }
  }
}
//********************
void sim900_error()
{
  static byte index;
  while (Serial_SIM900.available())
  {
    char c = Serial_SIM900.read();
    if (c == '\r' && index > 0)
    {
      sim900_ser[index] = '\0';
      index = 0;
      if (strncmp(sim900_ser, "\nERROR", 6) == 0)
      {
        error++;
        error_counter++;
      }
    }
    else if (index < sim900buf - 1)
    {
      sim900_ser[index++] = c;
    }
  }
}
//********************
void vic1_auswerten()
{
  if (strncmp(vic1_ser, ":AD5ED00", 8) == 0)
  {
    char str[5] = "";
    char sub3[3] = "";
    strncpy(sub3, &vic1_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -375 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic1_v_mppt = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic1_ser, ":AD7ED00", 8) == 0)
  {
    char str[5] = "";
    char sub3[3] = "";
    strncpy(sub3, &vic1_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -377 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic1_i_mppt = ergebniss / 10.0;
    }
    return;
  }
  if (strncmp(vic1_ser, ":ABBED00", 8) == 0)
  {
    char str[5] = "";
    char sub3[3] = "";
    strncpy(sub3, &vic1_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -349 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic1_vpv_mppt = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic1_ser, ":ABCED00", 8) == 0)
  {
    char str[9] = "";
    char sub5[3] = "";
    strncpy(sub5, &vic1_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic1_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic1_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -350 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic1_ppv_mppt = ergebniss / 100;
    }
    return;
  }
  if (strncmp(vic1_ser, ":A010200", 8) == 0)
  {
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int checksum = ergebniss;
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    byte xxx = 72 - a;
    if (xxx == checksum)
    {
      vic1_cs_mppt = ergebniss;
    }
    return;
  }
  if (strncmp(vic1_ser, ":7D3ED00", 8) == 0)
  {
    char str[5] = "";
    char sub3[3] = "";
    strncpy(sub3, &vic1_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic1_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic1_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -370 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic1_h20_mppt = ergebniss * 10;
    }
    return;
  }
}
//****************
void vic2_auswerten()
{
  if (strncmp(vic2_ser, ":AD5ED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic2_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -375 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic2_v_mppt_r = ergebniss;
      vic2_v_mppt = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic2_ser, ":AD7ED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic2_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -377 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic2_i_mppt = ergebniss / 10.0;
    }
    return;
  }
  if (strncmp(vic2_ser, ":ABBED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic2_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -349 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic2_vpv_mppt = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic2_ser, ":ABCED00", 8) == 0)
  {
    digitalWrite(ledPin, HIGH);
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic2_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic2_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic2_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -350 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic2_ppv_mppt = ergebniss / 100;
    }
    digitalWrite(ledPin, LOW);
    return;
  }
  if (strncmp(vic2_ser, ":A010200", 8) == 0)
  {
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int checksum = ergebniss;
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    byte xxx = 72 - a;
    if (xxx == checksum)
    {
      vic2_cs_mppt = ergebniss;
    }
    return;
  }
  if (strncmp(vic2_ser, ":7D3ED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic2_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic2_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic2_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -370 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic2_h20_mppt = ergebniss * 10;
    }
    return;
  }
}
//****************
void vic3_auswerten()
{
  if (strncmp(vic3_ser, ":78DED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -300 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_v_bmv = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":78CED00", 8) == 0)
  {
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic3_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic3_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -299 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_i_bmv = ergebniss / 1000.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":78EED00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -301 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_p_bmv = ergebniss;
    }
    return;
  }
  if (strncmp(vic3_ser, ":7100300", 8) == 0)
  {
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic3_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic3_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = 59 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_h17_bmv = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":7110300", 8) == 0)
  {
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic3_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic3_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = 58 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_h18_bmv = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":7060300", 8) == 0)
  {
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic3_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic3_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = 69 - a - b - c - d;

    if (xxx == checksum)
    {
      hextodec(str);
      vic3_h7_bmv = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":7070300", 8) == 0)
  {
    char str[9];
    char sub5[3] = "";
    strncpy(sub5, &vic3_ser[16], 2);
    sub5[2] = '\0';
    hextodec(sub5);
    int checksum = ergebniss;
    char sub4[3] = "";
    strncpy(sub4, &vic3_ser[14], 2);
    sub4[2] = '\0';
    hextodec(sub4);
    int d = ergebniss;
    strcpy (str, sub4);
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int c = ergebniss;
    strcat (str, sub3);
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcat (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = 68 - a - b - c - d;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_h8_bmv = ergebniss / 100.0;
    }
    return;
  }
  if (strncmp(vic3_ser, ":7FF0F00", 8) == 0)
  {
    char str[5];
    char sub3[3] = "";
    strncpy(sub3, &vic3_ser[12], 2);
    sub3[2] = '\0';
    hextodec(sub3);
    int checksum = ergebniss;
    char sub2[3] = "";
    strncpy(sub2, &vic3_ser[10], 2);
    sub2[2] = '\0';
    hextodec(sub2);
    int b = ergebniss;
    strcpy (str, sub2);
    char sub1[3] = "";
    strncpy(sub1, &vic3_ser[8], 2);
    sub1[2] = '\0';
    hextodec(sub1);
    int a = ergebniss;
    strcat (str, sub1);
    byte xxx = -192 - a - b;
    if (xxx == checksum)
    {
      hextodec(str);
      vic3_soc_bmv = ergebniss / 100.0;
    }
    return;
  }
}
//****************
long hextodec(char*hdec)
{
  ergebniss = 0;
  while (*hdec)
  {
    long onebyte = *hdec++;
    if (onebyte >= '0' && onebyte <= '9')
    {
      onebyte = onebyte - '0';
    }
    else if (onebyte >= 'a' && onebyte <= 'f')
    {
      onebyte = onebyte - 'a' + 10;
    }
    else if (onebyte >= 'A' && onebyte <= 'F')
    {
      onebyte = onebyte - 'A' + 10;
    }
    ergebniss = (ergebniss << 4) | (onebyte & 0xF);
  }
  return ergebniss;
}
//********************
void ina_226()
{
  shunt = readRegister(0x01);
  if (shunt && 0x8000)
  {
    shunt = ~shunt;
    shunt += 1;
    shunt *= -1 ;
  }
  shunt_logger = shunt;
  shunt   = constrain(shunt, 3000, 17500);
  p_map   = (map(shunt, 3000, 17500, 0, 13000 )) / 10;
  p_ueber = (p_map - vic2_ppv_mppt);
  //p_ueber = constrain(p_ueber, 0, 1300);
}
//********************
void ueberschuss()
{
  if (vic2_cs_mppt != 4 && vic2_cs_mppt != 5)
  {
    reset();
    relais();
    return;
  }
  if (vic2_cs_mppt == 4 && status_float == 0)
  {
    status_absorption = 0;
    status_float = 1;
    reset();
    relais();
  }
  if (vic2_cs_mppt == 5 && status_absorption == 0)
  {
    status_absorption = 1;
    status_float = 0;
    reset();
    relais();
  }
  if (zaehler < 120)
  {
    if (zaehler < 60)
    {
      messung_1 = samples1.getMedian();
      mess = 1;
    }
    if (zaehler >= 60)
    {
      messung_2 = samples2.getMedian();
      mess = 2;
    }
    samples1.add(vic2_v_mppt_r);
    samples2.add(vic2_v_mppt_r);
    zaehler++;
  }
  if (zaehler == 120)
  {
    mess = 3;
    if (abs(messung_1 - messung_2) <= 3)  //<<<<<----- 0.03 Volt
    {
      if (vic2_v_mppt_r > (min(messung_1, messung_2)) - 20)  //<<<<<-----0.2 Volt
      {
        if (p_ueber > p_K1 && status_K2 == HIGH && status_K3 == HIGH && status_K4 == HIGH)
        {
          status_K1 = LOW;
        }
        if (p_ueber <= 0 && status_K2 == HIGH && status_K3 == HIGH && status_K4 == HIGH)
        {
          status_K1 = HIGH;
        }
        if (p_ueber > p_K2 && status_K1 == LOW && status_K3 == HIGH && status_K4 == HIGH)
        {
          status_K2 = LOW;
        }
        if (p_ueber <= 0 && status_K1 == LOW && status_K3 == HIGH && status_K4 == HIGH)
        {
          status_K2 = HIGH;
        }
        if (p_ueber > p_K3 && status_K1 == LOW && status_K2 == LOW && status_K4 == HIGH)
        {
          status_K3 = LOW;
        }
        if (p_ueber <= 0 && status_K1 == LOW && status_K2 == LOW && status_K4 == HIGH)
        {
          status_K3 = HIGH;
        }
        if (p_ueber > p_K4 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW)
        {
          status_K4 = LOW;
        }
        if (p_ueber <= 0 && regel == 0 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW)
        {
          status_K4 = HIGH;
          up_down = 0;
        }
        if (p_ueber > 100 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW && status_K4 == LOW)
        {
          static unsigned long prev_millis;
          if (millis() - prev_millis > 2000)
          {
            prev_millis = millis();
          }
          regel++;
          up_down = 1;
        }
        if (p_ueber <= 20 && status_K1 == LOW && status_K2 == LOW && status_K3 == LOW && status_K4 == LOW)
        {
          regel--;
          up_down = 2;
        }
      }
      else
      {
        regel = regel - 2;
        up_down = 2;
      }
    }
    else
    {
      reset();
    }
  }
  relais();
  regel = constrain(regel, 0, 20);
}
//****************
void nulldurchgang()
{
  //regel = 8;
  if (counter == 20) counter = 0;
  if (counter == 0) Status = 1;
  if (counter == regel) Status = 0;
  PORTA = (Status << PA0);
  counter++;
}
//********************
void reset()
{
  zaehler = 0;
  messung_1 = 0;
  messung_2 = 0;
  mess = 0;
  regel = 0;
  up_down = 0;
  status_K1 = HIGH;
  status_K2 = HIGH;
  status_K3 = HIGH;
  status_K4 = HIGH;
}
//********************
void relais()
{
  digitalWrite(K1, status_K1);
  digitalWrite(K2, status_K2);
  digitalWrite(K3, status_K3);
  digitalWrite(K4, status_K4);
}
//********************
void thingspeak()
{
  schalter++;
  switch (schalter)
  {
    case   1: digitalWrite(sim900_pin, HIGH); break;
    case   2: digitalWrite(sim900_pin, LOW); break;
    case  22: Serial_SIM900.println(F("AT+CIPSHUT")); break;
    case  24: Serial_SIM900.println(F("ATE0")); break;
    case  26: Serial_SIM900.println(F("AT+CIPMUX=0")); break;
    case  28: Serial_SIM900.println(F("AT+CSTT=\"internet\"")); break;
    case  30: Serial_SIM900.println(F("AT+CIICR")); break;
    case  32: Serial_SIM900.println(F("AT+CIFSR")); break;
    case  34: Serial_SIM900.println(F("AT+CIPSPRT=0")); break;
    case  36: Serial_SIM900.println(F("AT+CSQ")); break;
    case  38: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;
    case  41: Serial_SIM900.println(F("AT+CIPSEND")); break;
    case  43: daten1(); break;
    case  45: Serial_SIM900.println((char)26); break;
    case  53: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;
    case  56: Serial_SIM900.println(F("AT+CIPSEND")); break;
    case  58: daten2(); break;
    case  60: Serial_SIM900.println((char)26); break;
    case  68: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;
    case  71: Serial_SIM900.println(F("AT+CIPSEND")); break;
    case  73: daten3(); break;
    case  75: Serial_SIM900.println((char)26); break;
    case  83: Serial_SIM900.println(F("AT+CIPSTART=\"TCP\",\"api.thingspeak.com\",\"80\"")); break;
    case  86: Serial_SIM900.println(F("AT+CIPSEND")); break;
    case  88: daten4(); break;
    case  90: Serial_SIM900.println((char)26); break;
    case  98:
      schalter = 37;
      if (error >= 1)
      {
        schalter = 21;
        error = 0;
      }
      break;
  }
}
//................
void daten1()
//MPPT 100/50 12 Volt
{
  char v[10];
  char i[10];
  char vpv[10];
  char ppv[10];
  char h20[10];
  char cs[10];

  dtostrf(vic1_v_mppt, 1, 2, v );
  dtostrf(vic1_i_mppt, 1, 2, i );
  dtostrf(vic1_vpv_mppt, 1, 2, vpv );
  itoa(vic1_ppv_mppt, ppv, 10 );
  itoa(vic1_h20_mppt, h20, 10 );
  itoa(vic1_cs_mppt, cs, 10 );

  char daten1[180] = "GET http://api.thingspeak.com/update?api_key=MC6V8698TB8GXDS3&field1=";
  strcat (daten1, v);  //MPPT Spannung
  strcat (daten1, "&field2=");
  strcat (daten1, i);  //MPPT Strom
  strcat (daten1, "&field3=");
  strcat (daten1, vpv);  //PV Spannung
  strcat (daten1, "&field4=");
  strcat (daten1, ppv);  //PV Leistung
  strcat (daten1, "&field5=");
  strcat (daten1, h20);  //Wh/Tag
  strcat (daten1, "&field6=");
  strcat (daten1, cs);  //Status
  Serial_SIM900.println(daten1);
}
//................
void daten2()
//MPPT 100/50 24 Volt
{
  char v[10];
  char i[10];
  char vpv[10];
  char ppv[10];
  char h20[10];
  char cs[10];
  char p_ueber_[10];
  char regel_[10];

  dtostrf(vic2_v_mppt, 1, 2, v );
  dtostrf(vic2_i_mppt, 1, 2, i );
  dtostrf(vic2_vpv_mppt, 1, 2, vpv );
  itoa(vic2_ppv_mppt, ppv, 10 );
  itoa(vic2_h20_mppt, h20, 10 );
  itoa(vic2_cs_mppt, cs, 10 );
  itoa(p_ueber, p_ueber_, 10 );
  itoa(regel, regel_, 10 );

  char daten2[180] = "GET http://api.thingspeak.com/update?api_key=5Y645SG09QQZ3NA8&field1=";
  strcat (daten2, v);  //MPPT Spannung
  strcat (daten2, "&field2=");
  strcat (daten2, i);  //MPPT Strom
  strcat (daten2, "&field3=");
  strcat (daten2, vpv);  //PV Spannung
  strcat (daten2, "&field4=");
  strcat (daten2, ppv);  //PV Leistung
  strcat (daten2, "&field5=");
  strcat (daten2, h20);  //Wh/Tag
  strcat (daten2, "&field6=");
  strcat (daten2, cs);  //Status
  strcat (daten2, "&field7=");
  strcat (daten2, p_ueber_); // Überschuss Leistung
  strcat (daten2, "&field8=");
  strcat (daten2, regel_);  // Last 0 - 255
  Serial_SIM900.println(daten2);
}
//................
void daten3()
//BMV 702 24 Volt
{
  char v[10];
  char i[10];
  char p[10];
  char h18[10];
  char h17[10];
  char h8[10];
  char h7[10];
  char soc[10];

  dtostrf(vic3_v_bmv, 1, 2, v );
  dtostrf(vic3_i_bmv, 1, 2, i );
  itoa(vic3_p_bmv, p , 10 );
  dtostrf(vic3_h18_bmv, 1, 2, h18 );
  dtostrf(vic3_h17_bmv, 1, 2, h17 );
  dtostrf(vic3_h8_bmv, 1, 2, h8 );
  dtostrf(vic3_h7_bmv, 1, 2, h7 );
  dtostrf(vic3_soc_bmv, 1, 2, soc );

  char daten3[180] = "GET http://api.thingspeak.com/update?api_key=XDJ604T15I5ZNIWS&field1=";
  strcat (daten3, v);  //BMV Spannung
  strcat (daten3, "&field2=");
  strcat (daten3, i);  //BMV Strom
  strcat (daten3, "&field3=");
  strcat (daten3, p);  //BMV Leistung
  strcat (daten3, "&field4=");
  strcat (daten3, h18);  //KWH geladen
  strcat (daten3, "&field5=");
  strcat (daten3, h17);  //KWH entladen
  strcat (daten3, "&field6=");
  strcat (daten3, h8);  //höchste Spannung
  strcat (daten3, "&field7=");
  strcat (daten3, h7);  //niedrigste Spannung
  strcat (daten3, "&field8=");
  strcat (daten3, soc);  //SOC
  Serial_SIM900.println(daten3);
}
//................
void daten4()
//BME 280 / SIM 900
{
  char temperatur_[10];
  char luftfeuchtigkeit_[10];
  char luftdruck_[10];
  char error_counter_[10];
  char shunt_logger_[10];

  dtostrf(temperatur, 1, 2, temperatur_);
  dtostrf(luftfeuchtigkeit, 1, 2, luftfeuchtigkeit_);
  dtostrf(luftdruck, 1, 2, luftdruck_);
  itoa(error_counter, error_counter_ , 10 );
  itoa(shunt_logger, shunt_logger_ , 10 );

  char daten4[180] = "GET http://api.thingspeak.com/update?api_key=YNYKLGS425SLZ828&field1=";
  strcat (daten4, temperatur_);  //Temperatur
  strcat (daten4, "&field2=");
  strcat (daten4, luftfeuchtigkeit_);  //Luftfeuchtigkeit
  strcat (daten4, "&field3=");
  strcat (daten4, luftdruck_);  //Luftdruck
  strcat (daten4, "&field4=");
  strcat (daten4, error_counter_);  //SIM 900 Error
  strcat (daten4, "&field5=");
  strcat (daten4, shunt_logger_);  //Einstrahlung
  Serial_SIM900.println(daten4);
}
//********************
void fest_display()
{
  lcd.clear();

  lcd.setCursor (5, 0);
  lcd.print(F("V"));
  lcd.setCursor (13, 0);
  lcd.print(F("A"));

  lcd.setCursor (5, 1);
  lcd.print(F("V"));
  lcd.setCursor (13, 1);
  lcd.print(F("A"));

  lcd.setCursor (5, 2);
  lcd.print(F("V"));
  lcd.setCursor (13, 2);
  lcd.print(F("A"));

  lcd.setCursor (5, 3);
  lcd.print(F("W"));

  lcd.setCursor (18, 3);
  lcd.write(0xdf); //Grad Zeichen
  lcd.setCursor (19, 3);
  lcd.print(F("C"));
}
//********************
void vic1_display()
{
  lcd.setCursor (0, 0);
  lcd.print(vic1_v_mppt);

  lcd.setCursor (9, 0);
  if (vic1_i_mppt < 9.995) lcd.print(F(" "));
  lcd.print(vic1_i_mppt, 1);

  lcd.setCursor (15, 0);
  if (vic1_cs_mppt == 0)   lcd.print(F("AUS  "));
  if (vic1_cs_mppt == 2)   lcd.print(F("FAULT"));
  if (vic1_cs_mppt == 3)   lcd.print(F("BULK "));
  if (vic1_cs_mppt == 4)   lcd.print(F("ABS  "));
  if (vic1_cs_mppt == 5)   lcd.print(F("FLOAT"));
  if (vic1_cs_mppt == 7)   lcd.print(F("EQU M"));
  if (vic1_cs_mppt == 245) lcd.print(F("START"));
  if (vic1_cs_mppt == 247) lcd.print(F("EQU A"));
  if (vic1_cs_mppt == 252) lcd.print(F("EXT  "));
}
//********************
void vic2_display()
{
  lcd.setCursor (0, 1);
  lcd.print(vic2_v_mppt);

  lcd.setCursor (9, 1);
  if (vic2_i_mppt < 9.995) lcd.print(F(" "));
  lcd.print(vic2_i_mppt, 1);

  lcd.setCursor (15, 1);
  if (vic2_cs_mppt == 0)   lcd.print(F("AUS  "));
  if (vic2_cs_mppt == 2)   lcd.print(F("FAULT"));
  if (vic2_cs_mppt == 3)   lcd.print(F("BULK "));
  if (vic2_cs_mppt == 4)   lcd.print(F("ABS  "));
  if (vic2_cs_mppt == 5)   lcd.print(F("FLOAT"));
  if (vic2_cs_mppt == 7)   lcd.print(F("EQU M"));
  if (vic2_cs_mppt == 245) lcd.print(F("START"));
  if (vic2_cs_mppt == 247) lcd.print(F("EQU A"));
  if (vic2_cs_mppt == 252) lcd.print(F("EXT  "));
}
//********************
void vic3_display()
{
  lcd.setCursor (0, 2);
  lcd.print(vic3_v_bmv);

  lcd.setCursor (7, 2);
  if (abs(vic3_i_bmv) < 99.995) lcd.print(F(" "));
  if (abs(vic3_i_bmv) < 9.995) lcd.print(F(" "));
  if (vic3_i_bmv >= 0) lcd.print(F(" "));
  lcd.print(vic3_i_bmv, 1);
}
//********************
void ueberschuss_display()
{
  lcd.setCursor (15, 2);
  if (mess == 0) lcd.print(F("     "));
  if (mess == 1) lcd.print(F("MESS1"));
  if (mess == 2) lcd.print(F("MESS2"));
  if (mess == 3) lcd.print(F("UEBER"));

  lcd.setCursor (0, 3);
  if (abs(p_ueber) < 1000) lcd.print(F(" "));
  if (abs(p_ueber) < 100) lcd.print(F(" "));
  if (abs(p_ueber) < 10) lcd.print(F(" "));
  if (p_ueber >= 0) lcd.print(F(" "));
  lcd.print(p_ueber);

  lcd.setCursor (7, 3);
  if (regel < 100) lcd.print(F(" "));
  if (regel < 10) lcd.print(F(" "));
  lcd.print(regel);

  lcd.setCursor (10, 3);
  if (up_down == 0) lcd.write(byte(0));
  if (up_down == 1) lcd.write(byte(1));
  if (up_down == 2) lcd.write(byte(2));
}
//********************
void bme280_display()
{
  lcd.setCursor (12, 3);
  if (abs(temperatur < 9.995)) lcd.print(F(" "));
  if (temperatur >= 0) lcd.print(F(" "));
  lcd.print(temperatur);
}
//********************
static void writeRegister(byte reg, word value)
{
  Wire.beginTransmission(ina226_addr);
  Wire.write(reg);
  Wire.write((value >> 8) & 0xFF);
  Wire.write(value & 0xFF);
  Wire.endTransmission();
}
//********************
static word readRegister(byte reg)
{
  word res = 0x0000;
  Wire.beginTransmission(ina226_addr);
  Wire.write(reg);
  if (Wire.endTransmission() == 0)
  {
    if (Wire.requestFrom(ina226_addr, 2) >= 2)
    {
      res  = Wire.read() * 256;
      res += Wire.read();
    }
  }
  return res;
}
//********************
void bme280()
{
  temperatur = (bme.readTemperature());
  luftfeuchtigkeit = (bme.readHumidity());
  luftdruck = ((bme.readPressure() / 100.0F) + 12.8); //Luftdruck umgerechnet von 103m ueber Meereshoehe auf Meereshoehe
}