• Project Overview
• Video Demonstrations
• Hardware
• Task Scheduling
• Drivers
• Getting Started
• Resources
• Contact

The STM32 Multi Sensor MicroSD Datalogger Project is a comprehensive embedded system that reads data from multiple sensors and logs it to a MicroSD card in CSV format.

The system reads data from multiple sensors:

• DS18B20: Digital temperature sensor (1-Wire)
• DHT11: Temperature and humidity sensor (1-Wire protocol)
• MPU6050: 6-axis accelerometer, gyroscope, and temperature sensor (I2C)

The data acquired from these sensors are saved into a MicroSD card in a file named saved_sensor_data.csv in CSV format using the FatFS file system.

There are three ways to interact with the system:

1. 16x2 LCD Display: Shows real-time sensor data in four selectable modes:

   • Mode 1 (Temperature/Humidity): Displays DHT11 Temperature and Humidity
   • Mode 2 (Temperature): Displays both DS18B20 and MPU6050 temperatures
   • Mode 3 (Accelerometer): Shows X, Y, Z acceleration values
   • Mode 4 (Gyroscope): Shows X, Y, Z gyroscope values

2. Three Push Buttons:

   • Button 1: Switch between display modes
   • Button 2: Save current sensor readings to SD Card
   • Button 3: Retrieve and export all stored data via UART

3. UART Interface: Export stored data in a formatted table for analysis on a PC

The data is also saved automatically every 5 seconds (currently disabled for demonstration purposes as button-based saving is easier to showcase).

The main control loop runs at a timing of 10ms, demonstrating real-time control and task scheduling without using an RTOS.

This project really demonstrates the combination of multiple embedded concepts: sensor data acquisition, data storage, real-time control, and task scheduling through a control loop.

Button 1 – Display Mode Switching

Pressing Button 1 cycles through four LCD display modes: DHT11 Temp/Hum → DS18B20 + MPU6050 Temp → Accelerometer → Gyroscope

Button 2 & 3 – Save & Retrieve Data

Button 2 saves sensor data to MicroSD card. Button 3 retrieves all stored data and sends via UART.
Both buttons have a 1-second cooldown to prevent accidental multiple presses and allow time for data to be saved.

Data Persistence – After Reset

Data persists in the SD card even after reset. The CSV file is found and data is read correctly.

UART Output Format

HTerm output showing formatted table.

Note: MicroSD cards require 3.3V logic, but most adapter modules include onboard voltage regulators and level shifters, allowing them to be powered with 5V.

The LCD display and MPU6050 share the same I2C bus (PB10/SCL, PB11/SDA) with different addresses:

🔗 View Custom Written I2C Driver Source Code

Note: All peripherals are used as pre-built modules. The LCD module uses a PCF8574 I2C backpack.

Schematic designed using EasyEDA

The system uses a 10ms timer-based control loop with independent counters for each task. TIMER3 is configured to drive the main control loop.

🔗 View DWT Driver (Microsecond Delay)
🔗 View TIMER2 Driver (Millisecond Counter)
🔗 View TIMER3 Driver (10ms Heartbeat)
🔗 View Button & TIMER4 Driver (Debounce)

Note: DWT (Data Watchpoint and Trace) is a built-in peripheral in ARM Cortex-M3 cores that provides a cycle counter running at CPU frequency (72MHz). This gives ~13.9ns resolution, making it ideal for generating precise microsecond delays required by the DS18B20 and DHT11 1-Wire protocol. Unlike traditional timer-based delays, DWT does not occupy a dedicated timer peripheral and continues running in the background.

The SD card interface handles all communication between the STM32 and the MicroSD card, from low-level SPI commands to high-level file operations.

Application Layer (sd_data_logger.c)
↓
High-Level File API (sd_functions.c) - Mount, read, write, list files
↓
FatFS Middleware (CubeMX generated)
↓
Disk I/O Interface (sd_diskio.c) - FatFS hardware abstraction
↓
Low-Level SPI Driver (sd_spi.c) - Raw SPI commands, DMA, timing
↓
Hardware (STM32 SPI1 + SD Card)

• Full SD protocol implementation (CMD0, CMD8, ACMD41, CMD17, CMD24, etc.)
• SDHC/SDSC detection and handling
• Single and multi-block read/write with DMA support
• CRC and error checking

• Standard FatFS disk I/O functions (initialize, read, write, ioctl)
• Connects hardware driver to FatFS middleware
• Parameter checking and status reporting

• Mount/Unmount - Filesystem detection and mounting
• Auto-format - Detects unformatted cards and formats them (512/4096-byte fallback)
• File Operations - Create, write, append, read, delete, rename
• Directory Operations - Create folders, recursive listing with sizes
• Space Information - Get free and total space in KB
• CSV Parsing - Read and parse CSV files

Data is saved to saved_sensor_data.csv with the following format:

Entry,DS18B20_C,MPU6050_C,DHT11_C,DHT11_%,AX_g,AY_g,AZ_g,GX_dps,GY_dps,GZ_dps
1,24.50,25.34,25.3,56.2,0.123,-0.011,0.987,0.52,-0.18,0.09

🔗 View sd_spi.c - Low-Level Driver
🔗 View sd_diskio.c - FatFS Interface
🔗 View sd_functions.c - High-Level API
🔗 View sd_data_logger.c - Application Layer driver

The MPU6050 is an 6-axis inertial measurement unit (IMU) with an I2C interface (shared with LCD at address 0x68).

The driver provides two ways to read sensor data:

1. Raw Data: Direct 16-bit integer values from registers (±32768 range)
2. Scaled Data: Converted to physical units using sensitivity factors

Implementation:

• Burst read of all 14 data bytes in a single I2C transaction
• Data stored in global structure for access by other tasks
• Data Flow: I2C Read (0x3B-0x48) → 14 bytes → Store raw values → Scale for display

🔗 View MPU6050 Driver Source Code

Note: LCD display and SD Card logging use scaled values in physical units. Raw 16-bit values are stored in seperate structure and could be extracted if necessary.

The DHT11 uses a single-wire protocol with precise timing:

Instead of measuring pulse width, I used a simpler approach looking at datasheet:

For each bit:

1. Wait for line to go HIGH
2. Delay exactly 40µs
3. If line still HIGH → logic 1
   If line is LOW → logic 0

To ensure the timing is not interrupted, interrupts are disabled while communicating with the sensor. The checksum provided by the sensor is used to verify data integrity.

🔗 View DHT11 Driver Source Code

The DS18B20 uses the 1-Wire protocol with precise timing:

Instead of complex state machines, the driver uses direct bit-banging with microsecond delays.

Temperature Read Sequence:

1. Send reset pulse (500µs) and wait for presence
2. Send Skip ROM command (0xCC)
3. Send Read Scratchpad command (0xBE)
4. Read 2 bytes of temperature data (LSB first)
5. Calculate: temperature = raw_12bit × 0.0625°C

🔗 View DS18B20 Driver Source Code

Note: The sensor is read at 1Hz frequency to accommodate the 750ms conversion time. The driver automatically starts a new conversion after each read.

1. Clone the repository

git clone https://github.com/rubin-khadka/STM32_MultiSensor_MicroSD_Datalogger.git

2. Open this project in STM32CubeIDE:

   • File → Open Projects from File System...
   • Select the cloned directory
   • Click Finish

3. Build & Flash

   • Build: Ctrl+B
   • Debug: F11
   • Run: F8 (Resume)

• STM32_MultiSensor_FlashStorage - Similar project but with W25Q64 Flash storage instead of MicroSD card
• STM32_DHT11_MPU6050_LCD - Sensor display project with DHT11 and MPU6050 on LCD and UART
• STM32_DHT11_UART_BareMetal - Basic DHT11 sensor reading with UART output using bare metal programming
• STM32_DHT11_LCD16x2 - DHT11 sensor data displayed on 16x2 LCD character display using HAL

• STM32F103 Datasheet
• STM32F103 Reference Manual
• DHT11 Sensor Datasheet
• DS18B20 Temperature Sensor Datasheet
• MPU6050 Sensor Datasheet
• PCF8574 I2C Backpack Datasheet

• Status: Complete
• Version: v1.0
• Last Updated: March 2026

Rubin Khadka Chhetri
📧 [email protected]
🐙 GitHub: https://github.com/rubin-khadka