//
// Befehle/Daten -> Byte-Stream
//
// Vor dem Daten befindet sich eine Sync-Phase.
// Im Anschluss wird ein Bit geschickt, das zwischen Schalter und Temperatur unterscheidet.
// Es folgen dann ein (Schalter) oder acht (Temperatur) Bits mit Daten.
//
// Zeiten für Sync und Flag/Daten sind fest vorgeben (BIT-Frequenz)
//
// Schalter
// _ _ _________________   _ _ _ ,-- HIGH-Value
// _X_X_/               \_/ X_X_ ,-- LOW-Value
//       :             : : : :
//       ^             ^ ^ ^ ^
//       |             | | | |
//       |--- SYNC ----| ^ F S
//       |\____________/ | ^ ^
//       |       ^       | | |
//       ^       |       | | |
//       |       |       | | '- Bit LOW -> Schalter OPEN, HIGH -> SCHALTER CLOSED
//       |       |       | |
//       |       |       | '- Bit HIGH -> Schalter
//       |       |       |
//       |       |       '- Ende Sync-Zeit (HIGH->LOW-Flanke startet Bit-Frequenz)
//       |       |
//       |       '- Sync-Zeit Signal steht auf HIGH
//       |
//       '- Start der Messung (Wird durch Software initiiert)
// 
// Temperatur
// _ _ _________________     _ _ _ _ _ _ _ _  ,-- HIGH-Value
// _X_X_/               \___X_X_X_X_X_X_X_X_  ,-- LOW-Value
//       :             : : : : : : : : : : :
//       ^             ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
//       |             | | | | | | | | | | |
//       |--- SYNC ----| ^ F 0 1 2 3 4 5 6 7
//       |\____________/ | ^ \_____________/
//       |       ^       | |        ^
//       ^       |       | |        |
//       |       |       | |        '- Bit im Byte (Bit-Nummer)
//       |       |       | |           Temperatur (Codierung?)
//       |       |       | |
//       |       |       | '- Bit LOW -> Temperatur
//       |       |       |
//       |       |       '- Ende Sync-Zeit (HIGH->LOW-Flanke startet Bit-Frequenz)
//       |       |
//       |       '- Sync-Zeit Signal steht auf HIGH
//       |
//       '- Start der Messung (Wird durch Software initiiert)
//

///////////////////////////////////////////////////////////
// Ausgaben auf Serial

#define DEBUG

#ifdef DEBUG
#define INFO(text,value) \
  do {                   \
    Serial.print(text);  \
    Serial.println(value); \
  } while (0)
#else
#define INFO(text,value) do{}while(0)
#endif

///////////////////////////////////////////////////////////
// Zeitkonstanten
const int DELTA_T = 100;          // ms (definiert Bit-Frequenz)
const int SYNC_T  = 12 * DELTA_T; // ms (Sync-Zeit)

///////////////////////////////////////////////////////////
// input - output

const int SIGNALLED  = 13; // Sende-LED-Pin
const int LED        = 14; // Anzeige, das Taste gedrückt
const int LDR        = A0; // Fotowiderstand
const int TEMPSENSOR = A1; // TEMP-Pin

///////////////////////////////////////////////////////////
// De- und Encoder

// Es wird nur die Temperatur oder die Schalterstellung übertragen
enum DataType {
  TEMP   = 0, // LOW-Bit
  SWITCH = 1, // HIGH-Bit
};

bool dataTypeToFlag (DataType type) {
  return type;
}

DataType flagToDataType (bool flag) {
  return flag?SWITCH:TEMP;
}

uint8_t databits(int flag) {
  return (flag==TEMP)?8:1;
}

byte    decodeTemp   (uint8_t temp) { return temp;       } // TODO
uint8_t encodeTemp   (byte data)    { return data;       } // TODO
byte    decodeButton (bool button)  { return button?1:0; }
bool    encodeButton (byte data)    { return data != 0;  }

///////////////////////////////////////////////////////////
// Input-Output-Routinen

uint8_t readTemp() { return 13; } // TODO
bool readSwitch() {return false; } // TODO

void showTemp(byte data) {} // TODO
void showSwitch(byte data){} // TODO

// Signal wird gesetzt
void writeSignal(bool b) {
  digitalWrite(SIGNALLED,b);
}

bool readSignal() { // todo
  return true;
}

///////////////////////////////////////////////////////////
// sender

// Initialisierung des Senders
void setupSender() {
  INFO("setupSender","");
  pinMode(SIGNALLED, OUTPUT);
  writeSignal(LOW);
}

// Bit-Stream auf Signal ausgeben
// Sync-Signal, Flag und Byte erzeuen
void sendBits(DataType type, byte data) {
  INFO("setupSender","");
  // Sync senden
  INFO("sync","");
  writeSignal(HIGH);
  delay(SYNC_T);
  writeSignal(LOW);
  delay(DELTA_T);
  // Typ senden
  INFO("type","");
  writeSignal(dataTypeToFlag(type));
  delay(DELTA_T);
  // Daten senden
  uint8_t bits = databits(type);
  INFO("bits:",bits);
  for(int i=0; i<bits; i++) {
    INFO("bit: ",bitRead(data,i));
    writeSignal(bitRead(data,i));
    delay(DELTA_T);
  }
}

void sendSwitch() {
  byte data = decodeTemp(readSwitch());
  sendBits(SWITCH,data);
}

void sendTemp() {
  byte data = decodeTemp(readTemp());
  sendBits(TEMP,data);
}

void sender () {
  sendSwitch();
  sendTemp  ();
}

///////////////////////////////////////////////////////////
// receiver

void setupReceiver() { // TODO
  // Analog-Input automatisch definiert
}

void receiver () {
  // Sync-Signal
  while (!readSignal()) {
    delay(1); // 1 ms
  }
  long int startTime = millis();
  while(readSignal()) {
    delay(1); // 1 ms
  }
  long int endTime = millis();
  if ((endTime-startTime<SYNC_T)) {
    return; // Sync-HIGH-Signal is to short
  }
  // read allways in the center of a bit-signal
  delay(DELTA_T/2);
  if (readSignal()) {
    return; // no Sync-LOW-Signal
  }
  delay(DELTA_T);
  DataType type = flagToDataType(readSignal());
  uint8_t bits = databits(type);
  byte data = 0;
  for(int i=0; i<bits; i++) {
    delay(DELTA_T);
    bitWrite(data,i,readSignal());
  }
  if (type==TEMP) {
    showTemp(data);
  }
  if (type==SWITCH) {
    showSwitch(data);
  }
}

///////////////////////////////////////////////////////////
// Hauptprogramm (setup+loop)

void setup() {
  Serial.begin(9600);
  setupSender();
  setupReceiver();
}

void loop() {
  sender();
  // receiver();
}