Solar Energy-Based AI System For Vehicle Detection And Count

Developed a solar-based AI system capable of detecting and counting the number of vehicles, such as motorcycles and cars, at traffic point

IntermediateFull instructions provided15 days347

Solar Energy-Based AI System For Vehicle Detection And Count

Things used in this project

Hardware components

Seeed Studio XIAO ESP32S3 Sense

Seeed Studio Vision AI Module V2

DFRobot Solar Power Manager 5V

Panel Surya 6WP 5V 1200mA

Saklar On Off On Waterproof 3 Pin

USB Hub, 4 Port

Software apps and online services

Seeed Studio https://sensecraft.se

google colab

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Solder Wire, Lead Free

Plier, Long Nose

Digilent Mastech MS8217 Autorange Digital Multimeter

Story

Introduction

Rapid growth in the number of vehicles in urban areas often leads to prolonged traffic congestion, especially at intersections and major roads. This congestion not only creates time and cost problems, but also adversely affects the environment through increased exhaust emissions. Effective traffic management requires accurate and continuous monitoring of the volume and type of vehicles crossing critical points.

Artificial intelligence (AI) technology has become a promising solution in traffic monitoring. With the ability to detect, classify, and count the number of vehicles in real-time, AI-based systems can provide richer and more efficient data than conventional manual or sensor-based methods. However, energy challenges are often an obstacle, especially in locations that do not have direct access to electricity.

To overcome this obstacle, this research develops an AI-based vehicle detection system powered by renewable energy sources in the form of solar panels. The system is designed to be placed at traffic congestion points to detect and count motorized vehicles such as cars and motorcycles. The use of solar energy ensures that the system can operate autonomously without dependence on conventional electrical power sources, making it suitable for applications in various locations, including remote areas.

This research not only focuses on developing an efficient system, but also emphasizes the aspects of energy sustainability and the relevance of technology in supporting smart city infrastructure. The data obtained from the system is expected to be used to optimize traffic management and design solutions to reduce congestion, as well as identify traffic trends useful for authorities.

solution Overview

Block diagram AI Model Use Swift Yolo

This project is made utilizing AI to detect cars and motorcycles at congestion points, after detecting, calculations are carried out, after detecting, calculations are carried out using the virtual loop method, the calculation data will be entered into the memory card for analysis so that it can be used to solve congestion problems.

Block diagram Panel Surya management

The source of electricity obtained through the solar panel plate, the power obtained is stored in the lippo battery, which manages it all DF Robbot Power Manger 5V

Create Data Model

In utilizing AI, a dataset (a set of data has gone through the filtering process) is needed, this project uses a dataset found in robflow https://universe.roboflow.com/motorxcar/motorxcar this dataset has 3 classes (cars, motorcycles, tricycles) these 3 classes are included in the training data settings in google colab cannot leave these three, otherwise it will show an error message

in the process of training the dataset into a data model o followed the documentatio from wiki seeedstudio

Adjustment of model parameters

in setting the height and width has a defalut setting of 192x192 you can aslo change to 220x220 and should not exceed 240x240

method Virtual Loop For Counting

Virtual Loop Method

system to count moving vehicles from surveillance videos, moving vehicle image is extracted using „double difference image „algorithm and counting is accomplished by tracking vehicle movements within a virtual loop area with the help of detection lines. The system works in 5 steps, as shown in Figure 1. All steps will be described in following sections.

#define carCountMax 9999
#define motorCountMax 9999
int carCount = 0;
int motorCount = 0;
int xCarBegin = 0;
int xCarEnd = 0;
int xMotorBegin = 0;
int xMotorEnd = 0;
// Loop parameters car
bool loopOccupiedCar = false;
bool loopOccupiedPreviousCar = false;
int loopxMinCar = 20;
int loopxMaxCar = 200;
// Loop parameters motor
bool loopOccupiedMotor = false;
bool loopOccupiedPreviousMotor = false;
int loopxMinMotor = 30;
int loopxMaxMotor = 180;
SSCMA AI;

void checkAIBox() {
if (!AI.invoke()) {
if (AI.boxes().size() > 0) {
for (int i = 0; i < AI.boxes().size(); i++) {
int boxX = AI.boxes()[i].x;
int boxW = AI.boxes()[i].w;
int xBegin = boxX;
int xEnd = xBegin + boxW;
if (boxW > 50) {
xCarBegin = xBegin;
xCarEnd = xEnd;
if ((xCarBegin > loopxMinCar) && (xCarEnd < loopxMaxCar)) {
loopOccupiedCar = true;
if (!loopOccupiedPreviousCar) {
carCount++;
if (carCount > carCountMax) {
carCount = carCountMax;
}
loopOccupiedPreviousCar = true;
}
} else {
loopOccupiedCar = false;
loopOccupiedPreviousCar = false;
}
} else {
xMotorBegin = xBegin;
xMotorEnd = xEnd;
if ((xMotorBegin > loopxMinMotor) && (xMotorEnd < loopxMaxMotor)) {
loopOccupiedMotor = true;
if (!loopOccupiedPreviousMotor) {
motorCount++;
if (motorCount > motorCountMax) {
motorCount = motorCountMax;
}
loopOccupiedPreviousMotor = true;
}
} else {
loopOccupiedMotor = false;
loopOccupiedPreviousMotor = false;
}
}
}
} else {
loopOccupiedPreviousCar = false;
loopOccupiedPreviousMotor = false;
}
}
}

Save Data

the data to be saved consist of time, number of motorcycles, number of cars every 30 minutes, when the data has been saved, the calculation will return to 0, the file is saved in the form of a.csv file so that it can be imported into the analysis tool.

Code

#include <Seeed_Arduino_SSCMA.h>
#include <Wire.h>
#include <FS.h>
#include <SD.h>
#include <SPI.h>

// Pin SD card (gunakan pin SD yang sesuai)
#define SD_CS_PIN 21

const int RTC_I2C_ADDRESS = 0x68; // Alamat I2C untuk RTC

const char* days[] = {"Minggu", "Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu"};
const char* months[] = {"Januari", "Februari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember"};

byte second = 0;
byte minute = 0;
byte hour = 0;
byte weekday = 0;
byte monthday = 0;
byte month = 0;
byte year = 0;

#define carCountMax 9999
#define motorCountMax 9999

int carCount = 0;
int motorCount = 0;

int xCarBegin = 0;
int xCarEnd = 0;
int xMotorBegin = 0;
int xMotorEnd = 0;

// Loop parameters car
bool loopOccupiedCar = false;
bool loopOccupiedPreviousCar = false;
int loopxMinCar = 20;
int loopxMaxCar = 200;

// Loop parameters motor
bool loopOccupiedMotor = false;
bool loopOccupiedPreviousMotor = false;
int loopxMinMotor = 30;
int loopxMaxMotor = 180;

SSCMA AI;

unsigned long lastWriteTime = 0;
int fileCount = 1;
bool sd_sign = false;

void setup() {
  Wire.begin();
  Serial.begin(115200);
  

  // Inisialisasi SD card
  if (!SD.begin(SD_CS_PIN)) {
    Serial.println("SD Card initialization failed!");
    return;
  }

  uint8_t cardType = SD.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }

  sd_sign = true; // SD card initialized successfully
  AI.begin();
 
}

void printTime() {
  char buffer[3];
  const char* AMPM = "";
  membacaWaktu();

  byte displayHour = hour; // Gunakan variabel sementara untuk menampilkan jam

  // Menentukan AM atau PM, dan sesuaikan untuk format 12 jam
  if (displayHour >= 12) {
    if (displayHour > 12) {
      displayHour -= 12;
    }
    AMPM = " PM";
  } else {
    if (displayHour == 0) {
      displayHour = 12; // Jika jam 00, tampilkan 12 AM
    }
    AMPM = " AM";
  }

  // Cetak waktu dalam format yang benar
  Serial.print(days[weekday - 1]);
  Serial.print(" ");
  Serial.print(monthday);
  Serial.print(" ");
  Serial.print(months[month - 1]);
  Serial.print(" 20");
  Serial.print(year);
  Serial.print(" ");
  Serial.print(displayHour);
  Serial.print(":");
  sprintf(buffer, "%02d", minute);
  Serial.print(buffer);
  Serial.print(":");
  sprintf(buffer, "%02d", second);
  Serial.print(buffer);
  Serial.println(AMPM);
}

void membacaWaktu() {
  Wire.beginTransmission(RTC_I2C_ADDRESS);
  Wire.write(byte(0)); 
  Wire.endTransmission();

  Wire.requestFrom(RTC_I2C_ADDRESS, 7); 
  second   = bcdToDec(Wire.read());
  minute   = bcdToDec(Wire.read());
  hour     = bcdToDec(Wire.read());
  weekday  = bcdToDec(Wire.read());
  monthday = bcdToDec(Wire.read());
  month    = bcdToDec(Wire.read());
  year     = bcdToDec(Wire.read());
}

byte bcdToDec(byte val) {
  return ((val / 16 * 10) + (val % 16));
}

void checkAIBox() {
  if (!AI.invoke()) {
    if (AI.boxes().size() > 0) {
      for (int i = 0; i < AI.boxes().size(); i++) {
        int boxX = AI.boxes()[i].x;
        int boxW = AI.boxes()[i].w;
        int xBegin = boxX;
        int xEnd = xBegin + boxW;

        if (boxW > 50) {
          xCarBegin = xBegin;
          xCarEnd = xEnd;

          if ((xCarBegin > loopxMinCar) && (xCarEnd < loopxMaxCar)) {
            loopOccupiedCar = true;
            if (!loopOccupiedPreviousCar) {
              carCount++;
              if (carCount > carCountMax) {
                carCount = carCountMax;
              }
              loopOccupiedPreviousCar = true;
            }
          } else {
            loopOccupiedCar = false;
            loopOccupiedPreviousCar = false;
          }
        } else {
          xMotorBegin = xBegin;
          xMotorEnd = xEnd;

          if ((xMotorBegin > loopxMinMotor) && (xMotorEnd < loopxMaxMotor)) {
            loopOccupiedMotor = true;
            if (!loopOccupiedPreviousMotor) {
              motorCount++;
              if (motorCount > motorCountMax) {
                motorCount = motorCountMax;
              }
              loopOccupiedPreviousMotor = true;
            }
          } else {
            loopOccupiedMotor = false;
            loopOccupiedPreviousMotor = false;
          }
        }
      }
    } else {
      loopOccupiedPreviousCar = false;
      loopOccupiedPreviousMotor = false;
    }
  }
}

void writeFile(fs::FS &fs, const char * path, String data) {
  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  file.print(data);
  file.close();
}

void loop() {
  checkAIBox();
  printTime();
  Serial.print("CarCount: ");
  Serial.println(carCount);
  Serial.print("MotorCount: ");
  Serial.println(motorCount);

  unsigned long now = millis();
  if ((now - lastWriteTime) >= 1800000) {
    char filename[32];
    sprintf(filename, "/count_data_%02d-%02d-%02d.csv", monthday, month, year);

    String dataString = String(hour) + ":" + String(minute) + ":" + String(second) + ",";
    dataString += "CarCount: " + String(carCount) + ", MotorCount: " + String(motorCount) + "\n";

    writeFile(SD, filename, dataString);
    Serial.printf("Data saved to: %s\r\n", filename);

    lastWriteTime = now;
    carCount = 0;
    motorCount = 0;
    
  }

  delay(500);
}