const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // Check if it's time to blink the LED
  if (currentMillis - previousMillis >= interval) {
    // Save the last time the LED was blinked
    previousMillis = currentMillis;

    // If the LED is off, turn it on. Otherwise, turn it off.
    if (digitalRead(ledPin) == LOW) {
      digitalWrite(ledPin, HIGH); // Turn the LED on
    } else {
      digitalWrite(ledPin, LOW); // Turn the LED off
    }
  }
} 
//===================================================================
const int ledPin = 13;  // Pin connected to the LED
unsigned long previousMillis = 0;  // Store last time LED was updated
const long interval = 1000;  // Blink interval in milliseconds (1 second)

int ledState = LOW;  // LED state, initially off

void setup() {
  pinMode(ledPin, OUTPUT);  // Set the LED pin as output
}

void loop() {
  unsigned long currentMillis = millis();  // Get current time

  if (currentMillis - previousMillis >= interval) {
    // If interval has passed since last update, toggle LED state
    previousMillis = currentMillis;  // Remember last time LED was updated

    if (ledState == LOW) {
      ledState = HIGH;  // Turn LED on
    } else {
      ledState = LOW;  // Turn LED off
    }

    digitalWrite(ledPin, ledState);  // Update LED state
  }
}
//===================================================================
const int ledPin = 13;
const unsigned long intervalMicros = 1000 * 1000; // 1 second in microseconds
unsigned long previousMicros = 0;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long currentMicros = micros();

  if (currentMicros - previousMicros >= intervalMicros) {
    previousMicros = currentMicros;
    digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED state
  }
}

//===================================================================
const int ledPin = 13;
unsigned long long previousMicros = 0;
const unsigned long long intervalMicros = 1000000; // 1 second in microseconds

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long long currentMicros = micros();
  if (currentMicros - previousMicros >= intervalMicros) {
    previousMicros = currentMicros;
    digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED state
  }
}

//===================================================================
const int ledPin = 13;
enum class LedState { OFF, ON };
LedState state = LedState::OFF;
unsigned long previousMillis = 0;
const long interval = 1000;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();

  switch (state) {
    case LedState::OFF:
      if (currentMillis - previousMillis >= interval) {
        state = LedState::ON;
        previousMillis = currentMillis;
      }
      break;
    case LedState::ON:
      if (currentMillis - previousMillis >= interval) {
        state = LedState::OFF;
        previousMillis = currentMillis;
      }
      break;
  }

  digitalWrite(ledPin, state == LedState::ON);
}

//===================================================================
const int ledPin = 9;
const int brightness = 128; // 50% brightness
const int period = 500; // 500 microseconds period

void setup() {
  pinMode(ledPin, OUTPUT);
  ledcSetup(0, frequency, resolution); // Replace with actual frequency and resolution values
  ledcAttachPin(ledPin, 0);
}

void loop() {
  ledcWrite(0, brightness);
  delayMicroseconds(period - brightness); // Delay off-time
  ledcWrite(0, 0);
  delayMicroseconds(brightness); // Delay on-time
}

//===================================================================
//===================================================================
//===================================================================
//===================================================================
//===================================================================

//========================================================================

const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
int ledState = LOW; // Tracks the current state of the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // Check if it's time to blink the LED
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis; // Save the last time the LED was blinked
    if (ledState == LOW) {
      ledState = HIGH; // Toggle LED state
    } else {
      ledState = LOW;
    }
    digitalWrite(ledPin, ledState); // Update LED state
  }
}

//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
boolean ledState = false; // Tracks the current state of the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // Check if it's time to blink the LED
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis; // Save the last time the LED was blinked
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Update LED state
  }
}//=====================================================================

const int ledPin = 13;
unsigned long previousMillis = 0;
const long interval = 1000;
bool ledOn = false;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    ledOn = !ledOn; // Toggle the flag
    digitalWrite(ledPin, ledOn); // Update LED based on flag
  }
}

//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
boolean ledState = false; // Tracks the current state of the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // Check if it's time to blink the LED
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis; // Save the last time the LED was blinked
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Update LED state
  }
}
//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
int currentState = 0; // Variable to store the current state of the state machine

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // State machine to control LED blinking
  switch (currentState) {
    case 0:
      // State 0: LED off
      digitalWrite(ledPin, LOW);
      if (currentMillis - previousMillis >= interval) {
        previousMillis = currentMillis;
        currentState = 1; // Transition to next state
      }
      break;
    case 1:
      // State 1: LED on
      digitalWrite(ledPin, HIGH);
      if (currentMillis - previousMillis >= interval) {
        previousMillis = currentMillis;
        currentState = 0; // Transition to next state
      }
      break;
  }
}

//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
bool ledState = false; // Tracks the current state of the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // Check if it's time to blink the LED
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis; // Save the last time the LED was blinked
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Update LED state
  }
}

//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
int state = 0; // Variable to store the current state of the state machine

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  unsigned long currentMillis = millis(); // Get the current time

  // State machine to control LED blinking
  switch (state) {
    case 0: // LED off
      digitalWrite(ledPin, LOW);
      if (currentMillis - previousMillis >= interval) {
        state = 1; // Transition to next state
        previousMillis = currentMillis;
      }
      break;
    case 1: // LED on
      digitalWrite(ledPin, HIGH);
      if (currentMillis - previousMillis >= interval) {
        state = 0; // Transition to next state
        previousMillis = currentMillis;
      }
      break;
  }
}
//========================================================================
const int ledPin = 13; // The pin connected to the LED
unsigned long previousMillis = 0; // Stores the last time the LED was updated
const long interval = 1000; // Interval at which to blink (milliseconds)
bool ledState = false; // Tracks the current state of the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the digital pin as an output
}

void loop() {
  if (millis() - previousMillis >= interval) { // Check if it's time to blink the LED
    previousMillis = millis(); // Save the last time the LED was blinked
    ledState = !ledState; // Toggle LED state
    digitalWrite(ledPin, ledState); // Update LED state
  }
}
//========================================================================