const int adcPin = A0; // ADC-Pin
const int serialBaudRate = 115200; // Baudrate des seriellen Monitors
const float toggleDelay = 0.2; // Verzögerung zwischen dem Umschalten der Bits, in Mikrosekunden

void setup() {
  Serial.begin(serialBaudRate); // Starten des seriellen Monitors
  analogReadResolution(12);

}

void loop() {
  uint32_t buffer[8] = {0}; // Initialisierung des Puffer-Arrays mit Nullen
  uint8_t bitCount = 0; // Anzahl der erzeugten Bits

  for (int i = 0; i < 8; i++) {
    uint32_t randomValue = 0; // Initialisierung der zufälligen Zahl
    
    while (bitCount < 32) {
      uint16_t adcValue = analogRead(adcPin); // Lesen des ADC-Werts
      uint32_t newBit = adcValue & 0x01; // Extrahieren des LSB aus dem ADC-Wert
      randomValue = (randomValue << 1) | newBit; // Hinzufügen des neuen Bits an das LSB
      bitCount++; // Inkrementierung der Anzahl der erzeugten Bits
      delay(toggleDelay); // Verzögerung
    }
  
    buffer[i] = randomValue; // Speichern des zufälligen Werts im Puffer-Array
    bitCount = 0; // Zurücksetzen der Anzahl der erzeugten Bits
  }

//  Serial.print("Zahl: ");
  for (int i = 0; i < 8; i++) {
    //Serial.print(vonNeumannAlgorithm(formatBinary(buffer[i]))); // Ausgabe der erzeugten 32-Bit-Werte im binären Format mit von neumann
    Serial.print(formatBinary(buffer[i])); // Ausgabe der erzeugten 32-Bit-Werte im binären Format ohne von Neumann
    //Serial.print(changeToAscii(vonNeumannAlgorithm(formatBinary(buffer[i]))));
    //Serial.print(binaryToHex(vonNeumannAlgorithm(formatBinary(buffer[i]))));


  }
//  Serial.println(); // Neue Zeile zur Trennung von anderen Ausgaben
}

String formatBinary(uint32_t number) {
  String binaryString = String(number, BIN); // aendern zwischen HEX und BIN moeglich, naechste Zeile mit aendern
  while (binaryString.length() < 32) {        // bei HEX 8, fuer BIN 32
    binaryString = "0" + binaryString;
  }
  return binaryString;
}

String vonNeumannAlgorithm(String binaryString) {
  String generatedString = ""; // erzeugter String
  int lastIndex = binaryString.length() - 1; // Index des letzten Bits im String
  
  // Durchlaufen der Bits paarweise
  for (int i = 0; i < lastIndex; i += 2) {
    if (binaryString.charAt(i) == '0' && binaryString.charAt(i+1) == '1') {
      generatedString += '0';
    } else if (binaryString.charAt(i) == '1' && binaryString.charAt(i+1) == '0') {
      generatedString += '1';
    } 
    // wenn beide Bits gleich sind, werden sie verworfen
  }
  
  return generatedString; // Rückgabe des erzeugten Strings
}

String changeToAscii(String binaryString) {
  String asciiString = ""; // Initialisierung des ASCII-Strings
  int numChunks = binaryString.length() / 8; // Anzahl der 8-Bit-Chunks im binären String

  // Durchlaufen der 8-Bit-Chunks
  for (int i = 0; i < numChunks; i++) {
    String chunk = binaryString.substring(i*8, (i+1)*8); // Extrahieren des aktuellen 8-Bit-Chunks
    char asciiChar = char(strtoul(chunk.c_str(), NULL, 2)); // Konvertieren des 8-Bit-Chunks in ein ASCII-Zeichen
    asciiString += asciiChar; // Hinzufügen des ASCII-Zeichens zum ASCII-String
  }
  
  return asciiString; // Rückgabe des erzeugten ASCII-Strings
}

String binaryToHex(String binaryString) {
  String hexString = "";
  for (int i = 0; i < binaryString.length(); i += 4) {
    char chunk[5]; // temporary char array to hold the 4-bit chunk
    binaryString.substring(i, i+4).toCharArray(chunk, 5); // copy the chunk to the char array
    int value = strtol(chunk, NULL, 2); // convert the chunk to an integer with base 2
    hexString += String(value, HEX); // format the integer as a hexadecimal string
  }
  return hexString;
}



//to do -> bin String to ASCII