#define adresseLM75_1 0x90  // 0b10010000 | bit0=>Richtungsbit 0=Schreiben 1=Lesen  | bit1-3 Slaveadresse A0=0, A1=0 ,A2=0
#define adresseLM75_2 0x92  // 0b10010010 | bit0=>Richtungsbit 0=Schreiben 1=Lesen  | bit1-3 Slaveadresse A0=1, A1=0 ,A2=0
#define numberLM75 2

#include "KORS-Shield.h"

int LM75_Lesen(byte leseadresse, byte pointer) {
  int status = 0;                     // rueckgabewert mit 0 initialisieren
  I2C_start();                        // I2C-Komunikation starten
  I2C_schreiben(leseadresse - 1);    // Slave schreibaufforderung schicken
  I2C_schreiben(pointer);             // Slave Pointer uebergeben
  I2C_start();                        // Repeated start
  I2C_schreiben(leseadresse);        // Slave leseaufforderung schicken
  status = I2C_lesen(false) << 8;     // High-Byte einlesen
  status = status + I2C_lesen(true);  // LOW-Byte einlesen
  I2C_stop();                         // I2C-Komunikation stoppen
  return status;                      // Register-Wert zurueckgeben
}

void LM75_Konfigurieren(byte schreibadresse, byte pointer, byte MSB, byte LSB) {
  I2C_start();                          // I2C-Kommunikation starten
  I2C_schreiben(schreibadresse);        // Slave schreibaufforderung senden
  I2C_schreiben(pointer);               // Slave Pointer uebergeben
  I2C_schreiben(MSB);                   // Slave 
  if(pointer > 1) I2C_schreiben(LSB);
  I2C_stop();
}

void setup() {
  DDRA = 255;
  pinMode(Button0, INPUT_PULLUP);
  EIMSK = EIMSK & 0b11110111;
  EIMSK = EIMSK & 0b11111011;
  EICRA = EICRA & 0b00111111;
  EICRA = EICRA & 0b11001111;
  EICRA = EICRA | 0b10000000;
  EICRA = EICRA | 0b00100000;
  EIMSK = EIMSK | 0b00001000;
  EIMSK = EIMSK | 0b00000100;
  SREG = SREG | (1<<7);
  Serial.begin(9600);  // Seriellen Monitor initialisieren
  I2C_init();          // Initialisierung aufrufen
  for(int i = 0; i < numberLM75; i++) {
    LM75_Konfigurieren((adresseLM75_1|(i<<1)), 1, 2, 0);
    LM75_Konfigurieren((adresseLM75_1|(i<<1)), 2, 255, 128);
    LM75_Konfigurieren((adresseLM75_1|(i<<1)), 3, 0, 0);
  }
}

ISR(INT3_vect) {
  LEDs = 0;
}

ISR(INT2_vect) {
  for(int i = 0; i < numberLM75; i++) {
    int16_t wert = 0;                                           // registerwert mit 0 initialisieren
    wert = LM75_Lesen(((adresseLM75_1|(i<<1)) + 1), 0) >> 7;    // Undefined-Bereich rausschieben
    if (wert >= 0) LEDs = LEDs | (1<<i);
  }
}

void loop() { 
}

/*******************************************************************************************************************
                                      Ab hier nichts ändern!!!
*******************************************************************************************************************/
#define SDA 20
#define SCL 21
#define set_SDA digitalWrite(SDA, HIGH)
#define clr_SDA digitalWrite(SDA, LOW)
#define set_SCL digitalWrite(SCL, HIGH)
#define clr_SCL digitalWrite(SCL, LOW)

void I2C_init() {        // Initialisierung
  pinMode(SDA, OUTPUT);  // SDA als Output
  pinMode(SCL, OUTPUT);  // SCL als Output
  delay(1);              // 1ms warten
  set_SDA;               // SDA setzen
  set_SCL;               // SCL setzen
  delay(1);              // 1ms warten
}
void I2C_start() {  // Startbedingung
  set_SDA;          // SDA setzen
  set_SCL;          // SCL setzen
  delay(1);         // 1ms warten
  clr_SDA;          // SDA zurücksetzen -> Startbeningung
  delay(1);         // 1ms warten
  clr_SCL;          // SCL zurücksetzen
  delay(1);         // 1ms warten
}
void I2C_stop() {  // Stopbedingung
  clr_SCL;         // SCL zurücksetzen
  clr_SDA;         // SDA zurücksetzen
  delay(1);        // 1ms warten
  set_SCL;         // SCL setzen
  delay(1);        // 1ms warten
  set_SDA;         // SDA setzen -> Stopbeningung
  delay(1);        // 1ms warten
}
bool I2C_schreiben(byte daten) {  // Wert in Slave schreiben
  bool datenbit, ACK_Flag;        // lokale variablen deklarieren
  for (int i = 7; i >= 0; i--) {  // for-Schleife um daten bitweise zu versenden mit MSB starten
    datenbit = (daten >> i) % 2;  // daten um i Stellen nach rechts verschieben und LSB in datenbit schreiben
    if (datenbit) set_SDA;        // wenn datenbit 1 SDA setzen
    else clr_SDA;                 // anderenfalls SDA zurücksetzen
    set_SCL;                      // SCL setzen
    delay(1);                     // 1ms warten
    clr_SCL;                      // SCL zurücksetzen
    delay(1);                     // 1ms warten
  }
  pinMode(SDA, INPUT_PULLUP);   // SDA als Input definieren auf GND geschaltet
  delay(1);                     // 1ms warten
  set_SCL;                      // SCL setzen
  delay(1);                     // 1ms warten
  ACK_Flag = digitalRead(SDA);  // SDA lesen und  in ACK_Flag schreiben den der Slave auf LOW setzt => ACK
  clr_SCL;                      // SCL zurücksetzen
  pinMode(SDA, OUTPUT);         // SDA als Output definieren
  delay(1);                     // 1ms warten
  return ACK_Flag;              // ACK_Flag zurückgeben
}
byte I2C_lesen(bool ACK_Flag) {                // Wert aus Slave lesen
  byte daten = 0;                              // lokale Variable daten initialisieren
  pinMode(SDA, INPUT);                         // SDA als Input
  for (int i = 7; i >= 0; i--) {               // Laufvariable i 7-0
    set_SCL;                                   // SCL setzen
    delay(1);                                  // 1ms warten
    daten = daten | (digitalRead(SDA) << i);   // datenbit aus Slave lesen und in daten speichern
    clr_SCL;                                   // SCL zurücksetzen
    delay(1);                                  // 1ms warten
  }
  pinMode(SDA, OUTPUT);    // SDA als Output
  if (ACK_Flag) set_SDA;   // Wenn NACK (HIGH) SDA setzen => Lesevorgang beenden
  else clr_SDA;            // sonst ACK (LOW) SDA zurücksetzen => Weiterlesen
  delay(1);                // 1ms warten
  set_SCL;                 // SCL setzen
  delay(1);                // 1ms warten
  clr_SCL;                 // SCL zurücksetzen
  delay(1);                // 1ms warten
  return daten;            // daten zurückgeben
}