class A
{  
    void C()
    {
        int a=20; int b=30; int c;
        c=a+b;
        System.out.println(c);
    }
    void C(int x,int y)
    {
        int c;
        c=x+y;
        System.out.println(c);
    }
    void C(int x,double y)
    {
        double c;
        c=x+y;
        System.out.println(c);
    }
    public static void main(String[] args)
    {
        A r= new A();
        r.C();
        r.C(10,20);
        r.C(11,22.33);
    }

}

class A
{
    void SHOW()
    {
        System.out.println(this);
    }
    public static void main(String[] args)
    {
        A r = new A();
        System.out.println(r);
        r.SHOW();
    }

}

import serial
import matplotlib.pyplot as plt

# Establish serial connection
ser = serial.Serial('COM5', 921600)  # Replace 'COM3' with your port
plt.ion()  # Turn on interactive mode for live plotting

voltage_data = []
current_data = []
power_data = []

fig, axs = plt.subplots(3, 1)

# Initialize empty plots
lines = [ax.plot([], [], label=label)[0] for ax, label in zip(axs, ['Voltage (V)', 'Current (A)', 'Power (W)'])]

for ax in axs:
    ax.legend()

plt.show(block=False)  # Ensure non-blocking plot

while True:
    # Read data from serial port
    arduino_data = ser.readline().decode().strip()
    if arduino_data:
        data_values = arduino_data.split(',')
        if len(data_values) >= 3:  # Check for at least 3 values
            try:
                voltage = float(data_values[0])
                current = float(data_values[1])
                power = float(data_values[2])

                voltage_data.append(voltage)
                current_data.append(current)
                power_data.append(power)

                lines[0].set_data(range(len(voltage_data)), voltage_data)
                lines[1].set_data(range(len(current_data)), current_data)
                lines[2].set_data(range(len(power_data)), power_data)

                for ax in axs:
                    ax.relim()
                    ax.autoscale_view()

                plt.draw()
                plt.pause(0.01)  # Update plot every 0.01 seconds

            except ValueError as e:
                print(f"Error: {e}. Invalid data format received: {arduino_data}")
        else:
            print(f"Incomplete data received: {arduino_data}")

    else:
        print("No data received from Arduino")

# Close serial connection
ser.close()

#include "LiquidCrystal.h"

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

float input_voltage = 0.0;
float temp=0.0;


void setup()
{
   Serial.begin(9600);     //  opens serial port, sets data rate to 9600 bps
   lcd.begin(16, 2);       //// set up the LCD's number of columns and rows: 
   lcd.print("DIGITAL VOLTMETER");
}
void loop()
{

//Conversion formula for voltage
   
   int analog_value = analogRead(A0);
   input_voltage = (analog_value * 5.0) / 1024.0; 

   
   if (input_voltage < 0.1) 
   {
     input_voltage=0.0;
   } 
    Serial.print("v= ");
    Serial.println(input_voltage);
    lcd.setCursor(0, 1);
    lcd.print("Voltage= ");
    lcd.print(input_voltage);
    delay(300);
} 

int baselineTemp = 0;
int celsius = 0;

void setup()
{
pinMode(A0, INPUT);
Serial.begin(9600);

pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
}
void loop()
{
baselineTemp = 20;
celsius = map(((analogRead(A0) - 20) * 3.04), 0, 1023, -40, 125);
Serial.print(celsius);
Serial.println(" C, ");
if (celsius < baselineTemp) {
digitalWrite(2, LOW);
digitalWrite(3, LOW);
}
if (celsius >= baselineTemp && celsius < baselineTemp + 2) {
digitalWrite(2, HIGH);
digitalWrite(3, LOW);
}
if (celsius >= baselineTemp + 2 && celsius < baselineTemp + 4) {
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
}
if (celsius >= baselineTemp + 4) {
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
}
delay(1000);
}

#define echo 2
#define trig 3

#define LED8 11
#define LED7 10
#define LED6 9
#define LED5 8
#define LED4 7
#define LED3 6
#define LED2 5
#define LED1 4

float   duration;
float  distance;

void setup() {

  pinMode(trig, OUTPUT);
  pinMode(echo, INPUT);

  for (int i = 4; i <= 11; i++)
    pinMode(i, OUTPUT);


  Serial.begin(9600);

}

void loop() {

  time_Measurement();
  distance = duration * (0.0343) / 2;
  Serial.println(distance);

  led_Check();
  delay(10);

  for (int i = LED1; i <= LED8; i++) {
    digitalWrite(i, LOW);
  }
}


void time_Measurement()
{
  digitalWrite(trig, LOW);
  delayMicroseconds(2);

  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);

  duration = pulseIn(echo, HIGH);
}

void led_Check() {
  
  if (11 < distance && distance <= 15)
    digitalWrite(LED8, HIGH);
  else if (10 < distance && distance <= 11)
    digitalWrite(LED7, HIGH);
  else if (9 < distance && distance <= 10)
    digitalWrite(LED6, HIGH);
  else if (8 < distance && distance <= 9)
    digitalWrite(LED5, HIGH);
  else if (7 < distance && distance <= 8)
    digitalWrite(LED4, HIGH);
  else if (6 < distance && distance <= 7)
    digitalWrite(LED3, HIGH);
  else if (5 < distance && distance <= 6)
    digitalWrite(LED2, HIGH);
  else if (1 < distance && distance <= 5)
    digitalWrite(LED1, HIGH);

  else {
    for (int i = LED1; i <= LED8; i++)
      digitalWrite(i, LOW);
  }

}

int count = 0;
int TrigPin = A0; 
int EchoPin = A1;
  
long duration;
// PULSE WIDTH

void setup() {
    // set Serial communication
    Serial.begin(115200);
    // set pin mode
    pinMode(TrigPin, OUTPUT);
    pinMode(EchoPin, INPUT);
    // init pin
    digitalWrite(TrigPin, LOW);
    delay(1);
}

void loop() {
    Serial.println(count++);
    Serial.println(getDistance());
    Serial.println("");
    Serial.println("");
    delay(1000);
}

long getDistance() {
    // trig
    digitalWrite(TrigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(TrigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(TrigPin, LOW);
    // echo
    duration = pulseIn(EchoPin, HIGH);     // unit: us
    return duration * 0.34029 / 2;         // unit: mm
}

const int potPin = A0;
const int rightLED = 5;
const int leftLED = 4;
const int enable = 9;
const int in1 = 8;
const int in2 = 7;
String direction = "";

void setup()
{
  pinMode(rightLED, OUTPUT);
  pinMode(leftLED, OUTPUT);
  pinMode(potPin, INPUT);
  attachInterrupt(0, setDirectionClockWise, RISING);
  attachInterrupt(1, setDirectionCounterClockWise, RISING);
  //Turn off motor
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);  
}

void loop()
{
  int motorSpeed = analogRead(potPin);
  Serial.println(motorSpeed);
  motorSpeed = map(motorSpeed, 0, 1023, 0, 255);
  Serial.println(motorSpeed);
  
  directionControl();
  delay(100);
  speedControl(motorSpeed);
  delay(100);
}

void setDirectionClockWise(){
  direction = "CW";
}

void setDirectionCounterClockWise(){
  direction = "CCW";
}

void directionControl(){
  if(direction == "CW"){
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    digitalWrite(rightLED, HIGH);
    digitalWrite(leftLED, LOW);  
  }
  
  else if(direction == "CCW"){
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    digitalWrite(rightLED, LOW);
    digitalWrite(leftLED, HIGH);
  }
}

void speedControl(int motorSpeed){
  analogWrite(enable, motorSpeed);
}

#include <LiquidCrystal.h>
#include <Servo.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Set up the LCD pins
Servo myservo; // Create a Servo object

const int led = 13; // LED connection to digital pin 13
const int led1 = 6; // LED connection to digital pin 6

byte leds = 0;

void setup() {
  lcd.begin(16, 2); // Initialize the LCD screen
  pinMode(led, OUTPUT);
  pinMode(led1, OUTPUT);
  myservo.attach(10); // Attach the servo motor to digital pin 10
}

void loop() {
  // Turn on the LED and rotate the servo and display message "on"
  digitalWrite(led, HIGH);
  digitalWrite(led1, LOW);
  lcd.setCursor(0, 0);
  lcd.print("    NOVVA ON");
  myservo.write(0); // Rotate the servo to 90 degrees

  delay(3000); // Delay for 3 seconds

  // Turn off the LED and stop the servo and display message "off"
  digitalWrite(led, LOW);
  digitalWrite(led1, HIGH);
  lcd.clear(); // Clear the LCD Display
  lcd.setCursor(0, 0);
  lcd.print("   NOVVA OFF!");
  myservo.write(90); // Stop the servo motor

  delay(3000); // Delay for 3 seconds
}

#include <Servo.h>
Servo Serv1; //create a servo object named Serv1

//use a PWM pin (3,5,6,9,10,11)
int pinServo1=8;

void setup(){
Serv1.attach(pinServo1);
}

void loop(){
//move the servo 20 degrees
Serv1.write(20);
//allow enough time to move
delay(1000);
//move the servo 100 degrees
Serv1.write(100);
//allow enough time to move
delay(1000);
}

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Set up the LCD pins

const int led = 13; // Green LED connection to digital pin 13
const int led1 = 6; // Red LED connection to digital pin 6

byte leds = 0;

void setup() {
lcd.begin(16, 2); // Initialize the LCD screen
pinMode(led, OUTPUT);
pinMode(led1, OUTPUT);
}
void loop() {
// Turn on the Green LED and display message "NOVVA ON!"
digitalWrite(led, HIGH);
digitalWrite(led1, LOW);
lcd.setCursor(0, 0);
lcd.print(" NOVVA ON");
delay(2000); // Delay for 2 seconds

// Turn on the Red LED and display message "NOVVA OFF!"
digitalWrite(led, LOW);
digitalWrite(led1, HIGH);
lcd.clear(); // Clear the LCD Display
lcd.setCursor(0, 0);
lcd.print(" NOVVA OFF!");

delay(2000); // Delay for 2 seconds
}

const int LED1=12;
const int LED2=13;
int val=0;
void setup()
{
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(7, INPUT);
}
void loop(){
val=digitalRead(7);
if(val==HIGH)
{
digitalWrite(LED1,HIGH);
digitalWrite(LED2,LOW);
}
else
{
digitalWrite(LED2,HIGH);
digitalWrite(LED1,LOW);
}
delay(100);
}

 ng new app-with-modules --routing --standalone false

const articles = document.getElementsByTagName('article');

const paragraphs = document.getElementsByTagName('p');

​

const firstArticle = articles[0];

const secondParagraph = paragraphs[1];

void handleWdbMessage(AdafruitIO_Data *data) {
  // ... (Function definition not included in snippet)
}

void loop() {
  // ... (Loop function definition not included in snippet)
}

class A
{
    
        int a=20;
        
}
class B extends A
{
    int a=10;
    void S()
    {
        System.out.println(super.a);
        System.out.println(a);
    }
}
class C
{
    public static void main(String[] args)
{
    B r= new B();
    r.S();
}
}

void connectWiFi() {
  // ... (Function definition not included in snippet)
}

void MQTT_connect() {
  // ... (Function definition not included in snippet)
}

void setup() {
  // ... (Setup function definition not included in snippet)
}

class A
{
    void S()
    {
        System.out.println("srk");
    }
}
class B
{
    void S()
    {
        super.show();
        System.out.println("srk");
    }
}
class C
{
    public staic void main (String[] args)

{
    B r= new B();
    r.S();
}

}

DHT dht(DHTPIN, DHTTYPE);

WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

Adafruit_MQTT_Publish temperature = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/temperature");
Adafruit_MQTT_Publish humidity = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/humidity");

AdafruitIO_WiFi io(AIO_USERNAME, AIO_KEY, WLAN_SSID, WLAN_PASS);

AdafruitIO_Feed *wdbFeed = io.feed("wdb");

#include <WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#include "AdafruitIO_WiFi.h"
#include "DHT.h"

#define WLAN_SSID       "X"
#define WLAN_PASS       "asdfghjk"

#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "chathurazju"
#define AIO_KEY         "aio_fTGR25ihhqnx65rtc2aTOdaL8ODV"

#define DHTPIN 4        // Pin where the DHT11 is connected
#define DHTTYPE DHT11   // Type of DHT sensor (DHT11 or DHT22)

#define RED_LED_PIN    5 // Pin number for the red LED
#define GREEN_LED_PIN  13 // Pin number for the green LED

const articles = document.getElementsByTagName('article');

const paragraphs = document.getElementsByTagName('p');

​

const firstArticle = articles[0];

const secondParagraph = paragraphs[1];

const articles = document.getElementsByTagName('article');

const paragraphs;

const articles = document.getElementsByTagName('article');

const paragraphs;

#include <WiFi.h>
#include "AdafruitIO_WiFi.h"

#define WIFI_SSID     "Your_WiFi_SSID"
#define WIFI_PASS     "Your_WiFi_Password"
#define IO_USERNAME   "Your_AdafruitIO_Username"
#define IO_KEY        "Your_AdafruitIO_Key"

AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);

AdafruitIO_Feed *wdbFeed = io.feed("wdb");

void setup() {
  Serial.begin(115200);
  
  while (!Serial) {
    delay(100); // Wait for Serial to be available
  }

  Serial.println("Booting...");

  Serial.print("Connecting to Wi-Fi");
  io.connect();

  while (io.status() < AIO_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  Serial.println();
  Serial.println("Connected to Adafruit IO!");

  // Your data to send to Adafruit IO (replace this with your actual data)
  int sensorValue = 123; // Replace with your sensor data or variable value

  // Publish the data to the "wdb" feed on Adafruit IO
  wdbFeed->save(sensorValue);

  Serial.print("Data sent to Adafruit IO: ");
  Serial.println(sensorValue);
}

void loop() {
  io.run();
  // Other tasks can be performed here
}

wdbFeed->save(sensorValue);

io.connect();

void setup() {
  // Initialization code
}

AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);
AdafruitIO_Feed *wdbFeed = io.feed("wdb");

class A
{
    
    void ADD()
    {
        
        System.out.println("enter your name ");
    }
}
class B extends A
{
void SUB()
    {
        
        System.out.println("Enter your enrollemnet number");
    }
}
class C extends A
 
{
    void MULTI()
    {
        
        System.out.println("enter your college name ");
    }
}
    
class D
{
    public static void main(String[] args)
    {
       B r = new B();
       C r2= new C();
       
       r.ADD(); r.SUB();
       r2.ADD(); r2.MULTI();
    }
}

#define WIFI_SSID     "Your_WiFi_SSID"
#define WIFI_PASS     "Your_WiFi_Password"
#define IO_USERNAME   "Your_AdafruitIO_Username"
#define IO_KEY        "Your_AdafruitIO_Key"

#include <WiFi.h>
#include "AdafruitIO_WiFi.h"

#include <WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

#define WLAN_SSID       "Your_WiFi_SSID"
#define WLAN_PASS       "Your_WiFi_Password"

#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "Your_AdafruitIO_Username"
#define AIO_KEY         "Your_AdafruitIO_Key"

WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

Adafruit_MQTT_Publish data = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/your_feed_name"); // Change "your_feed_name" to your Adafruit IO feed name

void connectWiFi() {
  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");
}

void MQTT_connect() {
  int8_t ret;

  if (mqtt.connected()) {
    return;
  }

  Serial.print("Connecting to Adafruit IO... ");
  while ((ret = mqtt.connect()) != 0) {
    Serial.println(mqtt.connectErrorString(ret));
    Serial.println("Retrying MQTT connection in 5 seconds...");
    mqtt.disconnect();
    delay(5000);
  }
  Serial.println("MQTT Connected!");
}

void setup() {
  Serial.begin(115200);
  delay(100);

  connectWiFi();
}

void loop() {
  MQTT_connect();

  // Your logic to obtain sensor data or any variable
  float yourData = 25.5; // Replace this with your actual data source

  Serial.print("Sending data: ");
  Serial.println(yourData);

  if (!data.publish(yourData)) {
    Serial.println("Failed to publish data!");
  }

  delay(5000); // Adjust delay as needed
}

if (!data.publish(yourData)) {
  Serial.println("Failed to publish data!");
}

void loop() {
  // Main code that runs repeatedly
}

void setup() {
  // Initialization code
}

void MQTT_connect() {
  // Code to establish a connection with Adafruit IO (MQTT Broker)
}

void connectWiFi() {
  // Code to connect to WiFi network
}

WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

#define WLAN_SSID       "Your_WiFi_SSID"
#define WLAN_PASS       "Your_WiFi_Password"

#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "Your_AdafruitIO_Username"
#define AIO_KEY         "Your_AdafruitIO_Key"

#include <WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

class A
{
    int a; int b; int c;
    void ADD()
    {
        a=1;
        b=2;
        c=a+b;
        System.out.println("addition of number "+c );
    }
    void SUB()
    {
        a=1;
        b=2;
        c=a-b;
        System.out.println("subtraction of number "+c );
    }
}
class B extends A
{
    void MULTI()
    {
        a=1;
        b=2;
        c=a*b;
        System.out.println("multiplication of number "+c );
    }
}
class C extends B
{
        void REMAINDER()
    {
        a=1;
        b=2;
        c=a%b;
        System.out.println("remainder of number "+c );
    }
}
class D{
    public static void main(String[] args)
    {
        C r = new C();
        r.ADD();
        r.SUB();
        r.MULTI();
        r.REMAINDER();
    }
}

def is_prime(n):
    
    # Assume the number is prime and try to find counterexamples
    flag = True

    # Deal with special cases
    if n == 0 or n == 1:
        flag = False
    
    # Loop through all numbers between 2 and n - 1, and check if n is NOT prime
    i = 2
    while i < n:
        if n % i == 0:
            flag = False
        i = i + 1
    
    # Output the current value of flag
    return flag

# If the program reached this point, that means the number is prime
return True  

# Loop through all numbers between 2 and n - 1, and check if n is NOT prime
i = 2
while i < n:
    if n % i == 0:
        return False
    i = i + 1

# Deal with special cases
if n == 0 or n == 1:
    return False

#include <DHT.h>

#define DHTPIN 4         // Pin where the DHT11 is connected to the ESP32
#define DHTTYPE DHT11    // Type of DHT sensor used
#define LED_COUNT 4      // Number of LEDs connected
#define LED_START_PIN 13 // Starting pin for LEDs

DHT dht(DHTPIN, DHTTYPE);

const int ledPins[LED_COUNT] = {LED_START_PIN, LED_START_PIN + 1, LED_START_PIN + 2, LED_START_PIN + 3}; // Pins for 4 LEDs
int patternIndex = 0; // Index for the current lighting pattern
unsigned long patternStartTime = 0; // Variable to track the start time of the pattern
unsigned long offTime = 0; // Variable to track the LED off time

void setup() {
  Serial.begin(9600);
  dht.begin();

  for (int i = 0; i < LED_COUNT; ++i) {
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW); // Ensure all LEDs are initially turned off
  }
}

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

  if (patternStartTime == 0) {
    patternStartTime = currentMillis;
  }

  unsigned long patternDuration = 5000; // Pattern duration: 5 seconds
  unsigned long offDuration = 3000; // LED off duration: 3 seconds

  // Execute pattern for 5 seconds
  if (currentMillis - patternStartTime < patternDuration) {
    executePattern();
  } else {
    // Turn off LEDs for 3 seconds after pattern execution
    if (offTime == 0) {
      turnOffAll();
      offTime = currentMillis;
    }

    if (currentMillis - offTime >= offDuration) {
      // Reset variables for the next pattern
      patternIndex = (patternIndex + 1) % 4; // Change to the next pattern
      patternStartTime = 0;
      offTime = 0;
      Serial.print("Pattern: ");
      Serial.println(patternIndex);
    }
  }

  readSensorData(); // Read sensor data and print
}

void executePattern() {
  switch (patternIndex) {
    case 0:
      allOn();
      break;
    case 1:
      alternate();
      break;
    case 2:
      blink();
      break;
    case 3:
      sequence();
      break;
  }
}

void readSensorData() {
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();

  if (!isnan(humidity) && !isnan(temperature)) {
    Serial.print("Humidity: ");
    Serial.print(humidity);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(temperature);
    Serial.println(" °C");
  } else {
    Serial.println("Failed to read from DHT sensor!");
  }
  delay(2000);
}

// Functions for LED patterns (allOn, alternate, blink, sequence) remain the same as before.

void allOn() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], HIGH);
  }
}

void alternate() {
  for (int i = 0; i < LED_COUNT; i += 2) {
    digitalWrite(ledPins[i], HIGH);
    delay(100);
    digitalWrite(ledPins[i], LOW);
    delay(100);
  }
}

void blink() {
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < LED_COUNT; ++j) {
      digitalWrite(ledPins[j], HIGH);
    }
    delay(300);
    for (int j = 0; j < LED_COUNT; ++j) {
      digitalWrite(ledPins[j], LOW);
    }
    delay(300);
  }
}

void sequence() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], HIGH);
    delay(300);
    digitalWrite(ledPins[i], LOW);
  }
}

void turnOffAll() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], LOW);
  }
}

void turnOffAll() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], LOW);
  }
}

void allOn() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], HIGH);
  }
}

void alternate() {
  for (int i = 0; i < LED_COUNT; i += 2) {
    digitalWrite(ledPins[i], HIGH);
    delay(100);
    digitalWrite(ledPins[i], LOW);
    delay(100);
  }
}

void blink() {
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < LED_COUNT; ++j) {
      digitalWrite(ledPins[j], HIGH);
    }
    delay(300);
    for (int j = 0; j < LED_COUNT; ++j) {
      digitalWrite(ledPins[j], LOW);
    }
    delay(300);
  }
}

void sequence() {
  for (int i = 0; i < LED_COUNT; ++i) {
    digitalWrite(ledPins[i], HIGH);
    delay(300);
    digitalWrite(ledPins[i], LOW);
  }
}

void readSensorData() {
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();

  if (!isnan(humidity) && !isnan(temperature)) {
    Serial.print("Humidity: ");
    Serial.print(humidity);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(temperature);
    Serial.println(" °C");
  } else {
    Serial.println("Failed to read from DHT sensor!");
  }
  delay(2000);
}

void executePattern() {
  switch (patternIndex) {
    case 0:
      allOn();
      break;
    case 1:
      alternate();
      break;
    case 2:
      blink();
      break;
    case 3:
      sequence();
      break;
  }
}