Getting Started with Grove Vision AI V2 and SenseCraft

Introduction

The field of image recognition applications is growing rapidly.From security systems to industrial automation, the potential use cases for this technology are virtually endless.However, achieving good results requires not only a quality camera but also sufficient processing power to run complex AI models effectively.

For simple or entry-level applications, the XIAO ESP32-S3 Sense board is a great choice. This small but powerful microcontroller is capable of running lightweight machine learning models thanks to its versatility and performance, making it an excellent platform for getting started with AI projects.

But what happens when you want to take things a step further and work with more demanding models? That’s where the Grove Vision AI V2 module from Seeed Studio comes in. This device can be used with higher-quality cameras, such as those compatible with the Raspberry Pi, and it includes a specialized image processing chip that delivers faster and more accurate results.

With its enhanced capabilities, the Grove Vision AI V2 is ideal for developers who want to move beyond basic applications and explore more complex machine vision projects.

In this article, we’ll explore everything the Grove Vision AI V2 has to offer. You’ll see how easily it integrates with the SenseCraft platform — a powerful tool designed to simplify the deployment and management of AI models — and how it can be used in real-world applications. If you're looking to take your AI projects to the next level, keep reading to learn how to make the most of this advanced module.

Grove Vision AI V2

The Grove Vision AI V2 module from Seeed Studio is specifically designed for image recognition applications. It features the Himax WiseEye2 HX6538 chip (also known as WE2), a high-performance, ultra-low-power microcontroller tailored for battery-powered edge AI solutions.

The WE2 is based on the ARM Cortex-M55 architecture and features an integrated Ethos-U55 Neural Processing Unit (NPU), optimized for efficiently running machine learning models locally, without the need for cloud connectivity. This enables tasks such as object detection, image classification, and other computer vision functions to be executed autonomously, quickly, and with low power consumption.

Features

• WiseEye2 HX6538 processor with ARM Cortex-M55 architecture and Ethos-U55 NPU
• Combines processing power with ultra-low energy consumption
• Can be used as an expansion module for other microcontrollers
• Directly compatible with the XIAO family of boards

The module does not include a camera — it must be connected externally:

• Compatible with Raspberry Pi cameras
• Features a CSI connector

In addition to these core features, the module also includes:

• Digital microphone using PDM (Pulse Density Modulation)
• microSD card slot
• Grove interface with I²C pins
• USB-C port for power and programming

Thanks to these features, the Grove Vision AI V2 is ideal for embedded AI projects that require local image processing, such as facial recognition, security monitoring, access control, and applications in smart homes or industrial environments.

Programming

The module offers several programming options that make application development easier, catering to both beginners and advanced users.

• Supports TensorFlow and PyTorch (popular ML frameworks)
• Arduino compatible
• Integrates with SenseCraft for model management
• Officially supported by Edge Impulse

Let’s take a closer look at some of these options, along with the libraries and tools available for developing AI applications.

Himax SDK

If you're looking to build a professional application and fully leverage the capabilities of the WE2 chip, you can use the Himax Software Development Kit (SDK). This environment allows you to program the WE2 directly, generate native code, and access its advanced features.

However, setup and configuration can be a bit complex. To simplify the process, it’s recommended to follow the installation guide available on the Seeed Studio Wiki.

SSCMA-Micro

SSCMA-Micro is a custom firmware developed by Seeed Studio that includes built-in features for digital image processing and neural network inference. It is compatible with a variety of microcontrollers, including the ESP32-S3, Grove Vision AI, SenseCAP Watcher, and reCamera.

This firmware comes pre-installed on the Grove Vision AI module and is automatically updated when used with the SenseCraft AI platform.

SSCMA-Micro is capable of running models locally, including FOMO, Swift YOLO, YOLOv8, YOLOv11, MobileNetV2/V4, and others. These models are optimized to work on resource-constrained devices, making it possible to take full advantage of the limited hardware of these microcontrollers without compromising performance in specific computer vision tasks.

By using AT commands, SSCMA-Micro enables integration with the SenseCraft platform for selecting, training, and deploying AI models.

In addition, SSCMA simplifies communication with other microcontrollers through interfaces such as I²C, UART, or SPI, allowing the Grove Vision AI to operate as a specialized vision module connected to a separate host microcontroller.

This offers great flexibility, as the Grove Vision AI can be used as a peripheral connected to any board that supports one of these interfaces.For example, you could connect it to a Raspberry Pi Pico W running MicroPython. This connection can be made using the onboard Grove connector included with the module.

In the case of XIAO boards, integration is even more seamless — they can be plugged directly into the socket built into the Grove Vision AI module for this purpose.

You can find the full list of AT commands in the official SSCMA-Micro GitHub repository.

As mentioned earlier, using these AT commands allows you to connect Grove Vision AI to any other board. However, writing the code to send commands, receive responses, and parse their content can be somewhat tedious. Fortunately, Seeed Studio has also developed an Arduino library that makes this much easier — no need to handle the low-level AT command details.

Seeed_Arduino_SSCMA Library

If you're using Grove Vision AI together with another board programmed in Arduino, Seeed Studio provides a library that simplifies communication.The Seeed_Arduino_SSCMA library includes all the necessary functions to interact with the Grove Vision module in a straightforward way — without the need to deal with AT commands.

This library includes the necessary commands to invoke the AI model and retrieve inference results, which can then be used to make decisions.

To give you a better idea of the workflow when developing an application using SenseCraft and this library, let’s walk through a practical example: detecting people in a residential setting.

Example: Person Detection

Detecting the presence of unauthorized individuals in a home can be approached in various ways — such as using sensors that detect the opening of doors or windows, or motion detection systems based on PIR or radar technology.

However, when it comes to open spaces, these options become more limited. And if the area includes elements that frequently move — like tree branches, shadows, or pets — traditional systems are more likely to trigger false alarms.

In this context, a computer vision–based solution becomes especially useful: a camera analyzes the scene and only triggers the alarm when it identifies a human figure, effectively avoiding unnecessary alerts.

In this example, I’ll show you how to build a security alarm system from scratch using the Grove Vision AI module, a XIAO ESP32-C3, and SenseCraft.This is a silent alarm: when the system detects an intruder, it sends a notification to your phone using the Pushbullet service.

Components Used

Here are the components we’ll use to build the alarm:

• Grove Vision AI V2 module with SSCMA-Micro firmware
• CSI camera (e.g., OV5647)
• XIAO ESP32-C3 board with Wi-Fi antenna

You’ll also need:

• A working Wi-Fi connection (to send notifications)
• A Pushbullet account and API Key

If you're not familiar with Pushbullet or how it works, I invite you to check out this other project that I’ve published earlier here on Hackster.

How It Works

• Model: A pre-trained person detection model is used, loaded onto the Grove Vision AI module via the SenseCraft platform.
• Person detection: The XIAO ESP32-C3, mounted on the Grove Vision module, reads the inference results from the model. When a person is detected with high confidence, the XIAO connects to the home’s Wi-Fi network and sends a notification.
• Notification: The XIAO performs an HTTP POST request to the Pushbullet server, which then delivers a notification to the homeowner’s phone.

The Model

For this project, there's no need to train a model from scratch. SenseCraft offers a collection of pre-trained models, including one specifically for person detection based on the Swift-YOLO algorithm, optimized to run on the Grove Vision AI module.All you need to do is select the model in the platform, connect the module, and deploy it with just a few clicks.

The person detection model used in this project is based on Swift-YOLO, an optimized version of the popular YOLO (You Only Look Once) algorithm, known for its ability to detect objects in real time.

Swift-YOLO has been specially adapted by Seeed Studio to run efficiently on the Grove Vision AI V2. Thanks to this optimization, the model can be executed directly on the device, without relying on the cloud — enabling fast, accurate, and local person detection.

The following video demonstrates how to prepare and upload the model using SenseCraft:

Programming

Once the model is deployed to the Grove Vision AI module, the XIAO ESP32-C3 microcontroller is responsible for starting the inference process and analyzing the results.To do this, we use the Seeed_Arduino_SSCMA library, which allows easy communication with the module — no need to send AT commands manually.

Below is a basic example showing how the XIAO C3 retrieves inference data from the model:

#include <Seeed_Arduino_SSCMA.h>  // Library to communicate with the Grove Vision AI module
SSCMA AI;  // Create an object to handle the model information

void setup() {
  // Initialize communication with the Grove Vision AI module via I2C
  AI.begin();
  // Initialize the serial monitor to display the results
  Serial.begin(9600);
  delay(1000); 
}

void loop() {
  // Run the object detection model loaded on the Grove Vision AI
  // Parameters:
  //   1 → single inference
  //   false → do not use filters
  //   false → do not include image
  if (!AI.invoke(1, false, false)) {
    Serial.println("Model executed successfully");
    // Iterate and print the detections made
    for (int i = 0; i < AI.boxes().size(); i++) {
      Serial.print("Box[");
      Serial.print(i);
      Serial.print("] Class=");
      Serial.print(AI.boxes()[i].target);  // Detected class ID
      Serial.print(" Confidence=");
      Serial.println(AI.boxes()[i].score); // Confidence level (0.0 to 1.0)
    }
  } else {
    // If an error occurs while running the model, print a message to the console
    Serial.println("Error executing the model");
  }
  delay(1000);  // Wait 1 second before making another inference
}

This code must be uploaded to the XIAO ESP32-C3.If you previously loaded the model onto the Grove Vision module, now it’s time to disconnect it and connect the C3 to the computer running the Arduino IDE in order to upload this example program — and the others we’ll see next.

Analyzing the code, we see that at the beginning the Seeed_Arduino_SSCMA.h library is included to communicate with the Grove Vision AI.

Then, the object AI of the SSCMA class is created, which will handle all interaction with the Grove Vision AI module.

Next, the setup function begins, which initializes the I2C port to communicate with the module and the UART port to send information to the serial monitor.

In the loop function, the first thing it does is call the invoke method, which sends a command to the Grove Vision AI module to capture an image, process the loaded model, and return the results. The parameters 1, false, false indicate that the model is run only once, without filters and without returning any image.

After that, all the objects detected by the model are iterated through, and their number, detected class, and detection confidence level (between 0 and 1) are displayed.

Finally, an error message is shown if the model could not be invoked, and a delay is introduced before starting again.

In our example, we want to trigger an alarm when a person is detected. So, we can simplify the code and add an alarm condition.

This condition is defined as the detection of an object with class ID 0 (person) and a confidence level above a certain threshold (e.g., 0.8, or 80%).

You can see this logic in the following example, which prints “ALARM!!!” when the condition is met:

#include <Seeed_Arduino_SSCMA.h>
SSCMA AI;

void setup() {
  AI.begin();              // I2C communication with Grove Vision AI
  Serial.begin(9600);      // Serial monitor
  delay(2000);
  Serial.println("System started");
}

void triggerAlarm(void) {
  Serial.println("ALARM!!!");
}

void loop() {
  if (!AI.invoke(1, false, false)) {
    Serial.println("Model executed successfully");
    // Iterate through detections
    for (int i = 0; i < AI.boxes().size(); i++) {
      int detectedClass = AI.boxes()[i].target;
      float confidence = AI.boxes()[i].score;
      // If the detected class is a person (class 0) and confidence is greater than 80%
      if (detectedClass == 0 && confidence > 0.8) {
        triggerAlarm();
      }
    }
  } else {
    Serial.println("Error executing the model");
  }
  delay(1000); // Wait 1 second before executing again
}

To complete our example, we now just need to add the notification system using Pushbullet. Let’s see how it works.

Sending Notifications with Pushbullet

Pushbullet is a service that allows you to send notifications to different platforms (such as phones and computers) from your board by making a request to its API.To use it, you’ll need to create an account and install the app. There's a free plan available that allows you to send up to 500 notifications per month.

To send a request to Pushbullet, you’ll need the following information:

URL: https://api.pushbullet.com/v2/pushes

Method: POST

Headers:

• Content-Type: application/json
• Access-Token: YourToken

Payload: A JSON file with the following structure:

{
"type" : "note", "title" : "Some text", "body" : "Another text"
}

YourToken is your access token, which works like a personal key to communicate with Pushbullet’s servers.You can obtain this token from the official website or the Pushbullet app for Windows by going to: Settings > Account

Here’s an example showing how to use Pushbullet to send notifications from the XIAO ESP32-C3:

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "yourSSID";
const char* password = "yourPassword";
const char* pushbulletToken = "yourToken";  

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to WiFi");
  sendPushbulletNotification();
}

void loop() {
  // Nothing in the loop
}

void sendPushbulletNotification() {
  HTTPClient http;
  http.begin("https://api.pushbullet.com/v2/pushes");
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Access-Token", pushbulletToken);
  String payload = "{\"type\":\"note\",\"title\":\"Test from XIAO C3\",\"body\":\"Hello world!\"}";
  int httpResponseCode = http.POST(payload);
  if (httpResponseCode > 0) {
    String response = http.getString();
    Serial.println("Server response:");
    Serial.println(response);
  } else {
    Serial.print("Request error: ");
    Serial.println(httpResponseCode);
  }
  http.end();
}

This example connects to Wi-Fi in the setup (remember to replace "yourSSID" and "yourPassword" with your network credentials) and then calls the sendPushbulletNotification function, which sends a notification with the title “Test from XIAO C3” and “Hello world!” as the message content (replace “yourToken” with the value provided by Pushbullet in your account).

Final program

Now that we've seen how to invoke the model and get inference results, and how to send notifications using Pushbullet, all that's left is to combine everything into a single program, like the one below:

#include <WiFi.h>
#include <HTTPClient.h>
#include <Seeed_Arduino_SSCMA.h>

SSCMA AI;

const char* ssid = "yourSSID";
const char* password = "yourPassword";
const char* pushbulletToken = "yourToken";  

void setup() {
  AI.begin();              // I2C communication with Grove Vision AI
  Serial.begin(9600);
  // Connect to Wi-Fi network
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to Wi-Fi");
}

void loop() {
  if (!AI.invoke(1, false, false)) {
    Serial.println("Model executed successfully");
    // Iterate through detections
    for (int i = 0; i < AI.boxes().size(); i++) {
      int detectedClass = AI.boxes()[i].target;
      float confidence = AI.boxes()[i].score;
      // If the detected class is a person (class 0) and confidence is greater than 80%
      if (detectedClass == 0 && confidence > 0.8) {
        Serial.println("Person detected!");
        triggerAlarm();
      }
    }
  } else {
    Serial.println("Error executing the model");
  }
  delay(1000); // Wait 1 second before running again
}

void triggerAlarm() {
  // Send notification
  HTTPClient http;
  http.begin("https://api.pushbullet.com/v2/pushes");
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Access-Token", pushbulletToken);
  String payload = "{\"type\":\"note\",\"title\":\"Alarm!\",\"body\":\"Intrusion detected!\"}";
  int httpResponseCode = http.POST(payload);
  if (httpResponseCode > 0) {
    String response = http.getString();
    Serial.println("Server response:");
    Serial.println(response);
  } else {
    Serial.print("Request error: ");
    Serial.println(httpResponseCode);
  }
  http.end();
}

As you can see, this program combines everything we’ve covered so far.

In the setup, it initializes the connection with the Grove Vision and connects to the Wi-Fi network.

In the loop, it invokes the model every second, and if the model reports that a person has been detected with a confidence level greater than 80%, the alarm is triggered by printing a message and sending a notification via Pushbullet.

Of course, several aspects of this code could be improved. I’ve kept it simple to highlight the most important concepts rather than focusing on the details, but in a more complete version, you should consider things like managing the Wi-Fi connection and reconnecting if it's lost, avoiding multiple triggers when a person is detected, and so on.

Repository

All the code presented in this article can be found in my repository

More info

SenseCraft

Seeed Studio Wiki

Seeed_Arduino_SSCMA Repository

Conclusions

In this article, we explored the use of the Grove Vision AI V2 module together with the SenseCraft platform to develop image recognition projects locally, without the need for cloud connectivity. We looked at its main features, programming options, and how it easily integrates with boards like the XIAO ESP32-C3.

We also developed a practical example: a silent alarm that detects unauthorized people and sends a notification to a smartphone using Pushbullet. This project demonstrated how simple it can be to implement real computer vision solutions thanks to the support of libraries like Seeed_Arduino_SSCMA and the optimized models available in SenseCraft.

The combination of Grove Vision and SenseCraft offers an accessible, powerful, and versatile platform—ideal for those looking to incorporate artificial intelligence into their projects efficiently and without complications.

As always, I hope this article helps you build your own projects using SenseCraft and the Grove Vision AI module from Seeed Studio.

If you have any questions or suggestions, feel free to leave them in the comment section below.

For more information and projects, you can check out my blog and social media.

See you next time! 🚀