Code for Project 1: Smart Street Light

#define LED 19 //Declare the pins of the LED
#define PR 32 //Declare the pins of the light sensor

int brightness;
void setup() {
  pinMode(LED, OUTPUT); //Set LED pins to output mode
  pinMode(PR, INPUT); //Set the light sensor pins to input mode
}

void loop() {
  int light_value = analogRead(PR); //get the light intensity value:
  if(light_value < 1500){//check if value is less than 1500
    analogWrite(LED,0);//turn off led
    delay(100); //delay 0.1s
  }
  else{//check if value is more than 1500
    //Convert the light value into an LED brightness value.
    brightness = map(light_value, 1500, 4095, 0, 255);
    analogWrite(LED, brightness); //set LED brightness
    delay(100); //delay 0.1s
  }
}

Code for Project 2: Smart Traffic Light

#include     //Introducing libraries related to I2C communication
#include   //Introducing 4-digit digital tube related libraries
#define R 14         //Define pins for red traffic lights
#define Y 2          //Define pins for yellow traffic lights
#define G 0          //Define pins for traffic lights and green lights
#define PE 23        //Define the pins of the photoelectric sensor

int carcount = 0;
int redtime = 5000, greentime = 3000, yellowtime = 2000;  //Defining the Time of Traffic Lights
int lasttime = millis();//Defining the Time of Traffic Lights
int Traffic_volume;
int display_time;
char dis[4];  //Create a character array to store the displayed string
TM1650 d;     //Create a TM1650 object
char light[3] = { 'g', 'y', 'r' };
char color;
void setup() {
  Wire.begin();                        //Enable I2C communication
  d.init();                            //Initialize TM1650 object
  d.setBrightness(TM1650_MIN_BRIGHT);  //Set the brightness of TM1650 display
  d.displayOn();                       //Turn on display function
  pinMode(R, OUTPUT);                  //Set the red light pin to output mode
  pinMode(Y, OUTPUT);                  //Set the yellow light pin to output mode
  pinMode(G, OUTPUT);                  //Set the green light pin to output mode
  pinMode(PE, INPUT);                  //Set the photoelectric sensor pins to input mode
  Serial.begin(115200);                  //Initialize baud rate
}

void loop() {
  lasttime = millis();
  for (int i = 0; i < 3; i++) {
    color = light[i];
    trafficlight(color);
    while (display_time >= 1) {     //Countdown display
      itoa(display_time, dis, 10);  //Convert numbers into character arrays
      d.displayString(dis);         //Display countdown on digital display
      for (int j = 0; j < 2; j++) {
        if (digitalRead(PE) == 0) {  // Does the infrared obstacle avoidance sensor detect the vehicle
          carcount += 1;
        }
        delay(500);
      }
      display_time--;  //Seconds minus 1
    }
  }
  ////Determine if the traffic flow within 15 seconds is greater than 5
  if (carcount > 5 && millis() - lasttime < 15000) {
    redtime = 3000;
    greentime = 5000;
 }else{
    redtime = 5000;
    greentime = 3000;
  }
  carcount = 0;
}

void trafficlight(char color) {
  // Check if the traffic light is red
  if (color == 'r') {
    digitalWrite(R, HIGH);
    digitalWrite(Y, LOW);
    digitalWrite(G, LOW);
    display_time = redtime / 1000;
  }
  // Check if the traffic light is green
  if (color == 'g') {
    digitalWrite(R, LOW);
    digitalWrite(Y, LOW);
    digitalWrite(G, HIGH);
    display_time = greentime / 1000;
  }
  // Check if the traffic light is yellow
  if (color == 'y') {
    digitalWrite(R, LOW);
    digitalWrite(Y, HIGH);
    digitalWrite(G, LOW);
    display_time = yellowtime / 1000;
  }
}

Code for Project 3: Smart Crossing 

#include <Adafruit_NeoPixel.h>
#include <ESP32Servo.h>

// Pin definitions
#define R 14          // Red traffic light pin
#define Y 2           // Yellow traffic light pin
#define G 0           // Green traffic light pin
#define Serve 4       // Servo motor pin
#define Button 25     // Button pin (assumed connected to GND)
#define LED_PIN 18    // RGB LED strip pin
#define LED_COUNT 9   // Number of LEDs in strip
#define BRIGHTNESS 50 // LED brightness (0-255)
#define buzzer 12     // Buzzer pin

Servo Myservo;
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN);

bool buttonPressed = false;
unsigned long lastButtonTime = 0;
const unsigned long debounceDelay = 50;  // debounce button delay

void setup() {
  strip.begin();
  strip.setBrightness(BRIGHTNESS);

  pinMode(R, OUTPUT);
  pinMode(Y, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(Button, INPUT_PULLUP); // button connects to GND when pressed
  pinMode(buzzer, OUTPUT);

  Myservo.attach(Serve);

  // Default mode setup
  setDefaultMode();
}

void loop() {
  // Check for button press with simple debounce
  if (digitalRead(Button) == LOW) {
    unsigned long currentMillis = millis();
    if ((currentMillis - lastButtonTime) > debounceDelay) {
      lastButtonTime = currentMillis;
      if (!buttonPressed) { // only respond to first press until reset
        buttonPressed = true;
        runButtonSequence();
      }
    }
  }

  // Nothing to do continuously in default mode - it just stays there
}

// Set the system to default mode:
// servo 0 deg, green traffic light, red LED strip, no buzzer
void setDefaultMode() {
  Myservo.write(0);     // Servo up/open
  Traffic_Light(0, 0, 1); // Traffic light green ON, others off
  setStripColor(255, 0, 0); // LED strip RED
  noTone(buzzer);
  buttonPressed = false; // reset button flag to allow next press
}

// Helper: Control traffic light LEDs
void Traffic_Light(int r, int y, int g) {
  digitalWrite(R, r);
  digitalWrite(Y, y);
  digitalWrite(G, g);
}

// Helper: Set all LEDs on strip to given color and show
void setStripColor(uint8_t red, uint8_t green, uint8_t blue) {
  for (int i = 0; i < LED_COUNT; i++) {
    strip.setPixelColor(i, strip.Color(red, green, blue));
  }
  strip.show();
}

// Runs the sequence triggered by button press
void runButtonSequence() {
  // 1. Wait 5 seconds countdown (no buzzer)
  delay(5000);

  // 2. Turn traffic light yellow for 2 seconds
  Traffic_Light(0, 1, 0); // Yellow ON
  delay(2000);

  // 3. Turn traffic light red, servo down (90 deg), LED strip green
  Traffic_Light(1, 0, 0); // Red ON
  Myservo.write(90);      // Servo down/closed
  setStripColor(0, 255, 0); // LED strip GREEN

  // 4. Buzzer 8 seconds countdown with 0.5 second on/off intervals
  unsigned long buzzerCountdown = 8000; // 8 seconds total
  unsigned long interval = 500;
  unsigned long startMillis = millis();

  while (millis() - startMillis < buzzerCountdown) {
    tone(buzzer, 1000); // Buzz ON at 1kHz
    delay(interval);
    noTone(buzzer);     // Buzz OFF
    delay(interval);
  }
  noTone(buzzer);

  // 5. Return to default mode
  setDefaultMode();
}

Code for Project 4: Smart Parking Lot 

#include <ACB_MP3.h>
#include <Wire.h>
#include <MFRC522_I2C.h>
#include <ESP32Servo.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>
#include <List.hpp>

#define SERVE 4
#define PE 23
#define RAILING_CLOSE 90
#define RAILING_OPEN 0
#define NUM_ROWS 2
#define NUM_COLS 16

const int TOTAL_PARKING = 5;
int parking_space = TOTAL_PARKING;
int cost = 0;
String rfid_str;

MFRC522_I2C mfrc522(0x28, -1);
Servo Myservo;
hd44780_I2Cexp lcd(0x27, NUM_ROWS, NUM_COLS);
ACB_MP3 MyMP3;

List<String> card_list;
List<int> time_list;

void setup() {
  Wire.begin();
  mfrc522.PCD_Init();
  Myservo.attach(SERVE, 500, 2500);
  Myservo.write(RAILING_CLOSE);
  delay(500);

  lcd.begin(NUM_COLS, NUM_ROWS);
  lcd.backlight();
  lcd.clear();

  pinMode(PE, INPUT);
  MyMP3.init(16, 17);
  delay(500);

  Serial.begin(115200);
}

void loop() {
  spaceDisplay(parking_space);

  if (digitalRead(PE) == 0) {
    if (parking_space == 0) {
      Myservo.write(RAILING_CLOSE);
    } else {
      Myservo.write(RAILING_OPEN);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Register IC Card");

      while (!mfrc522.PICC_IsNewCardPresent() || !mfrc522.PICC_ReadCardSerial());

      MyMP3.playInFolder(0x03);
      delay(1000);

      rfid_str = getCardUID();

      int attempt = 0;
      int index = indexOfList(rfid_str);
      while (index >= 0 && attempt < 3) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Failed!");
        lcd.setCursor(0, 1);
        lcd.print("Use New Card!");

        while (!mfrc522.PICC_IsNewCardPresent() || !mfrc522.PICC_ReadCardSerial());
        MyMP3.playInFolder(0x03);
        delay(1000);
        rfid_str = getCardUID();
        index = indexOfList(rfid_str);
        attempt++;
      }

      if (index >= 0) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Card Exists");
        lcd.setCursor(0, 1);
        lcd.print("Try Again Later");
        delay(2000);
        Myservo.write(RAILING_CLOSE);
        return;
      }

      card_list.add(rfid_str);
      time_list.add(millis());
      parking_space--;

      MyMP3.playInFolder(0x01);
      delay(2000);
      Myservo.write(RAILING_CLOSE);

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Successful!");
      lcd.setCursor(0, 1);
      lcd.print("Start Billing!");
      delay(2000);
      lcd.clear();
    }
  }

  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) {
    rfid_str = getCardUID();
    int index = indexOfList(rfid_str);

    if (index == -1) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Unrecognized");
      lcd.setCursor(0, 1);
      lcd.print("IC Card!");
      delay(2000);
      lcd.clear();
      return;
    }

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Billing...");
    delay(1000);

    cost = ((millis() - time_list[index]) / 1000) * 2;

    lcd.setCursor(0, 1);
    lcd.print("Cost:");
    lcd.setCursor(5, 1);
    lcd.print(cost);

    delay(2000);

    Myservo.write(RAILING_OPEN);
    MyMP3.playInFolder(0x02);
    delay(2000);
    Myservo.write(RAILING_CLOSE);

    card_list.remove(index);
    time_list.remove(index);
    parking_space++;
    lcd.clear();
  }
}

String getCardUID() {
  String uid = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    uid += String(mfrc522.uid.uidByte[i], HEX);
  }
  mfrc522.PICC_HaltA();
  return uid;
}

int indexOfList(String s) {
  for (int i = 0; i < card_list.getSize(); i++) {
    if (s == card_list[i]) {
      return i;
    }
  }
  return -1;
}

void spaceDisplay(int space) {
  lcd.setCursor(0, 0);
  lcd.print("Parking Space");
  lcd.setCursor(0, 1);
  lcd.print("Total:");
  lcd.setCursor(6, 1);
  lcd.print(TOTAL_PARKING);
  lcd.setCursor(8, 1);
  lcd.print("Rest:");
  lcd.setCursor(13, 1);
  lcd.print(space);
  delay(200);
}

Code for Project 5: Drag Racing Tree Light with Lap Detection

#include <Wire.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h>

// Pin definitions
#define R 14          // Red traffic light pin
#define Y 2           // Yellow traffic light pin
#define G 0           // Green traffic light pin
#define buzzer 12     // Buzzer pin
#define PE 23         // Photoelectric (IR) sensor pin
#define Button 25     // Button pin (connected to GND)

// Create LCD object
hd44780_I2Cexp lcd;

int laps = 3;
bool running = false;

// Button debounce variables
bool lastButtonState = HIGH;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

// IR sensor debounce variables
unsigned long lastIrTime = 0;
const unsigned long irDebounceDelay = 1000; // 1 second debounce

// Utility function to center print on LCD
void lcdPrintCenter(int row, const String &text) {
  int startPos = (16 - text.length()) / 2;
  lcd.setCursor(startPos, row);
  lcd.print(text);
}

void setup() {
  pinMode(R, OUTPUT);
  pinMode(Y, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(buzzer, OUTPUT);
  pinMode(PE, INPUT);
  pinMode(Button, INPUT_PULLUP);  // Button to GND uses internal pullup

  // Start with all LEDs ON
  digitalWrite(R, HIGH);
  digitalWrite(Y, HIGH);
  digitalWrite(G, HIGH);
  noTone(buzzer);

  lcd.begin(16, 2);
  lcd.clear();
  lcd.print("Push Button to");
  lcd.setCursor(0, 1);
  lcd.print("Start");
}

void loop() {
  // Button reading with debounce
  bool reading = digitalRead(Button);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading == LOW && !running) {
      startSequence();
    }
  }
  lastButtonState = reading;

  // Lap counting using IR with debounce
  if (running) {
    int irValue = digitalRead(PE);
    if (irValue == LOW) { // Detection assumed at LOW
      if (millis() - lastIrTime > irDebounceDelay) {
        lastIrTime = millis();
        handleLapDetection();
      }
    }
  }
}

void startSequence() {
  running = true;
  laps = 3;

  // Turn off all LEDs initially
  digitalWrite(R, LOW);
  digitalWrite(Y, LOW);
  digitalWrite(G, LOW);

  delay(3000); // Wait 3 seconds after button press (countdown)

  // Red LED blink 2 times with buzzer 500Hz, 1 sec interval (on 500ms, off 500ms)
  for (int i = 0; i < 2; i++) {
    digitalWrite(R, HIGH);
    tone(buzzer, 500);
    delay(500);
    digitalWrite(R, LOW);
    noTone(buzzer);
    delay(500);
  }

  // Red to Yellow interval 0.25 sec
  delay(250);

  // Yellow LED on for 2 seconds, buzzer only on first 0.5 at 500 Hz
  digitalWrite(Y, HIGH);
  tone(buzzer, 500);
  delay(500); // buzzer on 0.5 second
  noTone(buzzer);
  delay(1500); // yellow remains on additional 1.5 seconds without buzzer
  digitalWrite(Y, LOW);

  // Yellow to Green interval 0.25 sec
  delay(250);

  // Green LED on for 3 seconds, buzzer at 1 kHz for first 2 seconds
  digitalWrite(G, HIGH);
  tone(buzzer, 1000);
  delay(2000); // buzzer on
  noTone(buzzer);
  delay(1000); // green remains on extra 1 second without buzzer
  digitalWrite(G, LOW);

  // Display centered "Laps Remaining:" on first row
  lcd.clear();
  lcdPrintCenter(0, "Laps Remaining:");

  // Display centered laps number on second row
  lcd.clear();
  lcdPrintCenter(0, "Laps Remaining:");
  String lapsStr = String(laps);
  lcdPrintCenter(1, lapsStr);
}

void handleLapDetection() {
  if (laps > 1) {
    laps--;
    String lapsStr = String(laps);
    lcdPrintCenter(1, lapsStr);
  } else if (laps == 1) {
    laps = 0;
    lcd.clear();
    lcdPrintCenter(0, "FINISH!");
    delay(3000);
    resetSystem();
  }
}

void resetSystem() {
  running = false;
  laps = 3;

  lcd.clear();
  lcd.print("Push Button to");
  lcd.setCursor(0, 1);
  lcd.print("Start");

  // Turn all LEDs ON
  digitalWrite(R, HIGH);
  digitalWrite(Y, HIGH);
  digitalWrite(G, HIGH);
  noTone(buzzer);
}

Code Breakdown

Project 1: Smart Street Light

Pin Definitions:

#define LED 19
#define PR 32

• LED – Controls the street light brightness.
• PR – Reads input from the light sensor module.

Variables:

• int brightness; – Stores LED brightness level.
  
  

setup() Function:

• Configures LED pin as output.
• Configures light sensor pin as input.
  
  

loop() Function:

• Reads light intensity using analogRead(PR).
• If value < 1500 → LED OFF.
• Else → Maps sensor value (1500–4095) to brightness range (0–255) and sets LED brightness.
• Adds 0.1s delay for smooth transitions.
  
  

Project 2: Smart Traffic Light

Libraries Used:

#include <Wire.h>  - Enables I2C communication
#include <TM1650.h> - Controls 4-digit LED display

Pin Definitions:

#define R 14
#define Y 2
#define G 0
#define PE 23

• R, Y, G – Traffic light LEDs.
• PE – Photoelectric sensor for vehicle detection.
  
  

Variables:

• carcount – Tracks detected cars.
• redtime, greentime, yellowtime – Light durations.
• display_time – Countdown timer display.
• char light[3] = {'g','y','r'} – Traffic light sequence.
  
  

setup() Function:

• Initializes I2C and TM1650 display.
• Sets light pins as outputs, sensor pin as input.
• Starts serial communication.
  
  

loop() Function:

• Cycles through green → yellow → red lights.
• Updates display countdown each second.
• Counts cars passing during green phase.
• Adjusts light durations if traffic volume > 5 in 15 seconds.
• trafficlight() Function:
• Activates correct light color.
• Sets display_time for countdown.

Project 3: Smart Crossing

Libraries Used:

#include <Adafruit_NeoPixel.h> - RGB LED strip control
#include <ESP32Servo.h>  - Servo motor control

Pin Definitions:
#define R 14
#define Y 2
#define G 0
#define Serve 4
#define Button 25
#define LED_PIN 18
#define LED_COUNT 9
#define BRIGHTNESS 50
#define buzzer 12

• R, Y, G – Traffic light LEDs.
• Serve – Servo gate control.
• Button – Crossing activation.
• LED_PIN – RGB strip data pin.
• buzzer – Sound alert.
  
  

setup() Function:

• Initializes LED strip, servo, traffic lights, buzzer.
• Sets default crossing mode.
  
  

loop() Function:

• Waits for button press (debounced).
• Runs crossing sequence when pressed.
• runButtonSequence() Function:
• Wait 5 seconds.
• Yellow light for 2s.
• Red light ON, servo down, LED strip green.
• Buzzer beeps for 8 seconds.
• Return to default mode.
  

Project 4: Smart Parking Lot

Libraries Used:

#include <acb_mp3.h> - MP3 audio control
#include <Wire.h>  - I2C communication
#include <MFRC522_I2C.h>  - RFID reader via I2C
#include <ESP32Servo.h>   - Servo control
#include <hd44780.h>  - LCD control
#include <hd44780ioClass/hd44780_I2Cexp.h>
#include <List.hpp>  - List handling for card IDs

Pin Definitions:

#define SERVE 4
#define PE 23
#define RAILING_CLOSE 90
#define RAILING_OPEN 0

• SERVE – Servo gate pin.
• PE – Photoelectric vehicle detection.
• RAILING_CLOSE/RAILING_OPEN – Servo angles.
  
  

Variables:

• TOTAL_PARKING – Maximum parking slots.
• parking_space – Tracks available slots.
• card_list – Stores active RFID card IDs.
• time_list – Stores parking start times.
  
  

setup() Function:

• Initializes RFID, servo, LCD, MP3 module.
• Sets initial gate position and displays default info.
  
  

loop() Function:

• If car detected at entry:
• Prompts for IC card registration.
• Stores new card, decreases available slots, starts billing.
• If IC card detected at exit:
• Calculates parking fee.
• Opens gate and removes card from list.
• Helper Functions:
• getCardUID() – Reads card UID.
• indexOfList() – Finds card in list.
• spaceDisplay() – Updates LCD display.
  
  

The ACEBOTT: Intelligent Transport Education Kit – Level 1 stands out as a powerful and practical tool for introducing STEM education in an engaging and hands-on way. Through a series of projects—including the Smart Street Light, Smart Traffic Light, Smart Crossing, Smart Parking Lot System, and an additional Drag Racing Tree Light with Lap Detection, we demonstrated real-world transportation concepts that students can build, program, and fully understand.

Instead of relying solely on visual coding platforms, we used the Arduino IDE to program each system, giving students a deeper insight into actual coding logic and embedded systems design. For younger students (elementary level), ACE Code or Scarth-based block programming is also available. This bridges the gap between theory and real-world application, allowing learners to build projects with a professional-level toolchain.

  
In summary, the ACEBOTT intelligent transportation kit is a well-rounded, beginner-friendly tool for teaching STEM concepts through hands-on, interactive projects. It helps students easily understand the fundamentals of electronics, automation, and intelligent transportation systems using real-world applications. With all essential components already included, it's a practical choice for schools, STEM educators, and workshops aiming to deliver meaningful tech learning experiences.

References

• Arduino Documentation
  
• Acebott Official Website

• ACEBOTT QE027 Intelligent Transportation L1 Documentation