STEM kviz: tri odgovora, RGB povratna informacija

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#ifndef COMMON_ANODE
#define COMMON_ANODE false  // true ONLY with the common-anode wiring variant.
#endif
constexpr uint8_t BUTTON_A_PIN = 27, BUTTON_B_PIN = 32, BUTTON_C_PIN = 14;
constexpr uint8_t RED_PIN = 25, GREEN_PIN = 26, BLUE_PIN = 33;
constexpr uint8_t SDA_PIN = 21, SCL_PIN = 22;
constexpr uint8_t OLED_ADDRESS = 0x3C;
constexpr uint32_t DEBOUNCE_MS = 30;
constexpr uint32_t FEEDBACK_MS = 1200;
// A fresh event needs 30 ms at one level. A held or inhibited press must
// release stably before another event can be accepted.
struct DebouncedButton {
  uint8_t pin;
  bool rawHigh = true, stableHigh = true, armed = true;
  bool pressed = false, released = false;
  uint32_t rawChangedAt = 0;
  explicit DebouncedButton(uint8_t inputPin) : pin(inputPin) {}
  void begin(uint32_t now) {
    pinMode(pin, INPUT_PULLUP);
    rawHigh = stableHigh = digitalRead(pin) == HIGH;
    armed = rawHigh;
    rawChangedAt = now;
    pressed = released = false;
  }
  void update(uint32_t now) {
    pressed = released = false;
    const bool readingHigh = digitalRead(pin) == HIGH;
    if (readingHigh != rawHigh) {
      rawHigh = readingHigh;
      rawChangedAt = now;
    }
    if (static_cast<uint32_t>(now - rawChangedAt) < DEBOUNCE_MS) return;
    if (rawHigh != stableHigh) {
      stableHigh = rawHigh;
      if (stableHigh) released = true;
      else if (armed) {
        pressed = true;
        armed = false;
      }
    }
    // Also recovers from an inhibited LOW pulse too short to become stable.
    if (rawHigh && stableHigh) armed = true;
  }
  void inhibit() { armed = false; pressed = false; }
  bool isReleased(uint32_t now) const {
    return rawHigh && stableHigh &&
           static_cast<uint32_t>(now - rawChangedAt) >= DEBOUNCE_MS;
  }
};
Adafruit_SSD1306 display(128, 64, &Wire, -1, 100000UL, 100000UL);
bool ready = false;

bool initializeDisplay() {
  if (!Wire.begin(SDA_PIN, SCL_PIN)) {
    Serial.println("OLED ERROR: I2C initialization failed; reset to retry.");
    return false;
  }
  Wire.setClock(100000);
  Wire.setTimeOut(50);
  Wire.beginTransmission(OLED_ADDRESS);
  if (Wire.endTransmission() != 0) {
    Serial.println("OLED ERROR: address did not ACK; check wiring/address and reset.");
    return false;
  }
  Serial.print("OLED address ACK: 0x"); Serial.println(OLED_ADDRESS, HEX);
  Serial.println("An ACK does not identify the display controller.");
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS, false, false)) {
    Serial.println("OLED ERROR: buffer initialization failed; reset to retry.");
    return false;
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);
  return true;
}

DebouncedButton buttonA(BUTTON_A_PIN), buttonB(BUTTON_B_PIN), buttonC(BUTTON_C_PIN);
struct Question {
  const char* prompt;
  const char* options[3];
  uint8_t correctIndex;
};
const Question Questions[] = {
  {"GPIO logic level?", {"3.3 V", "5 V", "12 V"}, 0},
  {"Button to GND is?", {"HIGH", "LOW", "PWM"}, 1},
  {"ADC input here?", {"GPIO34", "3V3 pin", "GND pin"}, 0},
  {"OLED data bus?", {"UART", "SPI", "I2C"}, 2},
  {"PIR detects?", {"Air temp", "Motion", "Humidity"}, 1}
};
constexpr size_t QUESTION_COUNT = sizeof(Questions) / sizeof(Questions[0]);
enum QuizState { WAIT_RELEASE, QUESTION, FEEDBACK, FINISHED };
QuizState state = WAIT_RELEASE;
size_t questionIndex = 0, score = 0;
uint32_t stateSince = 0;
bool answerCorrect = false, restartReady = false, screenDirty = true;
void enterState(QuizState next, uint32_t now);

void setRgb(bool red, bool green, bool blue) {
  digitalWrite(RED_PIN, (red != COMMON_ANODE) ? HIGH : LOW);
  digitalWrite(GREEN_PIN, (green != COMMON_ANODE) ? HIGH : LOW);
  digitalWrite(BLUE_PIN, (blue != COMMON_ANODE) ? HIGH : LOW);
}

void enterState(QuizState next, uint32_t now) {
  state = next;
  stateSince = now;
  screenDirty = true;
  if (state == WAIT_RELEASE || state == QUESTION) setRgb(false, false, true);
  else if (state == FEEDBACK) setRgb(!answerCorrect, answerCorrect, false);
  else setRgb(false, false, false);
}

bool allReleased(uint32_t now) {
  return buttonA.isReleased(now) && buttonB.isReleased(now) && buttonC.isReleased(now);
}

void drawQuiz() {
  if (!screenDirty) return;
  display.clearDisplay();
  if (state == FINISHED) {
    display.setCursor(0, 0); display.print("QUIZ FINISHED");
    display.setCursor(0, 16); display.print("Score: "); display.print(score);
    display.print(" / "); display.print(QUESTION_COUNT);
    display.setCursor(0, 38); display.print(restartReady ? "A: restart" : "Release all buttons");
  } else if (state == WAIT_RELEASE) {
    display.setCursor(0, 0); display.print("Question "); display.print(questionIndex + 1);
    display.print(" / "); display.print(QUESTION_COUNT);
    display.setCursor(0, 22); display.print("Release all buttons");
    display.setCursor(0, 38); display.print("Choose one: A, B or C");
  } else if (state == FEEDBACK) {
    display.setCursor(0, 0); display.print(answerCorrect ? "CORRECT" : "NOT CORRECT");
    display.setCursor(0, 18); display.print("Answer: ");
    display.print(static_cast<char>('A' + Questions[questionIndex].correctIndex));
    display.setCursor(0, 34); display.print("Score: "); display.print(score);
    display.print(" / "); display.print(QUESTION_COUNT);
  } else {
    const Question& question = Questions[questionIndex];
    display.setCursor(0, 0); display.print("Q"); display.print(questionIndex + 1);
    display.print("/"); display.print(QUESTION_COUNT); display.print("  Score "); display.print(score);
    display.setCursor(0, 12); display.print(question.prompt);
    for (uint8_t i = 0; i < 3; ++i) {
      display.setCursor(0, 24 + i * 10);
      display.print(static_cast<char>('A' + i)); display.print(": "); display.print(question.options[i]);
    }
    display.setCursor(0, 56); display.print("Press one button");
  }
  display.display();  // Redraw only on a state/value change; short taps may be missed.
  screenDirty = false;
}

void setup() {
  Serial.begin(115200);
  pinMode(RED_PIN, OUTPUT); pinMode(GREEN_PIN, OUTPUT); pinMode(BLUE_PIN, OUTPUT);
  setRgb(false, false, false);
  const uint32_t now = millis();
  buttonA.begin(now); buttonB.begin(now); buttonC.begin(now);
  ready = initializeDisplay();
  if (!ready) return;
  enterState(WAIT_RELEASE, millis());
  drawQuiz();
}

void loop() {
  if (!ready) return;
  const uint32_t now = millis();
  buttonA.update(now); buttonB.update(now); buttonC.update(now);
  if (state == WAIT_RELEASE) {
    if (allReleased(now)) enterState(QUESTION, now);
  } else if (state == QUESTION) {
    const uint8_t rawPressed = static_cast<uint8_t>(!buttonA.rawHigh) +
                               static_cast<uint8_t>(!buttonB.rawHigh) +
                               static_cast<uint8_t>(!buttonC.rawHigh);
    if (rawPressed > 1) {
      // An observed chord is rejected, without any A/B/C priority.
      enterState(WAIT_RELEASE, now);
    } else {
      int8_t answer = -1;
      if (buttonA.pressed && buttonB.rawHigh && buttonC.rawHigh) answer = 0;
      else if (buttonB.pressed && buttonA.rawHigh && buttonC.rawHigh) answer = 1;
      else if (buttonC.pressed && buttonA.rawHigh && buttonB.rawHigh) answer = 2;
      if (answer >= 0) {
        answerCorrect = static_cast<uint8_t>(answer) == Questions[questionIndex].correctIndex;
        if (answerCorrect) ++score;
        enterState(FEEDBACK, now);
      }
    }
  } else if (state == FEEDBACK) {
    if (static_cast<uint32_t>(now - stateSince) >= FEEDBACK_MS) {
      if (questionIndex + 1 < QUESTION_COUNT) {
        ++questionIndex;
        enterState(WAIT_RELEASE, now);
      } else {
        restartReady = false;
        enterState(FINISHED, now);
      }
    }
  } else {
    // B/C do not restart, and any observed chord must release completely.
    if ((!buttonB.rawHigh || !buttonC.rawHigh) && restartReady) {
      restartReady = false;
      screenDirty = true;
    }
    if (!restartReady && allReleased(now)) {
      restartReady = true;
      screenDirty = true;
    }
    if (restartReady && buttonA.pressed && buttonB.rawHigh && buttonC.rawHigh) {
      score = questionIndex = 0;
      restartReady = false;
      enterState(WAIT_RELEASE, now);
    }
  }
  drawQuiz();
}