STM32H743IIK6 Sensor Gateway with Ethernet Data Logging

Modern industrial equipment often has several independent data paths: analog sensors, digital sensors, local storage and an Ethernet connection to a supervisory computer.

A small microcontroller can handle one or two of these functions easily, but once high-rate sampling, data buffering, file storage and Ethernet communication are required simultaneously, memory bandwidth and CPU performance become important.

This project uses the STM32H743IIK6 as the central controller for a small industrial sensor gateway.

The MCU runs the application at up to 480 MHz and provides 2 MB of Flash and up to 1 MB of RAM. It also integrates a large collection of communication and analog peripherals.

The basic data flow is:

Sensors → STM32H743IIK6 → RAM buffer → microSD / Ethernet

The firmware periodically samples an analog sensor and reads a digital sensor through I²C or SPI. A timer controls the sampling interval so that acquisition is independent of Ethernet traffic.

The measurements are placed into a RAM buffer. A separate FreeRTOS task writes completed buffers to the microSD card using FatFs. Another task sends selected measurements through Ethernet using TCP or UDP.

This separation is useful because writing to an SD card can have unpredictable latency. Instead of stopping sensor acquisition while a file is being written, the MCU temporarily buffers samples in RAM.

For example, the system can generate a CSV file similar to:

timestamp_ms,temperature,analog_voltage,accel_x,accel_y,accel_z
1000,24.8,1.214,0.013,-0.021,1.002
1010,24.8,1.217,0.015,-0.019,1.001
1020,24.9,1.215,0.014,-0.020,1.004
1030,24.9,1.219,0.017,-0.018,1.003

At the same time, the Ethernet interface can expose a simple TCP or UDP data stream to a PC.

This makes the project useful for experimentation with:

• Industrial sensor monitoring
• Condition monitoring
• Vibration logging
• Laboratory data acquisition
• Embedded Ethernet
• Remote equipment monitoring
• MCU-to-PC data acquisition
• Edge data collection

The project also demonstrates an important STM32H7 design concept: using DMA and buffering to keep real-time acquisition running while the CPU handles communication and storage tasks.

The STM32H743 family includes several ADCs, DACs, timers, communication interfaces, Ethernet MAC, USB and SDMMC-related peripherals, providing enough hardware resources to expand the prototype considerably.

How the firmware is organized

A practical FreeRTOS architecture can use four main tasks:

+-----------------------+
                 |    STM32H743IIK6      |
                 |     Cortex-M7         |
                 +-----------+-----------+
                             |
              +--------------+--------------+
              |              |              |
          ADC/DMA         I2C/SPI       Ethernet
              |              |              |
              +------+-------+              |
                     |                      |
                 Sensor Buffer          Network Task
                     |
                Logging Task
                     |
                  FatFs
                     |
                  microSD

Task 1 — Sensor acquisition

A hardware timer triggers ADC conversion.

DMA transfers ADC results into RAM without requiring the CPU to process every sample individually.

Task 2 — Sensor processing

The firmware reads the digital sensor and combines its values with ADC measurements.

A timestamp is added to every measurement block.

Task 3 — Data logging

When a buffer reaches a defined size, the logging task writes the block to a CSV file on the microSD card.

Task 4 — Ethernet communication

The Ethernet task publishes the latest measurements to a PC or industrial gateway.

This architecture is particularly useful for demonstrating why a high-performance MCU such as the H743 is attractive for data-intensive embedded applications.

Schematics and circuit diagrams

I would provide the schematic as several functional blocks rather than putting the entire design on one crowded page.

1. MCU core

+3.3V
                           |
                  +--------+--------+
                  |                 |
              Decoupling        VDD pins
                  |                 |
                  +-------> STM32H743IIK6
                             |
                    +--------+--------+
                    |        |        |
                   SWD      RESET    BOOT
                    |        |        |
                 Debugger   Button   Strap

The STM32H743IIK6 should be wired according to ST's hardware-design recommendations, including the required supply decoupling, reset circuitry, clock circuitry and VCAP connections.

Because this is a UFBGA 176+25 package, the PCB layout should follow the ST datasheet and package-specific pin assignment rather than simply copying a schematic intended for the LQFP variant.

2. Ethernet interface

Here, we use a LAN8742A-CZ-TR.

STM32H743IIK6
       |
       | RMII
       |
       v
+---------------+
| Ethernet PHY  |
|   LAN8742A    |
+-------+-------+
        |
       TX/RX
        |
        v
+---------------+
| RJ45 +        |
| Magnetics     |
+---------------+
        |
      Ethernet

The H743 includes an integrated Ethernet MAC, while the external PHY provides the physical-layer interface.

3. microSD interface

STM32H743IIK6
      |
      | SDMMC
      |
      +----------------+
      |                |
     CLK              CMD
      |                |
     D0-D3             |
      |                |
      +-------+--------+
              |
        +-----v------+
        | microSD    |
        | connector  |
        +------------+

The SDMMC interface is used for high-level data logging, while FatFs provides the file-system layer.

4. Analog acquisition

Analog Sensor
     |
     | 0 - 3.3 V
     |
    RC Filter
     |
     v
STM32H743IIK6 ADC
     |
    DMA
     |
     v
RAM Buffer

A simple RC input filter can be added according to the bandwidth and source impedance of the actual sensor. The exact values should be selected from the sensor's electrical characteristics rather than treated as universal values.

5. Digital sensor

STM32H743IIK6
       |
      I2C
       |
       +----------+
       |          |
      SDA        SCL
       |          |
       +----+-----+
            |
       +----v-----+
       | Digital  |
       | Sensor   |
       +---------+

An SPI version can also be used when a higher sensor data rate is required.

Example firmware

The following is a realistic STM32CubeIDE/HAL-style C example showing the central data-acquisition concept. It is intentionally kept hardware-independent where the exact sensor and pin assignment would otherwise need to be invented.

#include "main.h"
#include <stdio.h>
#include <string.h>

#define ADC_BUFFER_SIZE    256
#define LOG_BUFFER_SIZE    32

extern ADC_HandleTypeDef hadc1;
extern UART_HandleTypeDef huart3;

volatile uint16_t adcBuffer[ADC_BUFFER_SIZE];
volatile uint8_t adcReady = 0;

typedef struct
{
    uint32_t timestamp_ms;
    uint16_t adc_value;
    float voltage;
} SensorSample;

SensorSample logBuffer[LOG_BUFFER_SIZE];

static uint32_t sampleIndex = 0;

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
    if (hadc->Instance == ADC1)
    {
        adcReady = 1;
    }
}

static float ADC_ToVoltage(uint16_t adc)
{
    return ((float)adc * 3.3f) / 65535.0f;
}

static void ProcessSamples(void)
{
    uint32_t i;

    for (i = 0; i < ADC_BUFFER_SIZE; i++)
    {
        uint32_t slot = sampleIndex % LOG_BUFFER_SIZE;

        logBuffer[slot].timestamp_ms = HAL_GetTick();
        logBuffer[slot].adc_value = adcBuffer[i];
        logBuffer[slot].voltage =
            ADC_ToVoltage(adcBuffer[i]);

        sampleIndex++;

        /*
         * A production implementation would signal
         * a FreeRTOS logging task here rather than
         * writing to the SD card from the ADC callback.
         */
    }
}

int main(void)
{
    HAL_Init();

    SystemClock_Config();

    MX_GPIO_Init();
    MX_ADC1_Init();
    MX_USART3_UART_Init();

    /*
     * Start ADC conversion using DMA.
     */
    HAL_ADC_Start_DMA(
        &hadc1,
        (uint32_t *)adcBuffer,
        ADC_BUFFER_SIZE
    );

    printf("STM32H743IIK6 Sensor Gateway\r\n");

    while (1)
    {
        if (adcReady)
        {
            adcReady = 0;

            ProcessSamples();

            printf(
                "ADC=%u Voltage=%.3f V\r\n",
                adcBuffer[0],
                ADC_ToVoltage(adcBuffer[0])
            );
        }
    }
}

For the complete implementation, I would extend this basic example into the following software structure:

Core/
 ├── Inc/
 │    ├── main.h
 │    ├── sensors.h
 │    ├── logger.h
 │    └── ethernet_app.h
 │
 └── Src/
      ├── main.c
      ├── sensors.c
      ├── logger.c
      └── ethernet_app.c

Middlewares/
 ├── FreeRTOS/
 ├── LwIP/
 └── FatFs/

The production version should use:

ADC + DMA
    ↓
Acquisition Buffer
    ↓
FreeRTOS Queue
    ↓
Logger Task ──────> FatFs ──────> microSD
    |
    └──────────────> Network Task ──────> LwIP ──────> Ethernet

That is a more useful demonstration of the H743 than simply blinking an LED, because it exercises several of the MCU's high-performance capabilities simultaneously.

Suggested project demonstration

1. Power-on

The status LED indicates that the STM32H743IIK6 has started successfully.

2. Sensor acquisition

Open the serial terminal and show ADC and sensor measurements arriving continuously.

3. Start logging

Press the logging button.

The firmware creates:

/data/session001.csv

on the microSD card.

4. Ethernet monitoring

Connect the board to a PC with Ethernet.

A small Python application receives the measurement stream and displays:

Temperature:     24.8 °C
Analog input:     1.217 V
Acceleration X:   0.014 g
Acceleration Y:  -0.020 g
Acceleration Z:   1.003 g

5. Verify local storage

Remove the microSD card and open the CSV file on a PC.

This gives you something concrete to reproduce: a complete embedded data path from sensor → DMA → RAM → SD card → Ethernet → PC.

Why this project fits STM32H743IIK6

The key point is not simply that the MCU is fast. The H743 combines a 480-MHz Cortex-M7, up to 2 MB Flash, 1 MB RAM, DSP/FPU capabilities and a large peripheral set. ST specifically lists Ethernet, USB, SDMMC, ADC/DAC, timers, FDCAN, SAI, SPI, I²C and other interfaces within this family.

The STM32H743I-EVAL reference platform also demonstrates a very similar combination of Ethernet, USB, CAN FD, audio, microSD, external memory and display peripherals, which supports the technical feasibility of this project architecture.