// Aufbau

// TX (Transmitter)
// RX (Receiver)
// TR (Transceiver)

//######################################################
// Protocol
//######################################################

const int DELTA_T = 1000; // ms
const int SYNC_T  = 12 * DELTA_T;

//######################################################
// Time Control
//######################################################

typedef long int action_t;

// action time for sender and receiver
action_t senderNextActionTime;
action_t receiverNextActionTime;

void setActionTime(action_t *actionTime, long int time) {
  *actionTime = time;
}

void getActionTime(action_t *actionTime) {
  return *actionTime;
}

void incActionTime(action_t *actionTime, long int deltaTime) {
  setActionTime(actionTime,getActionTime(actionTime)+deltaTime)
}

bool actionTime(action_t *actionTime) {
  return *actionTime <= milis();
}

// setActionTime(&senderNextActionTime,time);
// actionTime(&senderNextActionTime)

/////////////////////////////////////////////////////////////////////////////////////////////////
// struct and routines for sender 
struct Sender {
  static const unsigned int vecLen = 10; // Vektorlänge
  uint32_t signalTime [vecLen];   // eine Sequenz von Zeitpunkten
  bool     signal     [vecLen];   // für jeden Zeitpunt der Signalzustand ab diesem Zeitpunkt
  // aktueller Senderzustand
  // <0  Sender aus (Signal aus)
  // >=0 index in signalTime und signal
  int state;
  // Ausgabe-Pin
  unsigned int pin;
};
typedef struct Sender Sender;

void initSender(Sender *sender, const unsigned int pin ) {
  sender->pin = pin;
  sender->state = -1;
  showSignal(sender);
}



// initialisieren des Senders um ein BYTE zu übertragen
void sendData (Sender *sender, long unsigned int startTime, byte s) {
  sender->signalTime[0]  = startTime;
  sender->signal[0] = true;
  startTime += SYNC_T;
  sender->signalTime[1]  = startTime;
  sender->signal[1] = false;
  for( int i = 0; i<8; i++ ) {
    startTime += DELTA_T;
    sender->signalTime[2+i]  = startTime;
    sender->signal[2+i] = bitRead(s,i);
  }
  // sender ist aktiv (state>=0)
  sender->state=0;

}



void showSignal(Sender *sender) {
  if (sender->state < 0) {
    digitalWrite(sender->pin,LOW);
  } else {
    digitalWrite(sender->pin,sender->signal[sender->state]);
  }
}


/**

// Sender anpassen, Signal anpassen
bool senderUpdate(Sender *sender) {
  if ( sender->state <   0 ) {
    return false; // keine Daten zum senden
  }
  if ( sender->state >= sender->vecLen ) { 
    sender->state = -1;    // alle Bits gesendet
    showSignal(sender);
    return false;
  }
  if ( sender->signalTime[sender->state] > millis() ) {
    return true; // alter Zustand bleibt erhalten
  }
  // Signal neu setzen
  showSignal(sender);
  // Zusandszähler erhöhen
  sender->state++;
  return true;
}

**/

///////////////////////////////////////////////////////////////////////////////////////////////
// struct and routines for receiver
struct Receiver{
  static const unsigned int vecLen = 10; // Vektorlänge
  uint32_t signalTime [vecLen];   // eine Sequenz von Zeitpunkten
  bool     signal     [vecLen];   // für jeden Zeitpunt der Signalzustand für diesen Zeitpunkt
  // aktueller Receiverzustand
  // <0  Receiver aus
  // >=0 index in signalTime und signal
  int state;
  // Eingabe-Analog-Pin
  unsigned int pin;
  bool sync; // Wurde ein SyncSignal erkannt?
};
typedef struct Receiver Receiver;

bool getSignal(Receiver *receiver) {
  return false;
}
bool waitForSync(struct Receiver *receiver) {return false;}
bool updateReceiver(struct Receiver *receiver) {return false;}
byte getDate(struct Receiver *receiver) {return 0;}

// Sender sender;

void setup() {
//  initSender(&sender,13);
//  showSignal(&sender);
  Serial.begin(9600);
}

void loop() {
/*  if ( ! senderUpdate(&sender) ) {
    byte data = 0b10110101;
    sendData(&sender,millis(),data);
  }
/*
  if ( syncSignal(&receiver) ) {
    if ( ! receiverUpdate(&receiver) ) {
      byte data = getDate(&receiver);
    }
  }
*/
}