STM32F103 Blue Pill ADC Overview and Examples

The STM32F103 Blue Pill features an ADC (Analog-to-Digital Converter) that allows conversion of an analog signal to a digital value. This is essential for reading analog sensors and other analog input devices.

More information on Successive Approximation Conversion

Key Features of STM32 ADC

• Resolution: 12-bit, providing values from 0 to 4095.
• Speed: Capable of conversion rates up to several million samples per second.
• Channels: Multiple channels available, each connected to different analog pins.
• Modes: Supports single conversion, continuous conversion, and discontinuous conversion modes.
• DMA Support: Enables automatic data transfer to memory without CPU involvement.

ADC Example Code (Arduino C with Maple Library)

This example demonstrates how to configure and use the ADC on the STM32F103 Blue Pill to read analog values.

// Example code to read ADC value on STM32F103 Blue Pill using Arduino C and Maple Library

#include <Wire.h>       // For I2C communication (if needed)
#include <MapleFree>    // Maple library for STM32F103

void setup() {
    Serial.begin(115200);    // Start serial communication at 115200 baud
    analogReadResolution(12); // Set ADC resolution to 12 bits (0-4095)
    analogReadA0();          // Initialize ADC on A0 pin
}

void loop() {
    int adcValue = analogRead(A0); // Read ADC value from pin A0
    Serial.print("ADC Value: ");
    Serial.println(adcValue);      // Print the ADC value to the Serial Monitor
    delay(1000);                   // Wait for 1 second before reading again
}

ADC with DMA Example Code (Arduino C with Maple Library)

This example shows how to use DMA with the ADC to continuously sample data and store it in a buffer.

// Example code to use ADC with DMA on STM32F103 Blue Pill using Arduino C and Maple Library

#include <Wire.h>       // For I2C communication (if needed)
#include <libmaple/dma.h>
#include <libmaple/adc.h>

#define BUFFER_SIZE 100
volatile uint16_t adcBuffer[BUFFER_SIZE]; // Buffer to store ADC values

void setup() {
    Serial.begin(115200);      // Start serial communication at 115200 baud
    analogReadResolution(12);  // Set ADC resolution to 12 bits (0-4095)
    analogRead(A0);            // Initialize ADC on A0 pin

    DMA1_Channel1->CCR |= DMA_CCR_EN;           // Enable DMA channel 1
    DMA1_Channel1->CNDTR = BUFFER_SIZE;         // Set number of data items to transfer
    DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR;  // Peripheral address (ADC data register)
    DMA1_Channel1->CMAR = (uint32_t)adcBuffer;  // Memory address (ADC buffer)
}

void loop() {
    // Print ADC buffer contents
    for (int i = 0; i < BUFFER_SIZE; i++) {
        Serial.print("Buffer[");
        Serial.print(i);
        Serial.print("]: ");
        Serial.println(adcBuffer[i]);
    }
    delay(1000); // Wait for 1 second before printing again
}
  

STM32 I2C Communication

I2C (Inter-Integrated Circuit) is a popular communication protocol that allows multiple devices to communicate over a two-wire bus. One device acts as the master, while the others are slaves. This guide demonstrates how to set up I2C communication on STM32 microcontrollers using the STM32duino library, with examples for both master and slave configurations.

Key Concepts

• I2C Bus: Consists of two wires: SDA (data line) and SCL (clock line). The master device controls the clock and initiates communication, while slave devices respond to the master's requests.
• Addressing: Each I2C device on the bus has a unique address. The master uses this address to communicate with specific slaves.
• Data Transfer: Data is transferred in bytes, with each byte being acknowledged by the receiver.

Master Example Code

This example demonstrates how to configure an STM32 microcontroller as an I2C master, send data to a slave device, and receive data from it.

Basic I2C Example (Master Mode):

#include <Wire.h>

    #define SLAVE_ADDRESS 0x3C  // I2C slave address
    
    void setup() {
        Wire.begin();            // Initialize I2C as master
        Serial.begin(115200);   // Initialize serial communication
    }
    
    void loop() {
        Wire.beginTransmission(SLAVE_ADDRESS); // Begin communication with the slave
        Wire.write("Hello Slave");             // Send data to the slave
        Wire.endTransmission();                // End transmission
    
        delay(500); // Wait for 500 ms
    
        Wire.requestFrom(SLAVE_ADDRESS, 1);    // Request 1 byte of data from the slave
        if (Wire.available()) {
            char c = Wire.read();              // Read the received byte
            Serial.print("Received from slave: ");
            Serial.println(c);
        }
    
        delay(1000); // Wait for 1 second
    }
    

Slave Example Code

This example demonstrates how to configure an STM32 microcontroller as an I2C slave, respond to requests from a master, and send data to it.

// STM32 I2C Slave Example

#include <Wire.h>

#define SLAVE_ADDRESS 0x3C  // I2C slave address

void setup() {
    Wire.begin(SLAVE_ADDRESS);  // Initialize I2C as slave
    Wire.onReceive(receiveData); // Register receive event handler
    Wire.onRequest(sendData);   // Register request event handler
    Serial.begin(115200);       // Initialize serial communication
}

void loop() {
    // Main loop does nothing, all actions are handled by the event handlers
}

void receiveData(int numBytes) {
    while (Wire.available()) {
        char c = Wire.read();     // Read received data
        Serial.print("Received: ");
        Serial.println(c);
    }
}

void sendData() {
    Wire.write('A');            // Send data to the master
}

Steps to Test I2C Communication

1. Connect Devices: Connect the master and slave STM32 boards together using the SDA and SCL lines. Ensure you have pull-up resistors on both lines (typically 4.7kΩ to 10kΩ).
2. Select Board: In the Arduino IDE, go to Tools > Board and select the appropriate STM32 board for both master and slave.
3. Select Port: Choose the COM port assigned to each STM32 board in the Arduino IDE.
4. Upload Code: Upload the master code to one STM32 board and the slave code to the other.
5. Monitor Communication: Open the Serial Monitor for the master board to view transmitted and received data.

STM32 CAN Bus Example

The Controller Area Network (CAN) bus is a robust vehicle bus standard designed to facilitate communication among various in-vehicle systems without a host computer. STM32 microcontrollers feature integrated CAN controllers for implementing CAN bus communication.

Key Concepts

• CAN Bus: A multi-master, message-oriented protocol that supports real-time data exchange between devices on a network.
• STM32 CAN Controller: Integrated CAN controllers available in STM32 microcontrollers that handle CAN bus communication.
• Configuration: CAN bus configuration includes setting up the CAN peripheral, filters, and message handling routines.

Example Code

This example demonstrates how to set up CAN communication on an STM32 microcontroller using the STM32duino library. It includes code for sending and receiving CAN messages.

// CAN Bus example for STM32 using STM32duino library

<STM32CAN>

CAN can1(CAN1);  // Create CAN object for CAN1 peripheral

void setup() {
    Serial.begin(115200);  // Initialize serial communication
    can1.begin(500E3);     // Initialize CAN1 with 500 kbps bitrate

    // Set up CAN filter to receive all messages
    can1.filter(0, 0xFFFFFFFF, CAN_FILTER_32BIT);
}

void loop() {
    // Check if a CAN message has been received
    if (can1.available()) {
        CANMessage msg;
        can1.read(msg);  // Read the received CAN message
        Serial.print("Received CAN Message: ID = ");
        Serial.print(msg.id, HEX);
        Serial.print(", Data = ");
        for (int i = 0; i < msg.len; i++) {
            Serial.print(msg.data[i], HEX);
            Serial.print(" ");
        }
        Serial.println();
    }

    // Create and send a CAN message every second
    CANMessage txMsg;
    txMsg.id = 0x123;     // CAN ID
    txMsg.len = 8;        // Length of data
    for (int i = 0; i < 8; i++) {
        txMsg.data[i] = i; // Fill data with incremental values
    }
    can1.write(txMsg);  // Send CAN message

    delay(1000);        // Wait for 1 second
}

Steps to Test CAN Bus Communication

1. Connect STM32: Connect your STM32 board to your PC using a USB cable.
2. CAN Transceiver: Ensure you have a CAN transceiver connected to the STM32 CAN pins (e.g., MCP2551) and connected to a CAN bus network.
3. Select Board: In the Arduino IDE, go to Tools > Board and select your STM32 board (e.g., Blue Pill F103C8).
4. Select Port: Go to Tools > Port and select the COM port associated with your STM32 board.
5. Upload Code: Upload the example code to your STM32 board.
6. Monitor CAN Bus: Use a CAN bus analyzer or another STM32 board configured to receive CAN messages to observe communication on the CAN bus.

STM32 SPI Communication

The SPI (Serial Peripheral Interface) bus is a synchronous serial communication protocol used for short-distance communication in embedded systems. It uses four lines: MISO (Master In Slave Out), MOSI (Master Out Slave In), SCK (Serial Clock), and SS (Slave Select). This guide provides examples of SPI communication with an STM32 microcontroller acting as both a master and a slave.

Key Concepts

• Synchronous Communication: SPI is a synchronous protocol, meaning data transmission is synchronized with a clock signal generated by the master device.
• Lines: SPI uses four main lines: MOSI (data line from master to slave), MISO (data line from slave to master), SCK (clock line), and SS (chip select line).
• Data Transfer: Data is transferred in full-duplex mode, allowing simultaneous sending and receiving of data.

Master Example Code

This example demonstrates how to configure an STM32 microcontroller as an SPI master. It sends and receives data to/from a slave device.

// STM32 SPI Master Example

#include <SPI.h>

void setup() {
    Serial.begin(115200); // Initialize serial communication
    SPI.begin();          // Initialize SPI as master
    SPI.setClockDivider(SPI_CLOCK_DIV8); // Set SPI clock speed
    SPI.setDataMode(SPI_MODE0); // Set SPI mode
    SPI.setBitOrder(MSBFIRST); // Set bit order
}

void loop() {
    byte dataToSend = 0xA5; // Example data to send
    byte receivedData;
    
    digitalWrite(SS, LOW);  // Select the slave device
    receivedData = SPI.transfer(dataToSend); // Send and receive data
    digitalWrite(SS, HIGH); // Deselect the slave device

    Serial.print("Sent: 0x");
    Serial.print(dataToSend, HEX);
    Serial.print(" Received: 0x");
    Serial.println(receivedData, HEX);

    delay(1000); // Wait for 1 second
}

    

SPI Slave Code

// STM32 SPI Slave Example

#include <SPI.h>

volatile byte dataToSend = 0x5A; // Data to send to the master

void setup() {
    Serial.begin(115200); // Initialize serial communication
    SPI.begin();          // Initialize SPI as slave
    SPI.setClockDivider(SPI_CLOCK_DIV8); // Set SPI clock speed (should match master)
    SPI.setDataMode(SPI_MODE0); // Set SPI mode (should match master)
    SPI.setBitOrder(MSBFIRST); // Set bit order (should match master)
    SPI.usingInterrupt(); // Enable interrupts for SPI
    attachInterrupt(digitalPinToInterrupt(MISO), onSPIReceive, FALLING); // Attach SPI receive interrupt
}

void loop() {
    // Main loop does nothing, all actions are handled by interrupts
}

void onSPIReceive() {
    if (SPI.available()) {
        byte receivedData = SPI.transfer(0x00); // Read received data
        Serial.print("Received: 0x");
        Serial.println(receivedData, HEX);
        // Respond with data
        SPI.transfer(dataToSend);
    }
}

    

STM32 Timers Using Arduino - Detailed Description

Understanding Timers in Microcontrollers (MCUs) like STM32

Timers are one of the most versatile peripherals found in MCUs, including the popular STM32 series. They are essential for various time-based functions such as generating precise delays, handling real-time events, and generating pulse-width modulation (PWM) signals. STM32 timers offer advanced features beyond basic timekeeping, making them critical in embedded systems.

Basic Concepts of Timers

A timer is essentially a counter that increments or decrements at a specific clock rate, and when it reaches a defined value, it triggers an event. Timers operate using the system clock or an external clock source, and their main purpose is to measure time or generate periodic interrupts. Timers in STM32 MCUs are usually highly configurable and have multiple modes to suit different use cases.

Types of Timers in STM32

STM32 microcontrollers typically feature several types of timers, categorized as:

• Basic Timers: Used primarily for time delay generation and basic event counting. These timers do not have advanced features like PWM or input capture.
• General-Purpose Timers: Capable of PWM generation, input capture, output compare, and many more advanced features. These are versatile and support multiple channels for parallel operations.
• Advanced-Control Timers: Typically used for motor control applications. These offer more advanced features such as dead-time insertion and break input handling.

Timer Registers

Timers are controlled using several registers, which dictate how they count, compare values, and trigger interrupts or other events. Some of the key registers used in STM32 timers are:

• CR1: Control register 1. Configures basic functionality such as counter direction, auto-reload, and update behavior.
• CNT: Counter register. Stores the current count value of the timer.
• PSC: Prescaler register. Divides the clock frequency to control the counting speed.
• ARR: Auto-reload register. Specifies the value at which the timer resets (or reloads) and can trigger an event.
• CCR1-CCR4: Capture/Compare registers. Used in PWM mode or input capture mode to store values for comparison or capture purposes.
• EGR: Event generation register. Used to manually trigger events like updates, compare matches, etc.

STM32 microcontrollers, when programmed using the Arduino framework, offer powerful and flexible timers that can be used for a variety of applications.

STM32 timers are essential for time-based operations such as generating PWM signals, creating time delays, and counting events. When using STM32 with the Arduino IDE, you can take advantage of the hardware timers provided by the STM32 microcontroller to accomplish these tasks efficiently.

Interrupts: Timers can generate interrupts to execute specific actions at set intervals.

Examples of Using STM32 Timers with Arduino

1. Basic Timer Example

This example demonstrates how to use a basic timer to create a time delay.

// STM32 Basic Timer Example

<Arduino>

void setup() {
    // Initialize the serial communication
    Serial.begin(115200);

    // Initialize Timer6
    Timer6.init();
    Timer6.setPeriod(1000); // Set period to 1000 milliseconds
    Timer6.attachInterrupt(timerCallback);
}

void loop() {
    // Main loop does nothing
}

// Timer interrupt callback function
void timerCallback() {
    Serial.println("Timer event occurred");
}
    

2. PWM Signal Generation

This example demonstrates how to use a general-purpose timer to generate a PWM signal on a specific pin.

// STM32 PWM Example

<Arduino>

void setup() {
    // Initialize the serial communication
    Serial.begin(115200);

    // Initialize Timer2 for PWM on pin D9
    Timer2.setMode(PWM, D9);
    Timer2.setPWM(D9, 1000, 512); // 1 kHz frequency, 50% duty cycle
}

void loop() {
    // Main loop does nothing
}
    

3. Timer with Input Capture

This example shows how to use a general-purpose timer to capture the input signal on a pin.

// STM32 Timer Input Capture Example

<Arduino>

volatile uint32_t captureValue = 0;

void setup() {
    // Initialize the serial communication
    Serial.begin(115200);

    // Initialize Timer2 for input capture
    Timer2.setMode(INPUT_CAPTURE, D3); // Assuming input signal is on pin D3
    Timer2.attachInterrupt(inputCaptureCallback);
}

void loop() {
    // Print captured value
    Serial.println(captureValue);
    delay(1000);
}

// Timer input capture callback function
void inputCaptureCallback() {
    captureValue = Timer2.getCapture();
}
    

Timers as triggers for DMA and peripherals

Triggers for timers

STM32 Blue Pill - Serial Ports Example

The STM32 Blue Pill has three hardware serial ports: Serial, Serial1, and Serial2. This example demonstrates how to configure and use all three serial ports to communicate simultaneously.

In this code, we configure Serial(USB serial interface), Serial1(PA9 - TX, PA10 - RX), and Serial2(PB10 - TX, PB11 - RX) to transmit and receive data.

Code Example

/*
 * STM32 Blue Pill - Using All Three Serial Ports
 * Serial: USB Serial (Communication with PC)
 * Serial1: PA9 (TX) and PA10 (RX)
 * Serial2: PB10 (TX) and PB11 (RX)
 */

void setup() {
    // Initialize all three serial ports
    Serial.begin(115200);   // USB Serial communication (e.g., to Serial Monitor)
    Serial1.begin(115200);  // Hardware serial 1 (PA9 - TX, PA10 - RX)
    Serial2.begin(115200);    // Hardware serial 2 (PB10 - TX, PB11 - RX)

    // Print messages to show initialization
    Serial.println("USB Serial initialized");
    Serial1.println("Serial1 initialized");
    Serial2.println("Serial2 initialized");
}

void loop() {
    // Check if data is available from USB Serial
    if (Serial.available()) {
        char inByte = Serial.read();
        // Echo received data to Serial1 and Serial2
        Serial1.print("Received from USB Serial: ");
        Serial1.println(inByte);
        Serial2.print("Received from USB Serial: ");
        Serial2.println(inByte);
    }

    // Check if data is available from Serial1
    if (Serial1.available()) {
        char inByte = Serial1.read();
        // Echo received data to USB Serial and Serial2
        Serial.print("Received from Serial1: ");
        Serial.println(inByte);
        Serial2.print("Received from Serial1: ");
        Serial2.println(inByte);
    }

    // Check if data is available from Serial2
    if (Serial2.available()) {
        char inByte = Serial2.read();
        // Echo received data to USB Serial and Serial1
        Serial.print("Received from Serial2: ");
        Serial.println(inByte);
        Serial1.print("Received from Serial2: ");
        Serial1.println(inByte);
    }

    // Add a small delay to avoid flooding the serial ports
    delay(100);
    

Explanation

• Serial is used to communicate via the USB interface with the computer, such as the Serial Monitor in the Arduino IDE.
• Serial1 uses the STM32 hardware UART (USART1), which is connected to pins PA9 (TX) and PA10 (RX).
• Serial2 uses the STM32 hardware UART (USART2), connected to pins PB10 (TX) and PB11 (RX).

The code reads any available data from one serial port and echoes it to the others, allowing communication between devices connected to the different serial ports. This is useful in applications where you need to communicate with multiple devices simultaneously.

Note: When uploading this code, make sure to configure the STM32 board settings in the Arduino IDE, including selecting the correct port and upload method (usually "STM32duino bootloader" or "Serial").

STM32 Interrupt Examples

This guide demonstrates how to configure interrupts for different peripherals on STM32 microcontrollers. Interrupts are useful for handling asynchronous events, and they improve the efficiency of the system by responding only when required. Below are examples for external interrupts, timers, I2C, SPI, serial, CAN, RTC, and USB.

External Interrupt Example

This example shows how to configure an external interrupt using a push button on a specific pin.

//STM32 External Interrupt Example

void setup() {
    pinMode(PA0, INPUT); // Set pin PA0 as input (Button)
    attachInterrupt(digitalPinToInterrupt(PA0), handleButtonPress, FALLING); // Attach interrupt to PA0
}

void loop() {
    // Main code can run here, interrupt will trigger on button press
}

void handleButtonPress() {
    // Code to run when button is pressed
    Serial.println("Button Pressed!");
}    

Serial UART Interrupt Example

// STM32 Serial UART Interrupt Example

void setup() {
    Serial.begin(115200);      // Initialize serial communication
    attachInterrupt(digitalPinToInterrupt(PA9), onSerialReceive, RISING); // Attach interrupt to PA9 (TX pin)
}

void loop() {
    // Main code here
}

void onSerialReceive() {
    if (Serial.available()) {
        char c = Serial.read(); // Read the incoming data
        Serial.print("Received: ");
        Serial.println(c);
    }
}

I2C Interrupt Example

// STM32 I2C Interrupt Example

#include <Wire.h>

void setup() {
    Wire.begin();           // Initialize I2C as master
    Wire.onReceive(onI2CReceive);  // Attach interrupt for data reception
}

void loop() {
    // Main code here
}

void onI2CReceive(int numBytes) {
    while (Wire.available()) {
        char c = Wire.read(); // Read received data
        Serial.print("Received: ");
        Serial.println(c);
    }
}

SPI Interrupt Example

// STM32 SPI Interrupt Example

#include <SPI.h>

void setup() {
    SPI.begin();            // Initialize SPI as master
    attachInterrupt(digitalPinToInterrupt(MISO), onSPIReceive, FALLING); // Attach interrupt to MISO pin
}

void loop() {
    // Main code here
}

void onSPIReceive() {
    // Handle SPI data reception
    byte receivedData = SPI.transfer(0x00); // Read received data
    Serial.print("Received: ");
    Serial.println(receivedData, HEX);
}

CAN Interrupt Example

// TM32 CAN Interrupt Example

<STM32CAN>

CAN_message_t message;

void setup() {
    CAN.begin();            // Initialize CAN bus
    attachInterrupt(digitalPinToInterrupt(PB8), onCANReceive, FALLING); // Attach interrupt to CAN RX pin
}

void loop() {
    // Main code here
}

void onCANReceive() {
    if (CAN.available()) {
        CAN.read(message); // Read incoming CAN message
        Serial.print("CAN Message: ");
        Serial.println(message.id, HEX);
    }
}

ADC Interrupt Example

// STM32 ADC Interrupt Example

<ADC>

volatile uint16_t adcValue = 0;

void setup() {
    Serial.begin(115200);  // Initialize serial communication
    ADC_Init(ADC1);        // Initialize ADC1
    ADC_AttachInterrupt(ADC1, onADCComplete); // Attach ADC interrupt
    ADC_Start(ADC1);       // Start ADC conversion
}

void loop() {
    // Main code can run here, interrupt will handle ADC conversions
}

void onADCComplete() {
    adcValue = ADC_Read(ADC1);  // Read ADC value
    Serial.print("ADC Value: ");
    Serial.println(adcValue);
}

Timer Interrupt Example

// STM32 Timer Interrupt Example

HardwareTimer timer(TIM1);

void setup() {
    Serial.begin(115200);     // Initialize serial communication
    timer.pause();            // Pause the timer before setting it up
    timer.setPeriod(1000000); // Set timer period to 1 second (1,000,000 µs)
    timer.attachInterrupt(onTimerInterrupt); // Attach interrupt handler
    timer.resume();           // Start the timer
}

void loop() {
    // Main code runs here
}

void onTimerInterrupt() {
    Serial.println("Timer Interrupt Triggered!");
}

STM32 RTC with Alarm Example

The Real-Time Clock (RTC) on STM32 microcontrollers is a peripheral that provides calendar and clock functionality. It keeps track of the time and date, even when the microcontroller is powered off (if a backup battery is connected). In this example, we will configure the RTC and set up an alarm that will trigger an event when a specific time is reached.

Features

• Set up the RTC to keep track of time (hours, minutes, and seconds).
• Configure an alarm to trigger at a specific time.
• Use an interrupt to handle the alarm event.

RTC with Alarm Example Code

    
// STM32 RTC with Alarm Example
#include <Wire.h>   // Optional if using external RTC modules
#include <RTClock>

// RTC object using LSI (Low Speed Internal) clock
RTClock rtc(RTCSEL_LSI);

// Callback function for alarm interrupt
void alarmCallback() {
    Serial.println("Alarm Triggered!");
}

void setup() {
    Serial.begin(115200);  // Initialize serial communication

    // Initialize RTC
    rtc.begin();  // Start RTC with internal LSI oscillator

    // Set time: hours, minutes, seconds
    rtc.setTime(12, 30, 0);  // 12:30:00 PM

    // Set date: day, month, year
    rtc.setDate(1, 1, 2024);  // January 1st, 2024

    // Display the current time and date
    printTimeAndDate();

    // Set alarm: Set to trigger at 12:31:00
    rtc.setAlarmTime(12, 31, 0);  // 12:31:00 PM
    rtc.attachInterrupt(alarmCallback);  // Attach alarm interrupt

    // Enable alarm
    rtc.enableAlarm();
}

void loop() {
    // Continuously print the time every second
    printTimeAndDate();
    delay(1000);  // 1 second delay
}

// Function to print current time and date
void printTimeAndDate() {
    // Get current time
    int hour = rtc.getHours();
    int minute = rtc.getMinutes();
    int second = rtc.getSeconds();

    // Get current date
    int day = rtc.getDay();
    int month = rtc.getMonth();
    int year = rtc.getYear();

    // Print time and date to Serial Monitor
    Serial.print("Current Time: ");
    Serial.print(hour); Serial.print(":");
    Serial.print(minute); Serial.print(":");
    Serial.println(second);

    Serial.print("Current Date: ");
    Serial.print(day); Serial.print("/");
    Serial.print(month); Serial.print("/");
    Serial.println(year);
}

Explanation of the Code

In this example, the STM32's built-in RTC is configured to keep track of the current time and date. We also set an alarm to trigger at a specific time (12:31:00 in this case). When the alarm time is reached, an interrupt is triggered, and the callback function alarmCallback()is executed, printing "Alarm Triggered!" to the Serial Monitor.

Key Functions:

• rtc.begin(): Initializes the RTC using the LSI clock.
• rtc.setTime(hour, minute, second): Sets the current time on the RTC.
• rtc.setDate(day, month, year): Sets the current date on the RTC.
• rtc.setAlarmTime(hour, minute, second): Configures the alarm time.
• rtc.attachInterrupt(callback): Attaches the callback function that will be called when the alarm is triggered.

USB on STM32 Microcontrollers - Detailed Description

The Universal Serial Bus (USB) is a widely used interface for communication between devices and host systems. STM32 microcontrollers come with built-in USB peripherals that allow them to act as a USB device or even a USB host, enabling flexible applications like USB mass storage, virtual COM ports (CDC), HID devices (mouse/keyboard), and more. This guide provides a detailed description of the USB architecture, features, and typical uses on STM32 microcontrollers.

USB Features on STM32

• USB Device and Host Support: STM32 microcontrollers can operate as both USB devices and USB hosts, depending on the specific series (e.g., STM32F1, STM32F4, STM32H7).
• Full-Speed (FS) and High-Speed (HS) Support: STM32 supports USB 2.0 Full-Speed (12 Mbps) and, in certain models, USB 2.0 High-Speed (480 Mbps) communication.
• Peripheral Modes: STM32 can be configured as various types of USB devices, such as Mass Storage Device (MSC), Communication Device Class (CDC), Human Interface Device (HID), and more.
• USB OTG (On-The-Go): STM32 devices with OTG support can switch between device and host roles dynamically.
• USB Power Management: STM32 manages power for USB devices, including handling VBUS detection and control.
• Support for USB Libraries: STM32 provides support for the USB Device Library, USB Host Library, and USB OTG Middleware, simplifying USB application development.

USB Architecture on STM32

STM32 microcontrollers with USB support have dedicated USB peripherals, which handle the low-level protocol and electrical interface. The USB controller communicates with the microcontroller’s core through a set of registers and interrupts. Depending on the USB mode (device or host), different USB-related endpoints and functions are enabled.

USB Device Mode

In device mode, the STM32 acts as a USB peripheral, communicating with a host system (such as a PC). Common applications of STM32 in USB device mode include:

• CDC (Communications Device Class): Used to create virtual COM ports for serial communication over USB, replacing traditional RS-232 ports.
• MSC (Mass Storage Class): Used to emulate a USB flash drive or external storage device, allowing data transfer between the STM32 and a host.
• HID (Human Interface Device): Used to create devices like USB mice, keyboards, or game controllers.

USB Host Mode

In host mode, the STM32 acts as the master, controlling USB peripherals connected to it. For example, it can read data from a USB flash drive or communicate with a USB keyboard. Some STM32 devices, such as those with OTG (On-The-Go) support, can switch dynamically between host and device roles.

USB OTG (On-The-Go)

STM32 microcontrollers with USB OTG support can operate as either a USB device or a USB host. OTG allows dynamic role switching based on the connected device. For example, an STM32 OTG-enabled microcontroller can connect to a PC as a device or control a USB flash drive as a host.

USB Data Transfer Types

USB communication consists of four main types of data transfer:

• Control Transfers: Used for sending control information, such as device setup requests. Control transfers are essential for device enumeration and configuration.
• Bulk Transfers: Used for large amounts of data without strict timing requirements, such as file transfers in USB mass storage devices.
• Interrupt Transfers: Used for sending small amounts of data with guaranteed latency, often used in HID devices like keyboards or mice.
• Isochronous Transfers: Used for time-critical data such as audio or video streaming, where data must be delivered at regular intervals.

Common STM32 USB Applications

STM32 microcontrollers are commonly used in a wide range of USB applications, such as:

• Virtual COM Ports: Using the CDC class, STM32 can replace RS-232 serial ports, providing serial communication over USB.
• USB Mass Storage Devices: STM32 can act as a USB flash drive or external storage, enabling data transfer between the MCU and a host computer.
• Human Interface Devices (HID): STM32 can be configured as a USB keyboard, mouse, joystick, or other input devices.
• USB Host for Flash Drives: STM32 can act as a host to communicate with USB storage devices, such as reading or writing data from a USB flash drive.

Example USB Setup on STM32

The following is an example of setting up USB communication on an STM32 microcontroller using the CDC (Communication Device Class) to emulate a virtual COM port:

// STM32 USB CDC (Virtual COM Port) Example

#include "usbd_core.h"
#include "usbd_cdc.h"
#include "usb_device.h"

// Function to initialize USB
void USB_Init(void) {
    MX_USB_DEVICE_Init(); // Initialize the USB device
}

// Main program loop
int main(void) {
    HAL_Init();            // Initialize the HAL Library
    SystemClock_Config();  // Configure the system clock

    // Initialize the USB device (CDC class for Virtual COM Port)
    USB_Init();

    while (1) {
        // Continuously process USB communication
        MX_USB_DEVICE_Process();
    }
}

// Example function for sending data over USB CDC
void CDC_TransmitData(uint8_t* data, uint16_t length) {
    CDC_Transmit_FS(data, length);  // Send data to the host via USB
}

        

Steps to Implement USB on STM32

1. Configure the USB Peripheral: In STM32CubeMX, enable the USB peripheral and configure it for the desired USB mode (Device or Host).
2. Select the USB Class: Choose the appropriate USB class (e.g., CDC for virtual COM port, MSC for mass storage) based on your application.
3. Generate Code: Generate the initialization code using STM32CubeMX, which will automatically set up the USB peripheral.
4. Modify the Application Code: Customize the application code to handle specific USB tasks, such as sending or receiving data.
5. Test the USB Connection: Connect the STM32 to a host system (e.g., a PC) and test the USB communication (e.g., using a terminal program for CDC devices).

Conclusion

USB is a powerful and versatile communication interface, and STM32 microcontrollers offer extensive support for USB peripherals, including device, host, and OTG modes. With STM32’s USB libraries and middleware, developers can easily integrate USB functionality into their projects, enabling applications like virtual COM ports, mass storage devices, HID devices, and more.

Understanding DMA (Direct Memory Access)

Direct Memory Access (DMA) is a feature used in microcontrollers and other computing systems to transfer data directly between peripherals and memory, bypassing the CPU. By offloading these data transfers to the DMA controller, the CPU can perform other tasks, significantly improving system performance, especially in real-time applications.

How DMA Works

In a typical embedded system without DMA, the CPU is responsible for reading data from a peripheral (e.g., an ADC, UART, or SPI) and writing it to memory, or vice versa. This process consumes significant CPU cycles, especially for high-frequency or large-volume data transfers. DMA automates these transfers by allowing peripherals to communicate directly with memory, reducing the CPU's involvement.

Basic DMA Operation

The DMA controller operates as a separate entity within the microcontroller, managing the data transfer between memory and peripherals. The following sequence outlines the basic operation of a DMA transfer:

1. Initialization: The CPU configures the DMA controller, specifying the source and destination addresses, the size of the data to be transferred, and the transfer mode.
2. Trigger: The DMA transfer is triggered by an event, such as a peripheral request (e.g., a timer, UART, or ADC) or a software trigger initiated by the CPU.
3. Transfer: Once triggered, the DMA controller reads the data from the source (peripheral or memory) and writes it to the destination (memory or peripheral), without CPU intervention.
4. Completion: After the transfer is complete, the DMA controller can generate an interrupt to notify the CPU, allowing the CPU to handle post-transfer processing if necessary.

DMA Transfer Modes

DMA supports several modes of operation, depending on the needs of the application:

• Normal Mode: The DMA controller transfers a specified number of data items, after which the transfer is completed, and no further transfers occur.
• Circular Mode: The DMA controller continuously transfers data in a circular buffer. This mode is ideal for real-time data streams, such as audio, video, or sensor data, where continuous data processing is required.
• Peripheral-to-Memory Mode: Data is transferred from a peripheral to memory (e.g., storing ADC data in RAM).
• Memory-to-Peripheral Mode: Data is transferred from memory to a peripheral (e.g., sending data from RAM to a UART for transmission).
• Memory-to-Memory Mode: The DMA controller can also transfer data between two memory regions, which is useful for fast data copying or rearrangement.

DMA Trigger Sources

DMA transfers can be triggered by a variety of sources, including:

• Peripheral Requests: Many peripherals can request a DMA transfer when data is ready to be sent or received (e.g., UART, SPI, ADC).
• Timer Events: Timers can trigger DMA transfers at specific intervals, ideal for time-sensitive data transfers.
• Software Triggers: The CPU can trigger DMA transfers directly using software commands.

Benefits of Using DMA

DMA provides several advantages over CPU-driven data transfers:

• Reduced CPU Load: The CPU is free to perform other tasks while the DMA controller handles data transfers.
• Higher Data Throughput: DMA allows high-speed, uninterrupted data transfers, crucial in applications like audio streaming, video processing, or real-time sensor data acquisition.
• Low Latency: DMA transfers occur with minimal latency, enabling more responsive systems, especially in real-time applications.

DMA Limitations

Despite its benefits, DMA has some limitations:

• Peripheral Compatibility: Not all peripherals are DMA-capable, so it’s essential to check whether the specific peripheral supports DMA.
• Memory Access Conflicts: While DMA is active, it competes with the CPU for access to the memory bus, which could impact system performance in memory-intensive applications.

Conclusion

DMA is an essential feature in embedded systems, offering improved data transfer efficiency, reduced CPU load, and enhanced real-time performance. By offloading data transfer tasks from the CPU to the DMA controller, system resources are optimized, allowing for more complex and responsive applications. Understanding how to configure and utilize DMA effectively is a key skill in embedded systems development.

STM32 Bluepill Pin DMA Matrix for STM32F103