Real-Time Radar Visualization by Carenuity C3-Mini & OLED

Experience real-time radar data visualization with the Carenuity C3-Mini, LD2410C radar sensor, & OLED display via I2C - ideal for security.

IntermediateFull instructions provided1 hour229

Real-Time Radar Visualization by Carenuity C3-Mini & OLED

Things used in this project

Software apps and online services

Arduino IDE

Story

Real-Time Radar Visualization with Carenuity C3-Mini and OLED Via i2c

Introduction

In my latest and greatest project, I’ve combined cutting-edge radar technology with an intuitive display interface. I've created a system that provides real-time visualization of radar data by integrating the LD2410C radar sensor with an OLED screen via the versatile Carenuity C3-Mini. This project highlights the power and flexibility of these components, demonstrating their potential in a range of applications, especially in smart home automation and security.

Project Overview

This project aimed to develop a compact and powerful system capable of detecting and displaying radar data in real time. By leveraging the Carenuity C3-Mini's robust capabilities and the precision of the LD2410C radar sensor, I’ve built a versatile interface perfect for various applications, from security systems to smart home devices.

Key Components:

Carenuity C3-Mini: A successor to the D1-Mini, powered by a 160MHz RISC-V processor, with 400kB of SRAM and 4MB of flash memory. Learn more about the greatest Development board HERE
LD2410C Radar Sensor: A highly precise radar module that detects both stationary and moving targets, providing real-time data on their distance and energy levels.
OLED Display: A 128x64 pixel screen connected via I2C to visualize radar data.

Key Features:

Real-Time Radar Data Display: Continuously reads and displays data from the radar sensor, providing immediate visual feedback.
Compact and Efficient Design: All components are seamlessly integrated, making the system highly efficient and compact.
Versatile Connectivity: Ideal for various applications, thanks to its compatibility with multiple programming environments and ease of use.

Hardware Setup

The hardware configuration is simple and efficient:

The RX pin of the LD2410C radar sensor is connected to pin 5 of the Carenuity C3-Mini.
The TX pin of the radar sensor is connected to pin 4 of the C3-Mini.
The OLED display is connected via I2C for smooth data communication.

Software Implementation

The software side involves using the appropriate libraries to read data from the radar sensor and display it on the OLED screen. Below is the code used for this project:

Install this library in your arduino ide

Install the required libraries in your Arduino IDE.
Choose the board as Lolin C3-Mini under Tools and select the correct COM port.

Compile and upload your code.

What the LD2410C Radar Sensor Does

The LD2410C radar sensor is a versatile module capable of detecting both stationary and moving objects. It provides real-time data on the distance and energy levels of detected targets, making it perfect for applications requiring precise motion detection and presence sensing. This sensor operates effectively in various environmental conditions, ensuring reliable performance where optical sensors might fail.

Pros of Radar Technology

Radar technology offers several advantages:

Accuracy: Provides precise detection of both stationary and moving objects.
Reliability: Functions effectively in various environmental conditions, unlike optical sensors.
Range: Capable of detecting objects over a considerable distance.
Versatility: Useful in a wide range of applications, from automotive to home security systems.

Conclusion

This project is a testament to the incredible capabilities of combining radar technology with modern microcontrollers and displays. The Carenuity C3-Mini, paired with the LD2410C radar sensor and an OLED screen, creates a powerful and compact system that can be applied in numerous real-world scenarios.

Feel free to replicate this project, make improvements, and adapt it to your specific needs. The possibilities are endless when you have the right components and a bit of creativity! Feel free to reach out for any assistance.

LD2410C Arduino code

#define MONITOR_SERIAL Serial
#define RADAR_SERIAL Serial1
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeSans9pt7b.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define RADAR_RX_PIN 5
#define RADAR_TX_PIN 4

#include <ld2410.h>

ld2410 radar;

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

uint32_t lastReading = 0;
bool radarConnected = false;

void setup(void) {
    MONITOR_SERIAL.begin(115200); // Feedback over Serial Monitor

    // radar.debug(MONITOR_SERIAL); // Uncomment to show debug information from the library on the Serial Monitor. By default this does not show sensor reads as they are very frequent.
    #if defined(ESP32)
    RADAR_SERIAL.begin(256000, SERIAL_8N1, RADAR_RX_PIN, RADAR_TX_PIN); // UART for monitoring the radar
    #elif defined(__AVR_ATmega32U4__)
    RADAR_SERIAL.begin(256000); // UART for monitoring the radar
    #endif
    delay(500);
    MONITOR_SERIAL.print(F("\nConnect LD2410 radar TX to GPIO:"));
    MONITOR_SERIAL.println(RADAR_RX_PIN);
    MONITOR_SERIAL.print(F("Connect LD2410 radar RX to GPIO:"));
    MONITOR_SERIAL.println(RADAR_TX_PIN);
    MONITOR_SERIAL.print(F("LD2410 radar sensor initialising: "));
    if (radar.begin(RADAR_SERIAL)) {
        MONITOR_SERIAL.println(F("OK"));
        MONITOR_SERIAL.print(F("LD2410 firmware version: "));
        MONITOR_SERIAL.print(radar.firmware_major_version);
        MONITOR_SERIAL.print('.');
        MONITOR_SERIAL.print(radar.firmware_minor_version);
        MONITOR_SERIAL.print('.');
        MONITOR_SERIAL.println(radar.firmware_bugfix_version, HEX);
    } else {
        MONITOR_SERIAL.println(F("not connected"));
    }

    // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
    if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
        Serial.println(F("SSD1306 allocation failed"));
        for (;;); // Don't proceed, loop forever
    }
    // Clear the buffer
    display.clearDisplay();
    display.display();
    delay(1500);
}

void loop() {
    radar.read();
    if (radar.isConnected() && millis() - lastReading > 1000) { // Report every 1000ms
        lastReading = millis();
        if (radar.presenceDetected()) {
            if (radar.stationaryTargetDetected()) {
                Serial.print(F("Stationary target: "));
                Serial.print(radar.stationaryTargetDistance());
                Serial.print(F("cm energy:"));
                Serial.print(radar.stationaryTargetEnergy());
                Serial.print(' ');

                // Display on OLED
                display.clearDisplay();
                display.setFont(&FreeSans9pt7b);
                display.setTextSize(1);
                display.setTextColor(SSD1306_WHITE); // Draw white text
                display.setCursor(0, 15); // Start at top-left corner
                display.print(F("S.target: "));
                display.print(radar.stationaryTargetDistance());
                display.print(F("cm energy:"));
                display.print(radar.stationaryTargetEnergy());
                display.display();
            }
            if (radar.movingTargetDetected()) {
                Serial.print(F("M.target: "));
                Serial.print(radar.movingTargetDistance());
                Serial.print(F("cm energy:"));
                Serial.print(radar.movingTargetEnergy());

                //Display on OLED
                display.print(F("M.target: "));
                display.print(radar.movingTargetDistance());
                display.print(F("cm energy:"));
                display.print(radar.movingTargetEnergy());
                display.display();
            }
            Serial.println();
        } else {
            Serial.println(F("No target"));
        }
    }
}