Revise paste Traffic Controller rev_01

/********* Pleasedontcode.com **********

Pleasedontcode thanks you for automatic code generation! Enjoy your code!

- Terms and Conditions:
	You have a non-exclusive, revocable, worldwide, royalty-free license
	for personal and commercial use. Attribution is optional; modifications
	are allowed, but you're responsible for code maintenance. We're not
	liable for any loss or damage. For full terms,
	please visit pleasedontcode.com/termsandconditions.

- Project: Traffic Controller
	- Source Code NOT compiled for: Arduino Uno
	- Source Code created on: 2025-11-23 07:01:06

********* Pleasedontcode.com **********/

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
	/* Implement a scheduling system for traffic lights */
	/* (yellow, red, green, Don't Walk, Walk) */
	/* synchronized with a push button to activate Walk */
	/* mode during yellow or red lights. Use the */
	/* EasyButton library and RTC for precise timing. */
/****** END SYSTEM REQUIREMENTS *****/

/* START CODE */

// SYSTEM REQUIREMENTS: 
// Implement a scheduling system for traffic lights
// (yellow, red, green, Don't Walk, Walk)
// synchronized with a push button to activate Walk mode during yellow or red lights.
// Use EasyButton library and RTC for precise timing.

#include <EasyButton.h>
#include <PCF85063A-SOLDERED.h>

// Define pins for traffic lights
const uint8_t pinYellow = 12;
const uint8_t pinRed = 11;
const uint8_t pinGreen = 10;
// Define pins for pedestrian signals
const uint8_t pinDontWalk = 9;
const uint8_t pinWalk = 8;
// Define push button pin to activate Walk mode
const uint8_t buttonPin = 2;

// Timing variables in milliseconds
unsigned long yellowDuration = 4000;
unsigned long redDuration = 4000;
unsigned long greenDuration = 4000;
unsigned long walkDuration = 2000;
unsigned long flashInterval = 250;

// Define button instance
EasyButton walkButton(buttonPin);

// Define RTC instance
PCF85063A rtc;

// State enumeration for traffic light states
enum State {
  S_YELLOW,
  S_RED,
  S_GREEN,
  S_DONT_WALK,
  S_WALK_STEADY,
  S_WALK_FLASH
};

State currentState = S_YELLOW;
unsigned long stateStartTime = 0;
bool walkModeActivated = false;
bool walkButtonPressed = false;

void setup() {
  // Initialize serial for debugging
  Serial.begin(115200);

// Initialize pins
  pinMode(pinYellow, OUTPUT);
  pinMode(pinRed, OUTPUT);
  pinMode(pinGreen, OUTPUT);
  pinMode(pinDontWalk, OUTPUT);
  pinMode(pinWalk, OUTPUT);

// Initialize RTC
  rtc.begin();
  // Set initial time and date
  rtc.setTime(6, 0, 0); // 6:00:00
  rtc.setDate(6, 15, 5, 2020); // Saturday, 15.05.2020
  // Set RTC alarm for scheduled transition if needed
  // (Optional, not used in current logic)

// Initialize button
  walkButton.begin();
  walkButton.onPressed([](){
    walkButtonPressed = true;
  });

// Start with yellow light
  currentState = S_YELLOW;
  stateStartTime = millis();
}

void loop() {
  // Read button state
  walkButton.read();

// Check if walk button was pressed
  if (walkButtonPressed) {
    walkModeActivated = true;
    walkButtonPressed = false;
  }

unsigned long currentTime = millis();

switch (currentState) {
    case S_YELLOW:
      digitalWrite(pinYellow, HIGH);
      digitalWrite(pinRed, LOW);
      digitalWrite(pinGreen, LOW);
      digitalWrite(pinDontWalk, HIGH);
      digitalWrite(pinWalk, LOW);
      if (currentTime - stateStartTime >= yellowDuration) {
        currentState = S_RED;
        stateStartTime = currentTime;
      }
      break;

case S_RED:
      digitalWrite(pinRed, HIGH);
      digitalWrite(pinYellow, LOW);
      digitalWrite(pinGreen, LOW);
      digitalWrite(pinDontWalk, HIGH);
      digitalWrite(pinWalk, LOW);
      if (currentTime - stateStartTime >= redDuration || walkModeActivated) {
        currentState = S_GREEN;
        stateStartTime = currentTime;
        walkModeActivated = false;
      }
      break;

case S_GREEN:
      digitalWrite(pinGreen, HIGH);
      digitalWrite(pinYellow, LOW);
      digitalWrite(pinRed, LOW);
      digitalWrite(pinDontWalk, HIGH);
      digitalWrite(pinWalk, LOW);
      if (currentTime - stateStartTime >= greenDuration) {
        currentState = S_DONT_WALK;
        stateStartTime = currentTime;
      }
      break;

case S_DONT_WALK:
      digitalWrite(pinDontWalk, HIGH);
      digitalWrite(pinWalk, LOW);
      if (walkModeActivated) {
        currentState = S_WALK_STEADY;
        stateStartTime = currentTime;
      } else if (currentTime - stateStartTime >= redDuration) {
        currentState = S_YELLOW;
        stateStartTime = currentTime;
      }
      break;

case S_WALK_STEADY:
      digitalWrite(pinDontWalk, LOW);
      digitalWrite(pinWalk, HIGH);
      if (currentTime - stateStartTime >= walkDuration) {
        currentState = S_WALK_FLASH;
        stateStartTime = currentTime;
      }
      break;

case S_WALK_FLASH:
      if ((currentTime / flashInterval) % 2 == 0) {
        digitalWrite(pinWalk, HIGH);
      } else {
        digitalWrite(pinWalk, LOW);
      }
      if (currentTime - stateStartTime >= walkDuration) {
        digitalWrite(pinWalk, LOW);
        digitalWrite(pinDontWalk, HIGH);
        walkModeActivated = false;
        currentState = S_YELLOW;
        stateStartTime = currentTime;
      }
      break;
  }
  // Optional: Use RTC to schedule precise transitions or for logging
  // Not used directly in this implementation
}

/* END CODE */