Maak Een Loop Timinsysteem Met Df Mijni En

#include <Arduino.h>
#include <EEPROM.h>
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>


// Hoisted type definitions
enum TimerState { READY, STARTING, RUNNING, FINISHED };

struct TimerConfig {
  uint16_t magic;
  uint16_t debounceMs;
  uint16_t startLeadMs;
  uint16_t finishArmMs;
  uint16_t resultHoldMs;
  uint8_t darkSamples;
  uint8_t thresholdPercent;
  uint16_t minimumThreshold;
  uint8_t volume;
};


// Forward declarations
void setDefaults();
void saveConfig();
void loadConfig();
int readLightAverage(uint8_t samples);
void calculateThreshold();
void sendConfig();
void reportReady();
void calibrate();
bool setValue(const char *key, long value);
void processCommand();
bool startButtonPressed();
void beginStartSequence();
void beginRun();
void finishRun(int light);

const uint8_t START_BUTTON_PIN = 2;
const uint8_t DFPLAYER_TX_PIN = 10;
const uint8_t DFPLAYER_RX_PIN = 11;
const uint8_t LDR_PIN = A0;
const uint16_t CONFIG_MAGIC = 0x4C54;



TimerConfig config;
TimerState state = READY;
SoftwareSerial dfPlayerSerial(DFPLAYER_RX_PIN, DFPLAYER_TX_PIN);
DFRobotDFPlayerMini dfPlayer;
bool dfPlayerReady = false;
unsigned long stateChangedAt = 0, runStartedAt = 0, lastButtonChangeAt = 0;
bool lastButtonReading = HIGH, stableButtonState = HIGH;
int beamValue = 0, finishThreshold = 0;
uint8_t darkSampleCount = 0;

void setDefaults() {
  config.magic = CONFIG_MAGIC;
  config.debounceMs = 35;
  config.startLeadMs = 1000;
  config.finishArmMs = 250;
  config.resultHoldMs = 2500;
  config.darkSamples = 3;
  config.thresholdPercent = 70;
  config.minimumThreshold = 20;
  config.volume = 22;
}

void saveConfig() { EEPROM.put(0, config); }

void loadConfig() {
  EEPROM.get(0, config);
  if (config.magic != CONFIG_MAGIC) { setDefaults(); saveConfig(); }
}

int readLightAverage(uint8_t samples) {
  long total = 0;
  for (uint8_t i = 0; i < samples; ++i) { total += analogRead(LDR_PIN); delay(2); }
  return total / samples;
}

void calculateThreshold() {
  finishThreshold = (beamValue * (long)config.thresholdPercent) / 100L;
  if (finishThreshold < config.minimumThreshold) finishThreshold = config.minimumThreshold;
  if (finishThreshold > 1023) finishThreshold = 1023;
}

void sendConfig() {
  Serial.print(F("EVENT,CONFIG,"));
  Serial.print(config.debounceMs); Serial.print(',');
  Serial.print(config.startLeadMs); Serial.print(',');
  Serial.print(config.finishArmMs); Serial.print(',');
  Serial.print(config.resultHoldMs); Serial.print(',');
  Serial.print(config.darkSamples); Serial.print(',');
  Serial.print(config.thresholdPercent); Serial.print(',');
  Serial.print(config.minimumThreshold); Serial.print(',');
  Serial.println(config.volume);
}

void reportReady() {
  Serial.print(F("EVENT,READY,")); Serial.print(beamValue); Serial.print(','); Serial.println(finishThreshold);
}

void calibrate() {
  beamValue = readLightAverage(40);
  calculateThreshold();
  saveConfig();
  Serial.print(F("EVENT,CALIBRATED,")); Serial.print(beamValue); Serial.print(','); Serial.println(finishThreshold);
  reportReady();
}

bool setValue(const char *key, long value) {
  if (!strcmp(key, "debounce") && value >= 5 && value <= 500) config.debounceMs = value;
  else if (!strcmp(key, "lead") && value >= 0 && value <= 10000) config.startLeadMs = value;
  else if (!strcmp(key, "arm") && value >= 0 && value <= 10000) config.finishArmMs = value;
  else if (!strcmp(key, "hold") && value >= 0 && value <= 20000) config.resultHoldMs = value;
  else if (!strcmp(key, "samples") && value >= 1 && value <= 20) config.darkSamples = value;
  else if (!strcmp(key, "percent") && value >= 1 && value <= 99) config.thresholdPercent = value;
  else if (!strcmp(key, "minimum") && value >= 0 && value <= 1023) config.minimumThreshold = value;
  else if (!strcmp(key, "volume") && value >= 0 && value <= 30) { config.volume = value; if (dfPlayerReady) dfPlayer.volume(config.volume); }
  else return false;
  calculateThreshold();
  saveConfig();
  return true;
}

void processCommand() {
  static char line[48];
  static uint8_t length = 0;
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\r') continue;
    if (c == '\n') {
      line[length] = 0;
      if (!strcmp(line, "GET_CONFIG")) sendConfig();
      else if (!strcmp(line, "CALIBRATE") && state == READY) calibrate();
      else if (!strcmp(line, "DEFAULTS") && state == READY) { setDefaults(); saveConfig(); calculateThreshold(); sendConfig(); }
      else if (!strncmp(line, "SET,", 4)) {
        char *key = line + 4;
        char *comma = strchr(key, ',');
        if (comma) { *comma = 0; if (setValue(key, atol(comma + 1))) { Serial.println(F("EVENT,SAVED")); sendConfig(); } else Serial.println(F("EVENT,ERROR,ongeldige waarde")); }
      }
      length = 0;
    } else if (length < sizeof(line) - 1) line[length++] = c;
  }
}

bool startButtonPressed() {
  bool reading = digitalRead(START_BUTTON_PIN);
  if (reading != lastButtonReading) { lastButtonChangeAt = millis(); lastButtonReading = reading; }
  if (millis() - lastButtonChangeAt >= config.debounceMs && reading != stableButtonState) { stableButtonState = reading; return stableButtonState == LOW; }
  return false;
}

void beginStartSequence() {
  beamValue = readLightAverage(20); calculateThreshold(); darkSampleCount = 0;
  if (dfPlayerReady) dfPlayer.play(1);
  state = STARTING; stateChangedAt = millis();
  Serial.print(F("EVENT,COUNTDOWN,")); Serial.print(beamValue); Serial.print(','); Serial.println(finishThreshold);
}

void beginRun() { state = RUNNING; runStartedAt = millis(); darkSampleCount = 0; Serial.println(F("EVENT,START")); }

void finishRun(int light) {
  unsigned long elapsed = millis() - runStartedAt;
  state = FINISHED; stateChangedAt = millis();
  Serial.print(F("EVENT,RESULT,")); Serial.print(elapsed); Serial.print(','); Serial.print(light); Serial.print(','); Serial.println(finishThreshold);
  if (dfPlayerReady) dfPlayer.play(2);
}

void setup() {
  pinMode(START_BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(115200); loadConfig();
  dfPlayerSerial.begin(9600);
  if (dfPlayer.begin(dfPlayerSerial, true, true)) { dfPlayerReady = true; dfPlayer.volume(config.volume); Serial.println(F("EVENT,AUDIO_OK")); }
  else Serial.println(F("EVENT,AUDIO_NOT_FOUND"));
  calibrate(); sendConfig();
}

void loop() {
  processCommand();
  if (state == READY) { if (startButtonPressed()) beginStartSequence(); }
  else if (state == STARTING) { if (millis() - stateChangedAt >= config.startLeadMs) beginRun(); }
  else if (state == RUNNING) {
    if (millis() - runStartedAt >= config.finishArmMs) {
      int light = analogRead(LDR_PIN);
      if (light < finishThreshold) { if (++darkSampleCount >= config.darkSamples) finishRun(light); }
      else darkSampleCount = 0;
    }
  } else if (millis() - stateChangedAt >= config.resultHoldMs) { calibrate(); state = READY; }
}