💡 Inspiration

In the dense forests and mountainous regions of Kerala, especially areas like Nelliampathy, wild elephants frequently traverse routes that have been part of their migratory patterns for centuries. These pathways, known locally as “Aanathaara” (elephant corridors), are deeply embedded in the landscape and ecology. However, with rapid human expansion — including roads, farmlands, and settlements — these natural trails now intersect with human activity, often with devastating consequences.

While locals may instinctively understand where and when to be cautious, most visitors, tourists, and even daily commuters remain unaware of the risks.In early 2025, a tragic incident occurred in Nelliampathy, Kerala. A German tourist, unfamiliar with the terrain and unaware of a wild elephant blocking the road, ventured forward despite the locals’ warnings. Tragically, he encountered the elephant and lost his life. Traditional static signage, such as painted boards warning of elephants, often fades into the background and fails to provide real-time, actionable alerts. The result? Dangerous — and sometimes fatal — encounters that could have been avoided with better awareness.

That's where EleTect 1.5 comes in — combining TinyML, LoRa, solar power, and interactive signage to proactively warn and deter.

🛠️ What It Does

EleTect 1.5 is an advanced extension of the award winning EleTect 1.0 system. It introduces an interactive digital signage system that provides real-time warnings to riders and drivers when elephants are present ahead on forest roads.

🐘 EleTect Node (Detection Unit)

• Detects elephants using a TinyML-powered system which can identify an elephant using vision and sound.
• Uses LoRa to send elephant presence status to the signage node.
• Triggers a deterrent mechanism (e.g., honeybee sound) only when vehicles are present.

🚦 Signage Node (Warning System)

• Placed 500m before known elephant crossings.
• Displays a bright, red, flashing elephant warning.
• Integrated camera detects the presence of vehicles.
• Sends vehicle presence data to EleTect Node.
• All powered entirely by solar energy.

🔁 Workflow

• Elephant detected ➡️ EleTect Node triggers LoRa alert to Sign Board.
• Signboard flashes elephant warning if vehicles are approaching.
• Signboard checks for vehicles using camera:

If vehicles are detected → message sent to EleTect Node.

EleTect Node waits 10 minutes → plays deterrent bee sound.

• After elephants leave, detection stops → Signboard resets.

🐘 What is Eletect?

Eletect is a technology-driven system designed to detect elephants early, deter them harmlessly, and alert nearby communities. Its goal is to protect lives, foster coexistence, and contribute to wildlife conservation.

Despite their size and power, elephants have a surprising vulnerability: they are instinctively afraid of bee buzzing sounds. By carefully and harmlessly using this natural deterrent, Eletect can safely redirect elephants away from human settlements without harming them. This peaceful strategy respects both humans and elephants.

⚠️ Disclaimer

Before continuing with this tutorial, please make sure you have read the complete EleTect documentation.
The first part—which covers building the Detection + Deterrence Node—is fully explained there and not repeated here to avoid making this documentation unnecessarily long.

This guide should be considered as a continuation of the original EleTect documentation.

👉 Click here to read the full EleTect documentation.

⚙️ How it Works

At the forest boundaries, multiple TinyML-powered nodes are deployed. Each node can:

• Detect elephants using a vision-based TinyML model on the Seeed Studio Grove Vision AI V2 module.
• Analyze sound using a Seeed Studio XIAO ESP32S3 Sense, running a TinyML audio model to detect elephant vocalizations.
• Trigger deterrents by playing honeybee buzzing sounds through an onboard speaker.
• Communicate via LoRa/LoRaWAN with a central master node to ensure real-time updates even in remote areas.

The system is completely solar-powered, making it sustainable and ideal for deployment in remote forest region

🌿 Field Survey, Official Approval & Real-World Trials

To ensure EleTect was not just a lab prototype but a real-world conservation tool, our team carried out an extensive ground survey and obtained official permission for field testing from the Divisional Forest Officer (DFO) of Kothamangalam, Mr. Varun Dalia, IFS, and Forest Range Officer, Mr. Jaleel.

🧭 On-Ground Survey & Study Area

The field research took place in Kothamangalam and Kottapady, Kerala — regions at the edge of the Western Ghats that experience frequent elephant incursions into farmlands and villages.

We conducted household-level surveys to assess the scale and nature of human–elephant conflict (HEC) in these areas. From 100 surveyed households, 85 reported direct encounters with elephants, while:

• 66% suffered crop destruction, and
• 38.4% experienced human injury or fatalities related to elephant incidents.

This data emphasized the urgent need for early warning and deterrent systems like EleTect.

🏛️ Collaboration & Forest Department Approval

After the survey phase, we formally presented EleTect to the DFO Office, Kothamangalam, and Forest Range Office to discuss its technical operation, safety, and ecological compatibility.

Following evaluation, the Forest Department granted permission to conduct live field trials in designated forest-border regions.

This collaboration provided both ethical validation and administrative support, ensuring that EleTect aligns with wildlife protection policies and sustainable forest management goals.

🏆 IEEE IAS CMD Humanitarian Award 2025

We are proud to share that EleTect was awarded the IEEE IAS CMD Humanitarian Project Award for the year 2025, in recognition of its innovative, impactful, and humanitarian approach to addressing the growing crisis of human–elephant conflict. As lives continue to be lost in forest-border regions, our team proposed a non-lethal, intelligent, and community-centered solution that fuses traditional tribal practices—such as the use of honeybee deterrents—with modern TinyML and edge AI technologies. EleTect demonstrates how technology can honor ecological wisdom while enhancing safety and peaceful coexistence.
 

As part of this recognition, we were invited to present EleTect at the IEEE IAS Annual Meeting 2025 in Taiwan, where we showcased the system’s design, field deployments, and real-world impact to an international audience of researchers and engineers. The smart signage module, developed under EleTect 1.5, is a functional extension of the project, aimed at solving additional dimensions of the problem—including early detection, deterrence, communication, and public awareness.

Architecture

Signages will be placed like below.

🔗 Components Used

Component

EleTect Node

ESP32-C6 DevKitC-1

Grove LoRa-E5 Module

Solar Charging Modules

Custom battery pack

Custom LED panel

Enclosure Using Acrylic sheet or 3D Printed

DigiKey-My-list  for directly shopping from here digikey click the link

🛠️ Step 1: Build the Custom Signage Enclosure

In this step, we’ll create a weatherproof and visually impactful enclosure that houses the electronics for the elephant warning signage system. The enclosure is made from 5mm clear acrylic sheets, designed in Fusion 360, and laser cut for precision.

🧰 Materials Needed

• 5mm thick clear acrylic sheet
• Access to a laser cutter
• Acrylic glue (e.g., Weld-On 3 or Fevikwik)
• Vinyl cutter and precision knife
• Reflective vinyl sticker sheet (yellow and red)
• Matte black vinyl sheet
• Clamps or tape for alignment
• Fusion 360 or similar CAD software
• Cooling film

🖥️ Step 1.1: Design the Enclosure in Fusion 360

Create a Design in Fusion360 for the enclosure.

Sketch the front panel dimensions based on your component layout (camera, LEDs, LoRa antenna, etc.).Ensure the box has enough depth to house the electronics.

Export each face of the enclosure as a DXF file for laser cutting.

🔥 Step 1.2: Laser Cut the Acrylic Panels

• Upload the DXF files to your laser cutter’s software.
• Set your laser cutter to the appropriate power/speed settings for 5mm acrylic.
• Carefully cut each panel and label them as you go to avoid confusion during assembly.Peel off any protective film after cutting.

👉 Safety first! Wear proper eye protection and operate the cutter in a ventilated area.

🧷 Step 1.3: Assemble the Enclosure

Lay out all the cut pieces on a clean surface.

Begin with the base and edges.Apply acrylic glue along the joining edges and press pieces together.Use clamps or masking tape to hold parts in place until dry.

Continue assembling all sides until the box is complete.

Let the entire assembly cure for several hours to ensure strong bonding.

👉 Tip: Double-check the alignment before applying glue — acrylic bonds instantly!Grind and smoothen the irregular edges using a grinding tool.

✨ Step 1.4: Apply the Reflective Graphics

Design an elephant silhouette and the text “ELEPHANTS AHEAD” using vector software (e.g., Adobe Illustrator or Inkscape).

Cut the design using a vinyl cutter from reflective vinyl sheet.

Clean the front acrylic panel with a microfiber cloth.Carefully transfer the reflective vinyl design onto the panel using transfer tape.

Cover the remaining  back and side edges with matte black vinyl to block internal components and focus attention on the warning.

👉 Result: A bold, reflective front that is highly visible when headlights or onboard LEDs shine on it.

💡 Step 2: Building the Custom LED Panel

In this step, we’ll design and assemble a high-visibility LED panel in the shape of an elephant, mounted inside our previously built acrylic enclosure. This panel serves as a visual alert, visible from a distance even in low-light conditions.

🧰 Materials Required

• 4x generic dotted PCBs (perforated board)
• 400x 5mm Red Clear LEDs
• 200x 68Ω resistors
• 22 AWG hookup wire
• Soldering iron + solder wire
• Black matte spray paint (optional, for aesthetics)
• 1x N-channel MOSFET (e.g., IRLZ44N)
• 1x 220Ω resistor (for MOSFET gate)
• 1x Custom 3S3P LiPo battery pack (11.1V nominal)
• Heat shrink, glue, basic tools

🎨 Step 2.1: Prep and Paint the PCBs

Take your four dotted PCBs paint them with matte black paint — this step is optional but gives a professional look and improves contrast against the red LEDs.

Let them dry completely.

👉 Tip: Paste a sheet or paper on the back of the pcb before painting so that the paint won't get into the backside✂️ Step 2.2: Join the PCBs to Form a Large Panel

Measure and cut the boards to your desired dimensions.

Carefully align and glue the four PCBs together to create a larger panel.

Make sure all the solder pads align properly and the board is flat.

🐘 Step 2.3: Trace and Plan the LED Layout

Place the vinyl elephant signage or sticker over the panel as a reference.Using a white marker or chalk, roughly trace the outline of the elephant and the text “ELEPHANTS AHEAD”.

Plan the LED positions inside this trace to match the shape as closely as possible

👉 Tip: Leave a bit of spacing between each LED to avoid overcrowding.

🔗 Step 2.4: LED Chain Design

We’ll use a simple and efficient wiring scheme:

2 LEDs in series + 1 resistor (68Ω) = 1 chain

Multiple such chains are wired in parallel across the panel

Why this config?With a 3S (11.1V) LiPo battery, 2 red LEDs (approx. 2V each) + 68Ω resistor draws safe current and provides balanced brightness.

🧪 Step 2.5: Prototype and Test the LED Circuit

First, build one LED chain on a breadboard.

Power it using a bench power supply.

Confirm brightness and measure current draw.Once satisfied, continue soldering the full design onto the board.

🔩 Step 2.6: Solder All LED Chains

Start from the top of the board, following your traced outline.

Insert 2 LEDs in series and connect the 68Ω resistor to complete the chain.Continue placing and soldering LED chains across the board, following your elephant outline and text.

Use thin wires to connect common positive and negative rails at the back.

After soldering, check for shorts and test small sections individually.

⚡ Step 2.7: Power and Drive Circuit

Connect all the negative lines from each LED chain to a MOSFET drain.Connect the MOSFET source to ground.Use a 220Ω resistor on the MOSFET gate and connect it to your microcontroller’s digital output (for PWM or ON/OFF control).The positive rail of all LED chains goes directly to the power supply.

Check heat levels and ensure no resistors or LEDs are overheating.

✅ Final Testing

Securely mount the pack inside the enclosure and wire it to the LED panel via a toggle switch or microcontroller control..Turn on the system and ensure all LEDs light up in the correct pattern.

But unfortunately, it didn’t quite meet my expectations. During the first test, I wasn’t fully satisfied, as it didn’t look as refined or close to the vision I had in mind.

But then I had a small idea — if I could diffuse the LED light, it might look much cleaner and more aesthetically pleasing. To quickly test this, I placed a simple A4 sheet between the front acrylic panel and the LED panel.

After diffusing it with an A4 sheet, the display looked even better—cleaner and clearer. There were some dead LEDs ,so i replaced them and it worked perfect.

Initially, my idea was to keep the elephant silhouette completely black when the sign was inactive and then illuminate it in red once activated. To match this concept, I painted the PCB black so that the LEDs would remain invisible until turned on. However, when I tried adding a simple A4 sheet as a diffuser, it disrupted the clean aesthetic I was aiming for, as the sheet made the panel look less appealing.

To tackle this, I thought of using smoked acrylic. This material would give the panel a sleek black look when off, while still allowing the red LEDs to shine through when active. Pairing it with a thin frosted acrylic sheet underneath would help diffuse the light evenly, achieving both functionality and the desired aesthetics.

The challenge, however, was that smoked acrylic was not easily available at the time, and even if sourced, it would add to the cost and overall weight of the system. To find a more practical alternative, I came up with the idea of applying car window cooling film to the back of the front panel to replicate the smoked effect. For light diffusion, I could then use a lightweight and low-cost option like a thin plastic sheet or even butter paper. This way, I could preserve both the aesthetics and the functionality without compromising on budget or weight. Firstly apply the cooling film on the back of the front acrylic panel.

Then use a thin plastic sheet or butter paper to diffuse the light on top of that.

So to test it i quickly made a setup and tested it.

Finally, after several trials, I was able to achieve exactly the result I had envisioned: a signage system that remains sleek and minimal when inactive, but transforms into a striking, attention-grabbing warning when activated.

Step 3:Custom model for vehicle detection

Grove Vision AI Module V2  Overview

The Grove Vision AI Module V2 is a game-changer in the world of microcontroller-based AI vision modules. Powered by the ARM Cortex-M55, it outperforms regular ESP32 CAM-based boards while consuming significantly less power. After extensive testing, we found it to be exceptionally powerful and precise.

Comparison with Xiao ESP32-S3 Sense Board

In our tests, we compared the Grove Vision AI Module V2 with the Xiao ESP32-S3 Sense board. The difference is clear in the comparison video. The Grove Vision AI Module V2 delivers a higher frame rate while maintaining low power consumption, outperforming the Xiao ESP32-S3 Sense board.

The product arrives in standard Seeed Studio packaging. Inside the box, you'll find:

• The Vision AI Module V2
• A connecting wire
• A sticker with a brief introduction to the module

Specifications

The module features the WiseEye2 HX6538 processor, which includes:

• Dual Core ARM Cortex M55:
• High Performance Core clocked at 400MHz
• High Efficiency Core clocked at 150MHz
• ARM Ethos-U55 microNPU (Neural Processing Unit) clocked at 400MHz
• PUF (Physical Unclonable Function) hardware security

These features enable rapid AI and ML processing, making it ideal for computer vision projects requiring high frame rates and low power consumption.

Memory and Connectivity

• 60MB of onboard flash memory
• PDM microphone
• SD card slot
• External camera connectivity
• CSI port
• Grove connector
• Dedicated pinout for connecting Xiao series microcontroller boards from Seeed Studio

Software Compatibility

The module supports a wide range of AI models and frameworks:

• SenseCraft AI models, including Mobilenet V1/V2, EfficientNet-Lite, YOLO v5/v8
• TensorFlow and PyTorch frameworks

It is compatible with popular development platforms like Arduino, Raspberry Pi, and ESP dev boards, making it versatile for further development.

Applications

Our tests confirmed that the Grove Vision AI Module V2 is suitable for a variety of applications, including:

• Industrial Automation: Quality inspection, predictive maintenance, voice control
• Smart Cities:Device monitoring, energy management
• Transportation: Status monitoring, location tracking
• Smart Agriculture: Environmental monitoring
• Mobile IoT Devices: Wearable and handheld devices

We can declare with confidence that the Grove Vision AI Module V2 delivers unmatched AI processing capabilities, flexible model support, a wealth of peripheral possibilities, high compatibility, and an entirely open-source environment after conducting rigorous testing. It is a great option for a variety of AI and computer vision applications because to its low power consumption and great performance.

Hardware Overview

Refer this article, 2024 MCU AI Vision Boards: Performance Comparison, it is possible to confirm how powerful Grove Vision AI (V2) is when compared to Seeed Studio Grove - Vision AI Module, Espressif ESP-EYE, XIAO ESP32S3 and on an Arduino Nicla Vision. Do check it out.

Refer this article, 2024 MCU AI Vision Boards: Performance Comparison, it is possible to confirm how powerful Grove Vision AI (V2) is when compared to Seeed Studio Grove - Vision AI Module, Espressif ESP-EYE, XIAO ESP32S3 and on an Arduino Nicla Vision. Do check it out.

Connecting to a CSI interface camera

Once you have the Grove Vision AI V2 and camera ready to go, then you can connect them via the CSI connection cable. When connecting, please pay attention to the direction of the row of pins and don't plug them in backwards.

Boot / Reset / Flashed Driver

Boot

If you have used some unusual method that has caused the Grove Vision AI to not work properly at all (at the software level), then you may need to put the device into BootLoader mode to revive the device. Here is how to enter BootLoader mode.

Method 1

Please disconnect the connection cable between the Grove Vision AI and your computer, then press and hold the Boot button on the device without releasing it. At this time, please connect Grove Vision AI to your computer with a Type-C type data cable, and then release it again. At this point the device will enter BootLoader mode.

Method 2

With the Grove Vision AI connected to your computer, you can enter BootLoader mode by pressing the Boot button and then quickly pressing the Reset button.

Reset

If you're experiencing problems with device data suddenly not uploading or images getting stuck, you can try restarting your device using the Reset button.

Driver

If you find that the Grove Vision AI V2 is not recognised after connecting it to your computer. Then you may need to install the CH343 driver on your computer. Here are some links to download and install the CH343 driver.

Windows Vendor VCP Driver One-Click Installer: CH343SER.EXE

Windows Vendor VCP Driver: CH343SER.ZIP

Windows CDC driver one-click installer: CH343CDC.EXE

Windows CDC driver: CH343CDC.ZIP

macOS Vendor VCP Driver: CH34xSER_MAC.ZIP

Below is a block Diagram of the Grove Vision AI (V2) system, including a camera and a master controller.

Getting started with SenseCraft Web Toolkit.

SenseCraft AI empowers users to effortlessly deploy a vast library of publicly available AI models on tot heir edge devices such as Recomputer(Jetson), XIAOS3, and more, and provides a seamless and user-friendly experience, allowing you to deploy public AI models directly on to your edge devices with just a few clicks.Say good bye to complex configurations and coding – with SenseCraft AI, you can efftortlessly unlock the power of AI on your devices. SenseCraft AI also allows you to upload and share your own trained AI models with the community. By publishing your models, you contribute to a growing library of shared knowledge, fostering collaboration and innovation among AI enthusiasts.Now we will quickly get started the modules with SenseCraft AI, and this will only require the module only.

Step 1. Connect the Grove Vision AI V2 to the SenseCraft AI Model Assistant​

First, we need to open the main SenseCraft AI Model Assistant page.

Go to SenseCraft AI

Create an account and login

Please use a Type-C type cable to connect Grove Vision AI V2 to your computer.

Here we are using a public model for testing the Grove Vision V2.

we selected the "Gesture Detection" model to deploy.

Click on "Deploy Model"

Then click on "connect"

Click on "Confirm" and select the connected serial port

Now the model will begin to get uploaded to the Grove vision V2

Now you can see that we have successfully uploaded the model.Now we can test it by showing different gestures

we can see how good the new Grove vision V2 is when compared to other MCUs and the previous version, we really got a massive upgrade in every terms, Really Loved it.

We can see that in the Preview Settings on the right hand side, there are two setting options that can be changed to optimise the recognition accuracy of the model.

Confidence: Confidence refers to the level of certainty or probability assigned by a model to its predictions.

• Confidence: Confidence refers to the level of certainty or probability assigned by a model to its predictions.

IoU: IoU is used to assess the accuracy of predicted bounding boxes compared to truth bounding boxes.

• IoU: IoU is used to assess the accuracy of predicted bounding boxes compared to truth bounding boxes.

Arduino Environment Preparation

1. Visit the official Arduinowebsite: https://www.arduino.cc/en/software

2. Click on the "Windows" or "Mac"buttonbased on your operatingsystem.

3. Download the ArduinoIDE1.8.19installer.

4. Once the downloadis complete, runtheinstaller.

5. Follow the installation wizard, acceptingthe license agreement and choosing the installation directory.

6. If prompted, allow the installer to install device drivers.

7. Once the installationis finished, click"Close" to exit the installer.

8. Open the Arduino IDE fromthedesktopshortcut or the start menu. 9. You're now ready tostart usingArduinoIDE 1.8.19!

Downloading the necessary libraries

1. Open your web browser and navigate to the GitHub repository:

https://github.com/Seeed-Studio/Seeed_Arduino_SSCMA

2. Click on the green "Code" button and select "Download ZIP" to download the library as a ZIP file.

3. Save the ZIP file to a location on your computer where you can easily find it.

4. Open the Arduino IDE.

5. Go to Sketch > Include Library >Add.ZIPLibrary.

6. In the file browser window that appears, navigate to the location where you saved the downloaded ZIP file.

7. Select the ZIP file and click "Open" to add the library to your Arduino IDE.

8. The Seeed_Arduino_SSCMAlibrary should now be installed and ready to use.

9. To verify the installation, go to Sketch>Include Library and check if "Seeed_Arduino_SSCMA" appears in the list of installed libraries.

You also need to downloadone more library

Go to the Sketch menu, then select Include Library>Manage Libraries.... This will open the Library Manager.In the search bar at the top of the Library Manager, type in ArduinoJSON. The search results will list the ArduinoJSON library. There will be an Install button next to the library. Click the Install button. The ArduinoIDE will automatically download and install the library into your Arduino development environment.

Installing the board to Arduino IDE

1. Open theArduinoIDE.

2. Go to File>Preferences.

3. In the "Additional BoardsManager URLs" field, enter the following URL:

https://raw.githubusercontent.com/espressif/arduinoesp32/gh-pages/package_esp32_index.json

https://raw.githubusercontent.com/espressif/arduinoesp32/gh-pages/package_esp32_index.json

4.Click "OK" to close the Preferences window.

5. Navigate to Tools >Board>Boards Manager.

6. In the Boards Manager window, search for "ESP32".

7. Locate the "ESP32 by Espressif Systems" entry and click on it.

8. Select the latest version from the drop down menu and click "Install".

9. Wait for the installation process to complete. This may take a few minutes.

10. Once the installation is finished, close the Boards Manager window

🧠 Central Controller: ESP32-C6-DevKitC-1

At the heart of our smart signage system is the ESP32-C6-DevKitC-1, a powerful and flexible development board from Espressif, designed for modern IoT applications. This board is responsible for receiving elephant detection alerts from EleTect nodes, interpreting camera-based AI inferences from the Grove Vision AI module, and triggering appropriate responses—like visual signage alerts or honeybee deterrent playback.

We chose this board for its cutting-edge wireless connectivity, generous memory, and support for RISC-V-based on-device processing.

🔧 Key Specifications

More details: ESP32-C6-DevKitC-1 on DigiKey

🧩 How It Works in the EleTect Signage System

1. Mounted Inside the Smart Signage Unit
   The ESP32-C6 board is installed inside our custom enclosure along with the  display, and power circuitry. It acts as the main controller and communication bridge.
2. Grove Vision AI Integration
   The Grove Vision AI V2 module is connected via UART to the ESP32-C6. The Grove module runs its own on-device model to detect vehicles waiting near signage. It sends inference results (e.g. “vehicle detected”) to the C6 board via serial messages.
3. Data Fusion & Decision Logic
   The ESP32-C6 receives elephant presence alerts from EleTect edge nodes via LoRa, and vehicle presence inferences from the camera. Based on these inputs, it decides whether to:
   • Send alert to node to play the honeybee deterrent sound
   • Trigger LED display of smart signage
   • Log or escalate to forest officials (optional future SIM module)
4. LoRa Communication
   An external LoRa module connects via SPI/UART. The C6 board listens for LoRa packets from the field-deployed acoustic EleTect nodes. When an elephant alert is received, it stores the event and coordinates camera-based checks before responding.
5. Signage & Deterrent Control
   • The ESP32-C6 controls a DFPlayer Mini  speaker to play honeybee buzz sounds.
   • It drives an RED LED Panel  for visual alerts to oncoming drivers using MOSFET Drive.
   • GPIOs control any future add-ons (like floodlights ).

6. Power & Deployment
   The board runs on 5V via USB-C or DC input and is designed for outdoor enclosure integration. It’s lightweight, low-power, and ideal for long-term signage deployment.

   

7. 

Custom model using google collab and Roboflow

In this part, we'll kick off by labeling our dataset with the intuitive tools provided by Roboflow. From there, we'll advance to training our model within Google Colab's collaborative environment. Next up, we'll explore deploying our trained model using the SenseCraft Model Assistant, a process designed to smoothly bridge the gap between training and real-world applications. By the conclusion of this part, you'll have your very own custom model ready to detect vehicles, operational on Grove Vision AI V2.

From dataset to model deployment, our journey consists of the following key stages:

1. Dataset Labeling — This section details the process of acquiring datasets suitable for training models. There are two primary methods: utilizing labeled datasets from the Roboflow community or curating your own dataset with scenario-specific images, necessitating manual labeling.

2. Model Training with Google Colab — Here, we focus on training a model capable of deployment on Grove Vision AI V2, leveraging the dataset obtained in the previous step via the Google Colab platform.

3. Model Upload via SenseCraft Model Assistant — This segment explains how to employ the exported model file to upload our elephant detection model to Grove Vision AI V2 using the SenseCraft Model Assistant.

Step 1.Create a free Roboflow account

Roboflow provides everything you need to label, train, and deploy computer vision solutions. To get started, create a free Roboflow account.

Step 2. Creating a New Project and Uploading images

Once you've logged into Roboflow, Click on Create Project.\

Name your project ("EleTect 1.5"). Define your project as t as Object Detection. Set the Output Labels as Categorical

Now it's time to upload vehicle images.

Collect images of elephants. Ensure you have a variety of backgrounds and lighting conditions. On your project page, click "Add Images".

You can drag and drop your images or select them from your computer. Upload at least 100 images for a robust dataset.

click on Save and Continue

Step 3: Annotating Images

After uploading, you'll need to annotate the images by labeling vehicle.

Roboflow offers three different ways of labelling images: Auto Label, Roboflow Labeling and Manual Labeling.

• Auto Label: Use a large generalized model to automatically label images.
• Roboflow Labeling: Work with a professional team of human labelers. No minimum volumes. No upfront commitments. Bounding Box annotations start at $0.04 and Polygon annotations start at $0.08.
• Manual Labeling: You and your team label your own images.

The following describes the most commonly used method of manual labelling.

Click on "Manual Labeling" button. Roboflow will load the annotation interface.

Select the "Start Annotating" button. Draw bounding boxes around the vehicle in each image.

Label each bounding box as vehicle.

Use the ">" button to move through your dataset, repeating the annotation process for each image.

Step 4: Review and Edit Annotations

It's essential to ensure annotations are accurate.

Review each image to make sure the bounding boxes are correctly drawn and labeled. If you find any mistakes, select the annotation to adjust the bounding box or change the label.

Step 5: Generating and Exporting the Dataset

Once all images are annotated. In Annotate click the Add x images to Dataset button in the top right corner.

Then click the Add Images button at the bottom of the new pop-up window.

Click Generate in the left toolbar and click Continue in the third Preprocessing step.

In the Augmentation in step 4, select Mosaic, which increases generalisation.

In the final Create step, please calculate the number of images reasonably according to Roboflow's boost; in general, the more images you have, the longer it takes to train the model. However, the more pictures you have will not necessarily make the model more accurate, it mainly depends on whether the dataset is good enough or not.

Click on Create to create a version of your dataset. Roboflow will process the images and annotations, creating a versioned dataset. After the dataset is generated, click Export Dataset. Choose the COCO format that matches the requirements of the model you'll be training.

Click on Continue and you'll then get the Raw URL for this model. Keep it, we'll use the link in the model training step a bit later.

Congratulations! You have successfully used Roboflow to upload, annotate, and export a dataset for elephant detection model. With your dataset ready, you can proceed to train a machine learning model using platforms like Google Colab.

Training Dataset Exported Model ​

Step 1. Access the Colab Notebook​

You can find different kinds of model Google Colab code files on the SenseCraft Model Assistant's Wiki. If you don't know which code you should choose, you can choose any one of them, depending on the class of your model (object detection or image classification).

If you are not already signed into your Google account, please sign in to access the full functionalities of Google Colab.

Click on "Connect" to allocate resources for your Colab session.

select the panel showing RAM and Disk

select "Change runtime type"

Select "T4 GPU"

Now run the "Setup SSCMA"

you will get a warning like this click on "Run anyways"

Wait untill the repositary is fully clonedand installed all the dependencies.

now its finished

Now run the "download the pretrain model weights file

Step 2. Add your Roboflow Dataset​

Before officially running the code block step-by-step, we need to modify the code's content so that the code can use the dataset we prepared. We have to provide a URL to download the dataset directly into the Colab filesystem.

To customize this code for your own model link from Roboflow:

1)Replace Gesture_Detection_Swift-YOLO_192 with the desired directory name where you want to store your dataset.

2)Replace the Roboflow dataset URL (https://universe.roboflow.com/ds/xaMM3ZTeWy?key=5bznPZyI0t)

with the link to your exported dataset (It's the Raw URL we got in the last step in Labelled Datasets). Make sure to include the key parameter if required for access.

3)Adjust the output filename in the wget command if necessary

(-O your_directory/your_filename.zip).4)Make sure the output directory in the unzip command matches the directory you created and the filename matches the one you set in the wget command.

Step 3. Adjustment of model parameters​

The next step is to adjust the input parameters of the model. Please jump to the Train a model with SSCMA section and you will see the following code snippet.

This command is used to start the training process of a machine learning model, specifically a YOLO (You Only Look Once) model, using the SSCMA (Seeed Studio SenseCraft Model Assistant) framework.

To customize this command for your own training, you would:

1)Replace configs/swift_yolo/swift_yolo_tiny_1xb16_300e_coco.py with the path to your own configuration file if you have a custom one.

2)Change work_dir to the directory where you want your training outputs to be saved.

3)Update num_classes to match the number of classes in your own dataset. It depends on the number of tags you have, for example rock, paper, scissors should be three tags.

4)Adjust epochs to the desired number of training epochs for your model. Recommended values are between 50 and 100.

5)Set height and width to match the dimensions of the input images for your model.

6)Change data_root to point to the root directory of your dataset.

7)If you have a different pre-trained model file, update the load_from path accordingly.

Step 5. Exportthe model​

After training, you can export the model to the format for deployment. SSCMA supports exporting to ONNX, and TensorFlow Lite at present

Step 6. Evaluate the model​

When you get to the Evaluate the model section, you have the option of executing the Evaluate the TFLite INT8 model code block.

Step 6. Download the exported model file​

After the Export the model section, you will get the model files in various formats, which will be stored in the Model Assistant folder by default. Our stored directory is EleTect 1.5.

select "ModelAssistatnt"

In the directory above, the .tflite model files are available for XIAO ESP32S3 and Grove Vision AI V2. For Grove Vision AI V2, we prefer to use the vela.tflite files, which are accelerated and have better operator support. And due to the limitation of the device memory size, we recommend you to choose INT8 model.

After locating the model files, it's essential to promptly download them to your local computer. Google Colab might clear your storage directory if there's prolonged inactivity. With these steps completed, we now have exported model files compatible with Grove Vision AI V2. Next, let's proceed to deploy the model onto the device.

Upload models to Grove Vision V2 via SenseCraft Model Assistant

Please connect the device after selecting Grove Vision AI V2 and then select Upload Custom AI Model at the bottom of the page.

You will then need to prepare the name of the model, the model file, and the labels. I want to highlight here how this element of the label ID is determined.

If you are using a custom dataset, then you can view the different categories and its order on the Health Check page. Just install the order entered here.

Then click Send Model in the bottom right corner. This may take about 3 to 5 minutes or so. If all goes well, then you can see the results of your model in the Model Name and Preview windows above.

Click on deploy and connect your grove vision V2.

Press Confirm and you are good to go.

📦 Camera Enclosure Design and Fabrication

To enable reliable visual monitoring in forest-edge and roadside environments, we designed a custom enclosure for the Grove Vision AI V2 Module using Autodesk Fusion 360. This case houses the camera securely and is optimized for outdoor use, with a snug lens window, mounting slots, and environmental protection. The enclosure was 3D printed using PLA filament and tested for hardware alignment and field durability.

The camera system is mounted on top of the smart signage unit, giving it an elevated, unobstructed view of the road ahead. Its primary role is to detect the presence of vehicles near the signage location, enabling dynamic decision-making. If an elephant is detected  and remains in the elephant corridor for a prolonged time—potentially blocking the road—the system uses camera input to verify the presence of halted vehicles. In such cases, it automatically triggers the honeybee deterrent and visual warning mechanisms, encouraging the elephant to move away and clear the path safely.

For field reliability and modular maintenance, the camera module connects to the signage base using aviation-grade connectors, ensuring secure power and signal transmission in harsh outdoor conditions.
 

Where to place the camera

Now that we have done training the vision based model, now we can connect it to EleTect node

🧠 Step 4: Connecting the Signboard to EleTect Node

Now that we have our physical enclosure and the custom LED warning panel ready, it's time to connect the system to the EleTect detection node using LoRa communication.

📡 Communication Architecture:

1.EleTect Node (Forest-side)

Detects elephant presence using:

• Grove Vision AI V2 → vision-based elephant detection.
• XIAO ESP32S3 Sense → sound-based detection.
• On detection → Sends ELEPHANT_DETECTED message via LoRa to the Signboard Node.
• If VEHICLE_PRESENT is received back → waits 10 minutes → activates bee sound deterrent via DFPlayer Mini + Speaker.
• Sends ELEPHANT_LEFT when elephants leave → resets the system.

2.Signboard Node (Roadside)

• Listens for elephant alerts from EleTect Node.
• On detection → flashes warning LED (with elephant symbol) continuously until elephant leaves.
• Uses Grove Vision AI V2 running a TinyML vehicle detection model to constantly check for vehicles.
• If vehicles are detected while elephants are present → sends VEHICLE_PRESENT message to EleTect Node.

Outcome

• 🚦 Elephant but no vehicles → Only flashing signboard (no sound, less disturbance).
• 🚦 Elephant + vehicles present → Signboard flashes + EleTect triggers bee sound after 10 minutes.
• ✅ Once elephant leaves → Signboard turns off, deterrent stops, system resets.

🧰 What You’ll Need:

• XIAO ESP32S3 – For LoRa and LED control
• LoRa-E5 Grove Module – For receiving data from EleTect node3S3P Li-ion Pack – Custom power solution for high LED current drawMOSFET (e.g., IRF540N or similar) – To drive the LED panel
• 220Ω Resistor – Gate resistor for the MOSFET
• Jumper Wires

🔌 Firmware for the Signboard XIAO ESP32S3:

Here's a basic sketch to control the LED flashing when elephant presence data is received from the EleTect node.

🧾 Code for the Signboard Node (Receiver):

/*
  Signage node for XIAO ESP32S3
  - Listens for "elephant" messages from EleTect node over LoRa
  - When elephant reported: blink a red signage LED (MOSFET-driven) for 40s after last report
  - Uses Grove Vision AI V2 to detect "vehicle" on road and reports vehicle events to EleTect node
    via LoRa  ]
  Pin & behavior configuration near top.
*/


#include <Arduino.h>
#include <Seeed_Arduino_SSCMA.h> // Grove Vision AI V2

// ----------------- CONFIGURATION -----------------
// Grove LoRa-E5 UART (connected to the Grove UART port)
const int LORA_RX_PIN = 16; // XIAO RX (connect to LoRaE5 TX)
const int LORA_TX_PIN = 17; // XIAO TX (connect to LoRaE5 RX)
const unsigned long LORA_BAUD = 9600UL; // typical default for LoRa-E5 AT firmware - change if your module uses different baud

// Grove Vision AI V2 UART - use a second serial port
#ifdef ESP32
  #include <HardwareSerial.h>
  HardwareSerial atSerial(0); // Grove Vision AI UART (example)
#else
  #define atSerial Serial1
#endif

Seeed_Arduino_SSCMA AI; // Grove Vision AI object

// LED signage output (MOSFET gate)
const int SIGN_LED_PIN = 25; // change to the MOSFET gate pin you connected

// Blink pattern configuration
const unsigned long SIGNAGE_TIMEOUT_MS = 40UL * 1000UL; // 40 seconds after last elephant message
const unsigned long BLINK_ON_MS = 300;   // LED on duration in blink cycle
const unsigned long BLINK_OFF_MS = 300;  // LED off duration in blink cycle

// Vision detection threshold and interval
const int VISION_SCORE_THRESHOLD = 80; // Grove Vision AI score threshold (0..100)
const unsigned long VISION_POLL_MS = 800; // how often to invoke vision model

// Vehicle reporting cooldown so we don't spam the network
const unsigned long VEHICLE_SEND_COOLDOWN_MS = 10000UL; // 10s between vehicle reports

// -------------------------------------------------

// State variables for signage
volatile unsigned long lastElephantMs = 0; // last time an elephant message was received
bool signageActive = false;

// Blink state machine
bool blinkStateOn = false;
unsigned long blinkStateChangeAt = 0;

// Vision timing
unsigned long lastVisionPollAt = 0;
unsigned long lastVehicleSentAt = 0;

// Serial buffer for incoming LoRa lines
String incomingLine = "";

// ---------- LoRa helper functions ----------

// Send a payload string via LoRa-E5 using AT command.
// NOTE: depending on your LoRa-E5 firmware you may need to change the exact AT command (AT+SEND, AT+MSG, etc.)
void sendLoRaPayload(const String &payload) {
  // A common AT-style uplink command may be: AT+SEND="payload"
  // Some firmwares accept AT+MSG or AT+SENDB (hex). Check your LoRa-E5 AT spec if this fails.
  String cmd = String("AT+SEND=\"") + payload + String("\"\r\n");
  Serial.print(">>> LoRa AT TX: ");
  Serial.print(cmd);
  Serial2.print(cmd);

  // Wait (non-blocking style: you can read responses in pollLoRaSerial())
}

// Parse incoming serial line(s) from Serial2 for elephant messages or LoRa AT responses
void processLoRaIncomingLine(const String &line) {
  String lower = line;
  lower.toLowerCase();

  // Debug print the raw line
  Serial.print("LoRa RX: ");
  Serial.println(line);

  // Many LoRa-E5 AT firmwares report downlink like:
  // +MSG: LEN:4, RSSI:-49, SNR:12
  // +MSG: RX "54455854"
  // or +RECV: PORT:8; RX:"payload"
  // So extract the quoted payload if present, otherwise inspect the whole line as text.
  String payload = "";

  // find patterns like RX "payload" or RX:"payload" or +RECV: ... "payload"
  int firstQuote = line.indexOf('"');
  int lastQuote = line.lastIndexOf('"');
  if (firstQuote >= 0 && lastQuote > firstQuote) {
    payload = line.substring(firstQuote + 1, lastQuote);
  } else {
    // no quotes -> maybe the firmware prints payload directly, so fallback to the whole line
    payload = line;
  }

  payload.trim();
  String payloadLower = payload;
  payloadLower.toLowerCase();

  // If payload contains the word "elephant", trigger signage
  if (payloadLower.indexOf("elephant") >= 0) {
    lastElephantMs = millis();
    signageActive = true;
    // Reset blink state so LED turns on immediately
    blinkStateOn = true;
    blinkStateChangeAt = millis();
    digitalWrite(SIGN_LED_PIN, HIGH);
    Serial.println("LoRa downlink contained 'elephant' -> signage activated (40s timeout).");
  } else {
    // Not an elephant message: print for debugging
    Serial.print("LoRa payload (ignored): ");
    Serial.println(payload);
  }
}

// Read any available bytes from Serial2 (LoRa-E5 UART) and accumulate lines
void pollLoRaSerial() {
  while (Serial2.available() > 0) {
    char c = (char)Serial2.read();
    if (c == '\r') continue;
    if (c == '\n') {
      String line = incomingLine;
      line.trim();
      incomingLine = "";
      if (line.length() > 0) {
        processLoRaIncomingLine(line);
      }
    } else {
      incomingLine += c;
      // Keep buffer bounded
      if (incomingLine.length() > 1024) {
        incomingLine = incomingLine.substring(incomingLine.length() - 512);
      }
    }
  }
}

// Non-blocking blink update; keep LED toggling while signageActive
void updateBlinkState() {
  if (!signageActive) {
    // ensure LED off
    if (blinkStateOn) {
      blinkStateOn = false;
      digitalWrite(SIGN_LED_PIN, LOW);
    }
    return;
  }

  unsigned long now = millis();
  if (blinkStateOn) {
    if (now - blinkStateChangeAt >= BLINK_ON_MS) {
      blinkStateOn = false;
      blinkStateChangeAt = now;
      digitalWrite(SIGN_LED_PIN, LOW);
    }
  } else {
    if (now - blinkStateChangeAt >= BLINK_OFF_MS) {
      blinkStateOn = true;
      blinkStateChangeAt = now;
      digitalWrite(SIGN_LED_PIN, HIGH);
    }
  }

  // Deactivate signage if timeout elapsed since last elephant message
  if (now - lastElephantMs >= SIGNAGE_TIMEOUT_MS) {
    signageActive = false;
    blinkStateOn = false;
    digitalWrite(SIGN_LED_PIN, LOW);
    Serial.println("Signage timeout expired -> signage deactivated.");
  }
}

// Vision: poll Grove Vision AI V2 and send vehicle messages via LoRa if vehicles found
void pollVisionAndReport() {
  if (!AI.invoke(1, false, false)) { // single invoke, no filter, no image
    for (int i = 0; i < AI.boxes().size(); i++) {
      int score = AI.boxes()[i].score;
      if (score > VISION_SCORE_THRESHOLD) {
        String label = AI.boxes()[i].label;
        String lower = label;
        lower.toLowerCase();
        if (lower.indexOf("vehicle") >= 0 || lower.indexOf("car") >= 0 || lower.indexOf("truck") >= 0 || lower.indexOf("bus") >= 0) {
          unsigned long now = millis();
          if (now - lastVehicleSentAt >= VEHICLE_SEND_COOLDOWN_MS) {
            lastVehicleSentAt = now;
            // Create a compact JSON payload; adjust fields as your backend expects
            String payload = String("{\"event\":\"vehicle\",\"score\":") + String(score) + String(",\"t\":") + String(now) + String("}");
            sendLoRaPayload(payload);
            Serial.printf("Vehicle detected (score %d) -> sent LoRa uplink\n", score);
          } else {
            Serial.println("Vehicle detected but on cooldown (skip sending).");
          }
        }
      }
    }
  } else {
    // AI.invoke returned non-zero according to earlier API — nothing or error
    // Serial.println("Vision: no boxes or invoke returned non-zero");
  }
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  Serial.println();
  Serial.println("Signage node (LoRa-E5) booting...");

  // LED pin
  pinMode(SIGN_LED_PIN, OUTPUT);
  digitalWrite(SIGN_LED_PIN, LOW);

  // init LoRa-E5 serial on Serial2 (hardware serial) with provided pins
  // Use Serial2 for XIAO ESP32S3 (change pins if you wired differently)
  Serial2.begin(LORA_BAUD, SERIAL_8N1, LORA_RX_PIN, LORA_TX_PIN);
  delay(50);
  Serial.println("LoRa-E5 UART (Serial2) initialized.");

  // Give LoRa module a moment and query AT to see if it responds
  delay(200);
  Serial2.print("AT\r\n"); // send AT test
  Serial.println("Sent 'AT' test to LoRa module - check Serial Monitor for response.");

  // init vision ai - wire to hardware serial or the same Serial? Use atSerial (HardwareSerial(0)) as in examples
  #ifdef ESP32
    atSerial.begin(115200);
    AI.begin(&atSerial); // Grove Vision AI using hardware serial 0
  #else
    atSerial.begin(115200);
    AI.begin(&atSerial);
  #endif
  Serial.println("Grove Vision AI v2 UART initialized.");

  lastElephantMs = 0;
  signageActive = false;
  blinkStateOn = false;
  blinkStateChangeAt = millis();

  lastVisionPollAt = 0;
  lastVehicleSentAt = 0;

  Serial.println("Setup complete.");
}

// Main loop: poll LoRa input, update blink state, and periodically poll vision
void loop() {
  // 1) Handle incoming LoRa messages from other nodes (downlinks or P2P test responses)
  pollLoRaSerial();

  // 2) Update blink state machine (non-blocking)
  updateBlinkState();

  // 3) Poll vision at intervals and optionally report vehicles
  if (millis() - lastVisionPollAt >= VISION_POLL_MS) {
    lastVisionPollAt = millis();
    pollVisionAndReport();
  }

  // small yield
  delay(10);
}

🔋 Powering the System:

The entire signboard is powered by a custom 3S3P battery pack made using Li-ion cells (11.1V ~ 12.6V).And downed using a buck converter to 5V.

The MOSFET allows the microcontroller to switch the high current LED panel without overloading the XIAO.

🧩 Step 5: 3D Printing and Mounting the LED Panel to a Custom Stand

Stand Construction from Scrap Metal

To reduce costs and promote sustainability, the stand for the EleTect warning signage and solar panel was made entirely from scrap metal. Despite being built from repurposed material, it is sturdy, weather-resistant, and highly visible.

Materials Used

• 1-inch square metal pipe (scrap, reused)
• Welding machine (for joints)
• Cutting tool (angle grinder)
• Anti-rust paint (to protect against corrosion in forest conditions)
• Mounting bolts & brackets (for signage + solar panel)

Dimensions & Assembly

• Height: ~8 feet (tall enough for clear visibility to drivers).
• Pole: Single vertical square pipe serves as the main post.
• Base: Welded flat support with angled bracing, bolted into the ground for stability.

Top Section:

• Solar panel mounted with a small angled bracket for optimal sunlight.
• Warning signage (“Elephants Ahead”) firmly attached just below the panel.

Construction Steps

• Cutting the Scrap Pipe: The scrap pipe was cut into one 8 ft piece (main vertical) and smaller pieces for the base support.
• Building the Base: A flat base with short stabilizers was welded to the bottom so it could be anchored securely into the ground with bolts.

Mounting the Sign & Solar Panel:

• A horizontal bracket at the top holds the solar panel at an angle.
• The triangular signage board is bolted slightly below the solar panel.

Painting & Finishing: The entire stand was coated with anti-rust paint, ensuring long durability outdoors.

Benefits

Ultra Low Cost: Made from waste scrap material.

Eco-Friendly: Reuses metal that would otherwise be discarded.

Durable: Strong enough to withstand wind, rain, and wildlife contact.

Scalable: Simple design can be replicated in bulk for multiple forest corridors.

Designing the Mount

To ensure stability and long-term deployment in outdoor environments, we designed a custom 3D printed mount that securely holds the LED signboard and aligns it on the custom metal pipe-based stand.

🛠️ Materials Used:

• PLA filament (Black)
• 3D printerM4 bolts and nutsScrews (for enclosure-mounting)steel pipe (for pole mounting)

🎯 Design Process:

CAD Modeling:

Using Fusion 360 design a mounting bracket that matches the dimensions of the acrylic signboard enclosure

Printing:

Assembly:

Once printed, the enclosure was carefully slotted into the mount

Secure with M4 bolts on either side to lock it in place.The mount was then clamped or screwed onto a metal/PVC pole, completing the physical installation.

🌍 Sustainability and Edge Deployment

• No internet required: Uses LoRa for remote communication
• Fully solar-powered, ideal for deployment in forest areas
• Deterrent only activates when necessary, conserving energy and minimizing disturbance to wildlife

📽️ Video Demonstration

Website Structure

The Eletect website serves as a pivotal platform connecting advanced hardware deployed in forests and agricultural areas with users, including community members and forest officers. It provides real-time monitoring and alerts, enabling timely detection of elephants, wild boars, and illegal activities. This immediate access allows users to take swift preventive measures, ensuring human-wildlife conflict mitigation and forest protection.

Through hardware-software integration, the website consolidates data from AI-enabled devices such as Grove Vision AI modules, XIAO ESP32S3 sensors, and LoRa/LoRaWAN communication nodes. This integration ensures that information from multiple detection points is centrally accessible, visualized on maps, and displayed in interactive tables and image galleries. The platform allows users to track wildlife locations, upload and review images, and monitor detection logs in a clear and intuitive manner.

The website also provides role-based access, allowing community users to monitor wildlife and receive alerts, while forest officers gain access to advanced functionalities like illegal activity detection, anti-poaching monitoring, and deforestation tracking. This ensures that both the public and authorities can respond effectively and collaboratively.

Moreover, this maintains a historical record of detections, storing timestamps, locations, and images. This data supports research, trend analysis, and strategic planning for conservation efforts. Its scalable design allows for future enhancements, such as adding more detection nodes, expanding species monitoring, or integrating mobile notifications, all through the same user-friendly interface.

In summary, the Eletect website transforms raw hardware data into actionable intelligence, offering a centralized, real-time, and scalable solution for wildlife conservation, community safety, and forest management. By bridging the gap between field-deployed devices and end-users, it ensures efficient monitoring, informed decision-making, and proactive protection of both humans and wildlife.

Home Page

• Hero section highlighting the      system’s purpose.
• Key features displayed as      cards: Elephant Detection, Wild Boar Protection, Illegal Activity      Detection.
• Login prompt for Community      Users and Forest Officers. 📷

Login Page

• Role-based login form for      Community and Officer accounts.
• Credentials validation to      provide access to dashboards.

Dashboard

• Accessible after login.
• Role-specific features      displayed as interactive cards.
• Community Users: Elephant,      Boar, Bird monitoring.
• Officers: Illegal Activity,      Deforestation, Anti-Poaching.

Feature Page

• Shows feature-specific      information, detection logs, uploaded images, and live monitoring.
• For Elephant detection: Map      showing detected locations (Kothamangalam, Kottapady), sample images, and      hardware integration details.

• AI-powered detection using      hardware nodes deployed in forests.
• Key locations: Kothamangalam      (detected on 30/06/2025), Kottapady (detected on 20/12/2024).
• Features:
• Detection log with timestamp,       location, confidence, size, and alert status.
• Live monitoring with       real-time alerts.
• Image gallery for uploaded       elephant images and sample images.
• Map integration using Google       Maps or Leaflet to visualize detected locations.

· Backend Framework: Using Python with FastAPI to handle API requests, user authentication, and real-time data processing.

· Database: PostgreSQL for storing user accounts, detection logs, uploaded images, and hardware sensor data.

· Data Structure: Each detection entry includes location, GPS coordinates, detection confidence, size, timestamp, and alert status.

· Hardware Integration: Field nodes with cameras and sensors send data via REST APIs  to the backend.

· Real-Time Updates: Backend can push instant updates to the frontend using WebSockets, ensuring immediate alerts and monitoring.

· Scalability & Security: PostgreSQL ensures reliable persistence, and the backend architecture allows scaling for more users, devices, and features.

🔄 Updated Version (V2) — Fully 3D-Printed Body + Custom 12V LED Strip Panel

After completing the first version of the EleTect Signage node, we designed and built a second, improved version with several major upgrades focused on durability, manufacturability, and better nighttime visibility.

✅ 1. Fully 3D-Printed Enclosure
🔄 Updated Version (V2) — Fully 3D-Printed Body + Custom 12V LED Strip Panel

After completing the first version of the EleTect Signage node, we designed and built a second, improved version with several major upgrades focused on durability, manufacturability, and better nighttime visibility.

✅ 1. Fully 3D-Printed Enclosure

printing video

The entire signage housing was redesigned in Fusion 360 and is now 100% 3D-printed, making it:

• More rugged and weather-resistant
• Easier to assemble and service
• Customizable for different mounting setups
• More suitable for outdoor deployments in forest-side roads

The new enclosure includes proper mounting slots, structured ribs for reinforcement, and a dedicated sealed chamber for the electronics.

✅ 2. Upgraded LED Panel → Custom 12V LED Strip Module

Initial test video
 

Instead of the earlier panel, the V2 design uses a custom 12V high-brightness LED strip module, which:

• Provides significantly higher visibility in fog, rain, and nighttime
• Works directly with the MOSFET driver stage
• Is easier to replace or extend based on signage size
• Offers a more even and uniform glow across the panel

This makes the alert signal much more noticeable for drivers when an elephant alert is triggered.

🔧 3. Improved Cable Routing & Connector System

The updated version incorporates:

• Proper cable ducts within the enclosure
• Aviation-grade connectors for camera + power + signal lines
• Better strain relief for long-term outdoor use

📌 Summary

The second version of the EleTect Signage node is:

• More durable
• Brighter and safer for roadside awareness
• Fully modular
• Ready for scalable deployment

This improved version is now the recommended design for future field installations.

The entire signage housing was redesigned in Fusion 360 and is now 100% 3D-printed, making it:

• More rugged and weather-resistant
• Easier to assemble and service
• Customizable for different mounting setups
• More suitable for outdoor deployments in forest-side roads

The new enclosure includes proper mounting slots, structured ribs for reinforcement, and a dedicated sealed chamber for the electronics.

✅ 2. Upgraded LED Panel → Custom 12V LED Strip Module

Instead of the earlier panel, the V2 design uses a custom 12V high-brightness LED strip module, which:

• Provides significantly higher visibility in fog, rain, and nighttime
• Works directly with the MOSFET driver stage
• Is easier to replace or extend based on signage size
• Offers a more even and uniform glow across the panel

This makes the alert signal much more noticeable for drivers when an elephant alert is triggered.

🔧 3. Improved Cable Routing & Connector System

The updated version incorporates:

• Proper cable ducts within the enclosure
• Aviation-grade connectors for camera + power + signal lines
• Better strain relief for long-term outdoor use

📌 Summary

The second version of the EleTect Signage node is:

• More durable
• Brighter and safer for roadside awareness
• Fully modular
• Ready for scalable deployment

This improved version is now the recommended design for future field installations.

🌏 Exhibition at Maker Faire Shenzhen 2025

The EleTect Signage system was officially exhibited at Maker Faire Shenzhen 2025, one of Asia’s largest community-driven innovation events.
 

At the event, we showcased:

• The complete EleTect workflow — Detection Node → LoRa Communication → Signage Alert Node
• The new fully 3D-printed enclosure and hardware improvements
• The upgraded 12V LED strip–based signage panel
• The real-time demo of vehicle detection using Grove Vision AI V2

• Live explanation of the LoRa communication pipeline and how alerts propagate
   

The project received strong interest from makers, engineers, educators, and sustainability-oriented groups, especially due to its focus on wildlife protection, rural safety, and low-power distributed sensing.

Participating in Maker Faire Shenzhen 2025 helped validate the design, gather feedback from industry experts, and explore possibilities for scaling the EleTect system for real-world deployments.

🌍 Future Plans

One of the most impactful upgrades we are planning for EleTect is the integration of Google Maps into the system. Currently, EleTect is capable of detecting elephant movement and triggering local deterrents or alerts. However, by incorporating Google Maps, we aim to create a real-time, centralized monitoring system that will drastically improve response times and ensure safer coexistence between humans and elephants.

🔹 How It Will Work:

• Live Location Mapping – Each EleTect unit deployed in the field will send detection data (timestamp, location coordinates, and event details) to a central cloud server.
• Google Maps Visualization – The data will be displayed on Google Maps, showing the exact position of elephant sightings or conflicts in real-time.
• Risk Zone Alerts – Areas with frequent detections will be marked as “High Risk” zones, allowing authorities and locals to take precautionary measures.
• Community Access – Farmers, drivers, and forest officials will be able to access a live web/app dashboard powered by Google Maps, ensuring they are instantly informed of nearby elephant movement.  Historical Data & Prediction – By overlaying historical data on Google Maps, the system can predict elephant routes and hotspots, helping in long-term conflict mitigation planning.

🔹 Benefits:

• Prevent Road Accidents – Drivers will receive live alerts on elephant crossings ahead, reducing the risk of collisions (like the unfortunate German tourist incident).
• Safer Agriculture – Farmers can check real-time elephant movement before stepping into their fields at night.
• Better Resource Deployment – Forest officials can allocate patrols and deterrents more effectively.
• Community Awareness – Local communities gain accessible, visual information, fostering safer human-elephant coexistence.

While designed for mitigating human-elephant conflict, the system can also be adapted for other regions and animals, such as kangaroos, deer, or bison, with only minimal modifications required. The overall goal remains the same: to reduce accidents, save human lives, and protect wildlife.

This integration will make EleTect not just a detection and deterrent system, but a smart, location-aware safety network that can save countless lives – both human and elephant.

🌱 Let’s Save Lives — Humans and Elephants Alike

With EleTect 1.5, we bridge the communication gap between the wild and the road.
Our goal is simple yet powerful: make our forests safer — not by blocking wildlife, but by understanding and respecting their natural paths.

By combining AI, long-range communication, and intelligent alert systems, EleTect aims to reduce human–elephant conflict and create safer environments for both wildlife and people.

We are now looking forward to deploying this system in real-world locations, gathering field data, and continuously improving the platform.
Our hope is to make a genuine impact — protecting wildlife, preventing accidents, and ultimately making people’s lives better.