Gravity: Offline Edge AI Gesture & Face Detection Sensor – 5 Gestures, 10 Faces, 3m (Arduino/ RPi/ ESP32) - แท้ DFRobot

• AI Recognition Performance: Offline solution, rapidly recognizing 5 hand gestures within 3 meters with high accuracy

• Facial Detection: Supports detection of areas above the shoulders, outputting quantity, position coordinates, and recognition scores

• Communication Methods: Two data communication modes—I2C and UART

• Voltage Compatibility: Compatible with 3.3V/5V levels and supply voltages

• Development Support: Supports MakeCode and Mind + graphical programming

Application

• Contactless control of information screens in public areas

• Stage performances

• Home appliance control

• Music playback control

• Dimension Diagram

Dimension Diagram

Physical Dimensions

• PCB Dimensions: 42m*32mm
• Mounting Hole Spacing: 25mm*35mm
• Mounting Hole Diameter: 3.1mm

Specifications

Function Diagram

Detailed Explanation of Core Functions

1. Gesture Recognition Function

Supported Gestures and Corresponding Information

Core Capabilities

• Capable of real-time detection of 5 gestures (👍, 👌, 🤚, ✌️, 🤙) with stable recognition within 3 meters; upon recognition, real-time feedback is provided via corresponding colored indicator lights (e.g., blue for a good), while outputting the gesture type and recognition score.

Frequently Asked Questions

Q: What does the gesture score signify, and what score constitutes a valid recognition?

A: The gesture recognition result outputs a score ranging from 0 to 100. By default, the program a score of ≥60 as a valid gesture (which will trigger the function). A higher score indicates a greater "similarity" between the current action and the standard gesture; for instance, a score of 80 or above generally confirms the target gesture. A score below 30 is often due to suboptimal recognition conditions (such as an unstandardized gesture, excessive distance beyond the effective range, or ambient light interference), in which case accurate gesture recognition is improbable.

Q: What is the range of gesture recognition distance, and what considerations apply when using it at different distances?

A:

• Recognition Range: Supports recognition within 0.5-3 meters. Prior to recognizing gestures, ensure that the area above the shoulders is fully within the camera's field of view and detected (facial indicator light illuminated). If the distance is too close (<0.5 meters), the area above the shoulders may exceed the camera's capture range, resulting in recognition failure;
• Optimal Distance (1-2 meters): Within this range, the camera achieves a balance between "comprehensive frame coverage" and "clarity of feature details," enabling precise capture of gestures with optimal recognition accuracy and response speed;
• Maximum Distance (≤3 meters): More susceptible to environmental interference. Obstructions (such as crowds or furniture) or complex lighting (direct glare/dimness) may impair recognition performance. It is advisable to utilize the 3-meter maximum distance in open, evenly lit environments, prioritizing an unobstructed lens and clear imagery.

2. Facial Detection Function (Including the Area Above the Shoulders)

Core Capabilities

• Capable of detecting the "facial range" with feedback via the facial indicator light (lit = presence detected, unlit = no presence).

• Capable of detecting the number of faces (up to 10), and real-time output of the number of faces, the coordinates of the face with the highest score, and the corresponding recognition score.

Frequently Asked Questions

Q: How to interpret the facial coordinate range, and what is its significance?

A: The X/Y coordinate range of the face is 0-640, corresponding to physical position coordinates within the camera's field of view. The numerical value is directly correlated with the actual position: a larger X value indicates the face is further to the right in the camera's view; a larger Y value indicates it is further downward (with the coordinate origin at the top-left corner of the view). For example, (320,320) corresponds to the exact center of the view, facilitating intuitive localization of the face within the frame and enabling position-based functions such as servo tracking.

Q: What does the facial score represent, and what score confirms a face?

A: The facial recognition result outputs a score ranging from 0 to 100. The program defaults to a reference threshold of 60, with a higher score indicating a greater likelihood that the region is a face. For example, a score of 90 suggests a high probability of it being a face.

Q: When multiple faces are present simultaneously, what rule governs the return of coordinates?

A: Currently, simultaneous return of coordinates for multiple faces is not supported; only the coordinates of the face with the highest recognition score (highest score = clearest view, most face-like) will be returned.

Q: When multiple faces and gestures are detected simultaneously, what is the scoring correspondence rule?

A: When multiple faces and gestures are detected, the score corresponds by default to the target with the highest gesture score (i.e., the target with the clearest gesture).

Q: What is the logical sequence of gesture and facial detection, and what precautions apply during use?

A: The camera first detects whether a face is recognized, then checks for the presence of the 5 gestures. Ensure that both the face and gestures are within the camera's detection range (i.e., perform the corresponding gesture when the facial indicator light is illuminated).

Tutorial for Using Arduino IDE

Through the following tutorial, you will master the basic usage and advanced applications of the SEN0626 AI Visual Gesture/Face Tracking Sensor in the Arduino IDE environment, specifically including: reading sensor data via both I2C and UART communication methods to understand the actual effects of gesture recognition and face detection; and through two examples of a dazzling LED ring and a human-tracking fan, learning how to combine the sensor with other devices to achieve complex functions (the following tutorial uses controllers such as FireBeetle 2 ESP32-E, DFRduino UNO R3 paired with the SEN0626 sensor as examples).

Basic Tutorial

• Hardware Preparation
  • AI Visual Gesture/Face Tracking Sensor ×1
  • FireBeetle 2 ESP32-E (N16R2）×1
• Software Preparation
  • Arduino IDE Click to download Arduino IDE
  • Download and install DFRobot_GestureFaceDetection
  • Download and install DFRobot_RTU

Reading Data via I2C

We can make the connections according to the diagram below:

• Wiring Diagram

• Sample Code
  • Step 1: Connect the sensor to the ESP32-E controller according to the wiring diagram above, and switch the communication mode selection switch on the sensor to the I2C side.
  • Step 2: Open Arduino IDE, copy the following code and upload it to the ESP32-E.
  • Step 3: Open the serial monitor in Arduino IDE, set the baud rate to 115200, and observe the serial print results.

#include "DFRobot_GestureFaceDetection.h"
#define DEVICE_ID 0x72 

DFRobot_GestureFaceDetection_I2C gfd(DEVICE_ID);
char str[100];

void setup(){
gfd.begin(&Wire);
Serial.begin(115200);
gfd.setFaceDetectThres(60);
gfd.setGestureDetectThres(60);
gfd.setDetectThres(100);
}

void loop(){
if(gfd.getFaceNumber() > 0){
uint16_t faceScore = gfd.getFaceScore();
uint16_t faceX = gfd.getFaceLocationX();
uint16_t faceY = gfd.getFaceLocationY();
sprintf(str, "detect face at (x = %d, y = %d, score = %d)\n", faceX, faceY, faceScore);
Serial.print(str);
uint16_t gestureType = gfd.getGestureType();
uint16_t gestureScore = gfd.getGestureScore();
sprintf(str, "detect gesture %d, score = %d\n", gestureType, gestureScore);
Serial.print(str);
}
delay(1500);
}

Results

Output content of the serial monitor:

Interpretation:

1. First line: Face detection data
   • x = 291, y = 330: Indicates the position coordinates of the detected face (area above the shoulders) in the camera's field of view (range 0-640; the larger the value, the closer to the right/bottom of the field of view);
   • score = 74: Face recognition score (0-100), with a higher score indicating more accurate recognition (a score ≥60 is considered valid).
2. Second line: Gesture detection data
   • gesture 2: Indicates that the recognized gesture type is "OK" (corresponding to program value 2, refer to the gesture comparison table in "Detailed Explanation of Core Functions");
   • score = 91: Gesture recognition score (0-100), with a higher score indicating a more standard gesture (a score ≥60 is considered valid). At this time, the gesture indicator light will synchronously light up green (corresponding to the "OK" gesture).

Note:

The above two lines of information will only be output when the sensor detects both a face (area above the shoulders) and a gesture simultaneously; if no face is detected, there will be no output from the serial port.

Reading Data via UART

We can make the connections according to the diagram below

• Wiring Diagram

• Sample Code
  • Step 1: Connect the sensor to the ESP32-E controller according to the wiring diagram above, and switch the communication mode selection switch on the sensor to the UART side.
  • Step 2: Open Arduino IDE, copy the following code and upload it to the ESP32-E.
  • Step 3: Open the serial monitor in Arduino IDE, set the baud rate to 115200, and observe the serial print results.

#include "DFRobot_GestureFaceDetection.h"
#define DEVICE_ID 0x72 

DFRobot_GestureFaceDetection_UART gfd(&Serial1, DEVICE_ID);

void setup(){
Serial1.begin(9600,SERIAL_8N1, D2, D3);
Serial.begin(115200);
delay(1500);
Serial.print("Product ID: ");
Serial.println(gfd.getPid());
Serial.print("Vendor ID: ");
Serial.println(gfd.getVid());
}

void loop(){
Serial.print("Faces detected: ");
Serial.println(gfd.getFaceNumber());
delay(1500);
}

Results

Output content of the serial monitor:

Interpretation:

1. First two lines: Device identity information
   • Product ID: 626: The product number of the sensor (corresponding to 0x3343 in hexadecimal);
   • Vendor ID: 13123: The vendor number (corresponding to 0x0272 in hexadecimal).
2. Third line: Face detection result
   • Faces detected: 1: Indicates that 1 face (area above the shoulders) is currently detected, and the face indicator light is on steadily at this time;
   • If there is no one, it will display Faces detected: 0, and the indicator light will turn off synchronously.

The face detection information is refreshed every 1.5 seconds, providing an intuitive feedback of the detection result.

Advanced Tutorial

Dazzling LED Ring

Through this tutorial, you will learn how to combine the AI Visual Gesture/Face Tracking Sensor with a WS2812B RGB LED ring, using the sensor to achieve contactless control of the LED ring's color, creating a dazzling LED ring device that changes color with gestures.

Hardware Preparation

• DFR0868 Beetle ESP32-C3 ×1
• FIT0676 93-LED/6-Ring WS2812B RGB ×1
• SEN0626 AI Visual Gesture/Face Tracking Sensor ×1

Software Preparation

• Arduino IDE Click to download Arduino IDE
• Download and install DFRobot_GestureFaceDetection
• Download and install DFRobot_RTU
• Download and install FastLED

Wiring Diagram

We can make the connections according to the diagram below

Sample Code

• Step 1: Connect the sensor, WS2812B LED ring, and ESP32-C3 controller according to the wiring diagram, and switch the sensor's communication mode switch to the I2C side.
• Step 2: Open Arduino IDE, copy the following code and upload it to the ESP32-C3.

#include <Wire.h>
#include <FastLED.h>
#include "DFRobot_GestureFaceDetection.h"

#define LED_PIN 4
#define NUM_LEDS 93
#define DEVICE_ID 0x72

CRGB leds[NUM_LEDS];
DFRobot_GestureFaceDetection_I2C gfd(DEVICE_ID);

void setup() {
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
Wire.begin(8, 9); // SDA, SCL
gfd.begin(&Wire);
Serial.begin(115200);
gfd.setFaceDetectThres(60);
gfd.setGestureDetectThres(60);
gfd.setDetectThres(100);
}

void loop() {
if(gfd.getFaceNumber() > 0) {
uint16_t gestureType = gfd.getGestureType();
switch(gestureType) {
case 1:
setAllLEDs(CRGB::Blue);
break;
case 2:
setAllLEDs(CRGB::Green);
break;
case 3:
setAllLEDs(CRGB::Red);
break;
case 4:
setAllLEDs(CRGB::Yellow);
break;
case 5:
setAllLEDs(CRGB::Purple);
break;
default:
setAllLEDs(CRGB::Black);
break;
}
}
else {
setAllLEDs(CRGB::Black);
}
delay(1500);
}

void setAllLEDs(CRGB color) {
for(int i = 0; i < NUM_LEDS; i++) {
leds[i] = color;
}
FastLED.show();
}

Results

When the sensor detects a face (area above the shoulders), the LED ring will synchronously change color according to the gesture you make:

• Gesture 1 (Good) → Blue;
• Gesture 2 (OK) → Green;
• Gesture 3 (Stop) → Red;
• Gesture 4 (Victory) → Yellow;
• Gesture 5 (Call me) → Purple.

When no face is detected, the LED ring automatically turns off, achieving the intelligent effect of "lights on when someone is present, color controlled by gestures".

Face-Tracking Fan

Through this tutorial, you will learn how to integrate the AI Visual Gesture/Face Tracking Sensor with a DC motor fan and a servo motor to achieve two core functions: controlling the fan's start and stop via gestures, while enabling the fan to automatically rotate and track the face position, creating an intelligent fan device that "delivers wind where the person is and is controllable via gestures".

Hardware Preparation

• DFR0216 DFRduino UNO R3 ×1
• DFR0265 Gravity: IO Sensor Expansion Board V7.1 ×1
• DFR0411 Gravity: 130 DC Motor Fan ×1
• SER0056 2Kg 300° Clutch Servo ×1
• AI Visual Gesture/Face Tracking Sensor ×1

Software Preparation

• Arduino IDE Click to download Arduino IDE
• Download and install DFRobot_GestureFaceDetection
• Download and install DFRobot_RTU
• How to install libraries

Wiring Diagram

Connections can be made according to the diagram below:

Sample Code

• Step 1: Connect the sensor, DFRduino UNO R3 controller, IO sensor expansion board, fan, and servo according to the wiring diagram, and switch the sensor's communication mode switch to the I2C side.
• Step 2: Open Arduino IDE, copy the following code and upload it to the DFRduino UNO R3.

#include <Wire.h>
#include <Servo.h>
#include "DFRobot_GestureFaceDetection.h"

#define DEVICE_ID 0x72
#define FAN_PIN 3
#define SERVO_PIN 5

Servo myservo;
DFRobot_GestureFaceDetection_I2C gfd(DEVICE_ID);

void setup(){
myservo.attach(SERVO_PIN);
myservo.write(0);
gfd.begin(&Wire);
Serial.begin(115200);
gfd.setFaceDetectThres(60);
gfd.setGestureDetectThres(60);
gfd.setDetectThres(100);
pinMode(FAN_PIN, OUTPUT);
}

void loop(){
//Serial.println(gfd.getGestureType());
if(gfd.getFaceNumber() > 0){
uint16_t gestureType = gfd.getGestureType();
if(gestureType == 2){
analogWrite(FAN_PIN, 255);
}
else if(gestureType == 3){
analogWrite(FAN_PIN, 0);
}
uint16_t x = gfd.getFaceLocationX();
Serial.println(x);
myservo.write(map(x,0,620,10,170));
Serial.println(gfd.getGestureType());
}
}

Results

When the sensor detects a face (area above the shoulders), the system activates the following linked effects:

1. Gesture-Controlled Fan
   • Making the "OK" gesture (corresponding to gesture type 2): The fan turns on immediately at maximum power without the need to touch a switch;
   • Making the "Number 5" gesture (corresponding to gesture type 3): The fan automatically turns off, achieving contactless start-stop control.
2. Real-Time Face Position Tracking: The servo motor will drive the fan, adjusting the angle in real time according to the X-coordinate of the face in the camera's field of view (range 0-620):
   • When the face moves left (X value decreases), the servo angle decreases synchronously (range 10°-170°), and the fan turns left;
   • When the face moves right (X value increases), the servo angle increases synchronously, and the fan turns right; the entire process is smooth and continuous, achieving the precise following effect of "wherever the person goes, the fan follows".
3. Debugging Feedback: The serial monitor outputs the X-coordinate of the face and the currently recognized gesture type in real time (e.g., "300", "2"), facilitating observation of the device's operating status and debugging optimization.

Note: Please check the tracking fan structure file in more downloads.

API Functions

 /**
* @fn getPid
* @brief Retrieves the device's PID.
* @return The device's PID.
*/
uint16_t getPid();

/**
* @fn getVid
* @brief Retrieves the device's VID.
* @return The device's VID.
*/
uint16_t getVid();

/**
* @fn setDeviceAddr
* @brief Sets the device address.
* @param addr The device address.
* @return Returns true if the address is set successfully; otherwise, returns false.
*/
bool setDeviceAddr(uint16_t addr);

/**
* @fn configUart
* @brief Configures UART settings.
*
* This method is used to set the device's UART communication parameters, including baud rate, parity, and stop bits.
* Users can select appropriate parameters according to their needs to ensure stable and effective communication with the device.
*
* @param baud Baud rate configuration, of type `eBaudConfig_t`, possible values include:
* - `eBaud_1200` - 1200 baud
* - `eBaud_2400` - 2400 baud
* - `eBaud_4800` - 4800 baud
* - `eBaud_9600` - 9600 baud
* - `eBaud_14400` - 14400 baud
* - `eBaud_19200` - 19200 baud
* - `eBaud_38400` - 38400 baud
* - `eBaud_57600` - 57600 baud
* - `eBaud_115200`- 115200 baud
* - `eBaud_230400`- 230400 baud
* - `eBaud_460800`- 460800 baud
* - `eBaud_921600`- 921600 baud
*
* @param parity Parity configuration, of type `eParityConfig_t`, possible values include:
* - `UART_CFG_PARITY_NONE` - No parity
* - `UART_CFG_PARITY_ODD` - Odd parity
* - `UART_CFG_PARITY_EVEN` - Even parity
* - `UART_CFG_PARITY_MARK` - Mark parity
* - `UART_CFG_PARITY_SPACE` - Space parity
*
* @param stopBit Stop bit configuration, of type `eStopbits_t`, possible values include:
* - `UART_CFG_STOP_BITS_0_5` - 0.5 stop bits
* - `UART_CFG_STOP_BITS_1` - 1 stop bit
* - `UART_CFG_STOP_BITS_1_5` - 1.5 stop bits
* - `UART_CFG_STOP_BITS_2` - 2 stop bits
*
* @return Configuration status, returns a status code if configuration is successful; otherwise, returns an error code.
*/
uint16_t configUart(eBaudConfig_t baud, eParityConfig_t parity, eStopbits_t stopBit);

/**
* @fn setFaceDetectThres
* @brief Sets the face detection threshold.
*
* Sets the threshold for face detection (0-100). The default value is 60%.
*
* @param score The threshold value.
* @return Returns true if successful; otherwise, returns false.
*/
bool setFaceDetectThres(uint16_t score);

/**
* @fn setDetectThres
* @brief Sets the detection threshold for the X coordinate.
*
* Sets the threshold for detecting the X coordinate (0-100). The default value is 60%.
*
* @param x The threshold value.
* @return Returns true if successful; otherwise, returns false.
*/
bool setDetectThres(uint16_t x);

/**
* @fn setGestureDetectThres
* @brief Sets the gesture detection threshold.
*
* Sets the threshold for gesture detection (0-100). The default value is 60%.
*
* @param score The threshold value.
* @return Returns true if successful; otherwise, returns false.
*/
bool setGestureDetectThres(uint16_t score);

/**
* @fn getFaceNumber
* @brief Retrieves the number of faces detected by the device.
* @return The number of detected faces.
*/
uint16_t getFaceNumber();

/**
* @fn getFaceLocationX
* @brief Retrieves the X coordinate of the detected face.
* @return The X coordinate of the face.
*/
uint16_t getFaceLocationX();

/**
* @fn getFaceLocationY
* @brief Retrieves the Y coordinate of the detected face.
* @return The Y coordinate of the face.
*/
uint16_t getFaceLocationY();

/**
* @fn getFaceScore
* @brief Retrieves the score of the detected face.
* @return The face score.
*/
uint16_t getFaceScore();

/**
* @fn getGestureType
* @brief Retrieves the type of detected gesture.
*
* This method retrieves the currently detected gesture type. The gesture recognition function can be used in various applications such as human-computer interaction or control systems.
* The returned gesture types correspond to the following values:
* - 1: LIKE (👍) - Blue
* - 2: OK (👌) - Green
* - 3: STOP (🤚) - Red
* - 4: YES (✌️) - Yellow
* - 5: SIX (🤙) - Purple
*
* If no gesture is detected, the return value may be a specific invalid value (e.g., 0).
*
* @return The type of detected gesture.
*/
uint16_t getGestureType();

/**
* @fn getGestureScore
* @brief Retrieves the score of the detected gesture.
* @return The gesture score.
*/
uint16_t getGestureScore();

Graphical Programming Tutorial

1. Mind+ (Based on Scratch3.0): Reading Face/Gesture Data with Building Blocks

No coding is required. By dragging and dropping graphical building blocks, you can make the sensor output the number of faces, position coordinates, and the types of recognized gestures (such as "thumbs-up", "OK", etc.).

Operation Steps:

1. Download and Install the Software: Click Download Mind+ and follow the prompts to complete the installation (refer to the Mind+ Basic Installation Tutorial).
2. Select Device and Add Extension:
   • Open Mind+, switch to "Upload Mode", and select "Arduino Uno" in "Extensions" → "Main Control Board";
   • Click "User Library", paste the link: https://gitee.com/zhangtang6677/ext-gestureFaceDetectionSensor.git, search for and add the "Gesture and Face Tracking Sensor" extension.
3. Graphical Programming: Drag modules from the left building block area (such as "Read Number of Faces", "Read Gesture Type", etc.) to form a simple program (refer to the example diagram).

4. Upload and View Results:

   • Connect the sensor to the computer with a data cable, "Connect Device" in Mind+ and select the corresponding port;
   • Click "Upload to Device", and after completion, open the "Serial Monitor" to see the real-time output of face, gesture, and face coordinate data (such as "Number of faces: 1", "Gesture: 2 (OK gesture)").

2. MakeCode (micro:bit Platform): Graphical Implementation of Face/Gesture Detection

On the micro:bit development board, program with graphical building blocks to enable the sensor to detect the presence of a face, recognize gesture types, and display the results on the device, which is suitable for fun interactive projects with micro:bit.

Operation Steps:

1. Open the Programming Platform: Enter the MakeCode official website in the browser, click "New Project" and name it (e.g., "Face and Gesture Detection").
2. Load the Sensor Library:
   • Click "Settings" in the upper right corner → "Extensions", paste the link in the search box: https://github.com/DFRobot/pxt-DFRobotGestureFaceDetection, and load the extension library.
3. Graphical Programming: Drag modules from the left building block area (such as "Get Number of Faces", "Get Face X Coordinate") to form a program (refer to the example diagram).

4. Download and View Results:

   • Click "Download" to save the program to the computer and transfer it to the micro:bit development board;
   • Connect the sensor to the micro:bit, open the "Show data" window, and you can see the real-time detection results (such as "Number of faces: 1", "Gesture: 2 (OK gesture)").

General Notes:

• In the Mind+ and MakeCode graphical programming environments, the sensor only supports the I2C communication mode and does not support the UART mode for the time being. Please switch the sensor's communication mode switch to the I2C side to ensure proper use.
• For supported gestures and corresponding information, refer to the "Detailed Explanation of Core Functions" section above in the Wiki.
• If no data is output, check whether the device connection is secure and whether the extension library is added correctly.

Modbus Register Definitions

For customizing device addresses, querying firmware versions, or adjusting core parameters, the following registers can be utilized (suitable for advanced development scenarios):

Note:

• The default device address is 0x0072. If the address is modified, the I2C address will be updated accordingly.
• The face detection range is the area above the human shoulders.

Common Modbus-RTU Function Codes:

Input registers and holding registers can be read and written via the above commands.

Register Read/Write Examples

Hardware Preparation

• SEN0626 AI Visual Gesture/Face Detection Sensor ×1
• TEL0185 RainbowLink USB Protocol Converter ×1

Recommended Serial Debugging Tools and Downloads

For serial port-related debugging work, professional serial debugging tools are required. Here are several commonly used and feature-rich tools recommended for you:

• xcom Serial Debug Assistant V2.0: An efficient and easy-to-use serial communication assistant. Available at this link.
• SSCOM3.2 Serial Assistant: Designed specifically for embedded development, IoT communication, and daily serial debugging. Download address is project repository.

Example 1: Read Number of Faces (Read Input Register Operation)

Function: Read the number of faces currently detected by the sensor via the Modbus RTU protocol.

Sending Command and Analysis

Complete sending command: 72 04 00 04 00 01 7B 08

Operation Steps

1. Hardware Connection: Connect the sensor to the host (computer) via the RainbowLink USB protocol converter, and switch the sensor communication mode to UART.

2. Parameter Configuration: Set parameters in the serial debugging tool (must be consistent with the sensor):

   1. Baud rate: 9600 (default)
   2. Data bits: 8 bits
   3. Stop bits: 1 bit
   4. Parity: None

3. Send Command: Enter the above hexadecimal command in the "Send Area" of the debugging tool, check "Send in Hexadecimal" and send.

Return Data and Analysis

After receiving the command, the sensor returns the number of faces data, as shown in the example below:

Complete return data: 72 04 02 00 01 7D 3B

Schematic diagram as follows:

Example 2: Modify Module Baud Rate (Write Holding Register Operation)

Function: Modify the UART baud rate of the sensor via the Modbus RTU protocol (default 9600, customizable).

Sending Command and Analysis

Complete sending command: 72 06 00 01 00 09 13 0F

Operation Steps

1. Hardware connection and basic parameter configuration are the same as "Reading the number of faces" (the current default baud rate 9600 must be used to send commands).
2. After sending the above command, if the returned data is consistent with the sending command, it indicates that the baud rate modification request has been received by the device.

Return Data and Analysis

Complete return data: 72 06 00 01 00 09 13 0F

Note:

• The baud rate modification takes effect only after the sensor is powered off and restarted;
• After restart, the serial debugging tool's baud rate must be modified to 115200 synchronously, otherwise communication cannot continue.

More Downloads

• SEN0626_2D_CAD.png
• SEN0626_2D_DXF.rar
• SEN0626_3D_STP.rar
• SEN0626_Tracking fan structure.zip