Here is an overview of the topics:<\/p>\n
- \n
- Board selection for this article<\/a><\/li>\n
- Hardware timer interrupts<\/a><\/li>\n
- Pulse Width Modulation (PWM)<\/a><\/li>\n
- Analog-to-digital converter (ADC)<\/a><\/li>\n
- Digital-to-analog converter (DAC)<\/a><\/li>\n
- External interrupts<\/a><\/li>\n
- I\u00b2C<\/a><\/li>\n
- SPI<\/a><\/li>\n
- HardwareSerial<\/a><\/li>\n
- SoftwareSerial<\/a><\/li>\n
- Independent Watchdog (IWDG)<\/a><\/li>\n
- Real Time Clock (RTC)<\/a><\/li>\n
- Low-power modes<\/a><\/li>\n
- Appendix – Extended RTC sketch<\/a><\/li>\n<\/ul>\n\n
Programming levels of the SM32 boards<\/h3>\n\n
Microcontrollers (MCUs) can be programmed at different levels of abstraction. In the case of STM32 MCUs, these are essentially <\/p>\n
- \n
- Register level (“Bare-Metal”, “Low-Level”)<\/strong>: You access the registers directly via structures and bit masks. This is very efficient, but the least portable. <\/li>\n
- CMSIS (Cortex Microcontroller Software Interface Standard)<\/strong>: Is specified by ARM and is supplied with ST. IRQ names and core functions, for example, are defined there. <\/li>\n
- ST-own abstractions<\/strong>:\n
- \n
- LL (Low-Layer)<\/strong>: Still close to the registers.<\/li>\n
- HAL (Hardware Abstraction Layer)<\/strong>: Higher abstraction, higher portability, but more overhead.<\/li>\n<\/ol>\n<\/li>\n
- Frameworks \/ cores<\/strong> for high-level development: This includes in particular the Arduino core board package from STM32duino, which I already used in the last article. HAL and LL are the basis for this but are “hidden” behind the Arduino-typical functions. <\/li>\n<\/ol>\n
This article is only about the high-level programming. However, as you will certainly come across terms such as HAL, LL or bare metal when dealing with the STM32 boards, I didn’t want to leave them unmentioned. <\/p>\n\n
Board selection for this article<\/h2>\n\n
Of course, I cannot discuss all STM32 boards here. Therefore, I have made the same selection as in the first part of the article:<\/p>\n
- \n
- The “BluePill” based on the STM32F103C8 <\/li>\n
- The “BlackPill” based on the STM32F411<\/li>\n
- The Nucleo-L432KC board, as a representative of a Nucleo-32 board<\/li>\n
- The Nucleo-F446RE board, as a representative of a Nucleo-64 board<\/li>\n
- The Arduino GIGA R1 WIFI, as an example of an STM32-based Arduino board<\/li>\n<\/ul>\n\n
The main focus is on the first three boards. <\/p>\n
And one more note in advance: When I refer to”the<\/em> Blackpill” or”the<\/em> BluePill” in this article, I am referring to the above-mentioned types. There are also different versions or fakes of these types. Therefore, your boards may behave differently in certain aspects than discussed here. <\/p>\n\n
Pinout of the boards discussed here<\/h3>\n\n
“BluePill” (STM32F103C8)<\/h4>\n\n
I took the pinout diagram for the BluePill shown below from this nice article<\/a> by Renzo Mischianti<\/a>. If you want to dive deeper into the specific features of the BluePill boards, I can highly recommend Renzo Mischianti’s articles. <\/p>\n\n
![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/STM32-STM32F1-STM32F103-STM32F103C8T6-pinout-low-resolution-1024x798.jpg\")
<\/a>Pinout Bluepill (STM32F103C8), courtesy of Renzo Mischianti<\/a> (respect copyright!)<\/figcaption><\/figure>\n\n Peculiarities of this BluePill board<\/strong>:<\/p>\n
- \n
- Some pins are 5-volt tolerant (green squares); others only tolerate 3.3 volts (red-brown squares).<\/li>\n
- The following applies to PC13, PC14, and PC15: \n
- \n
- These pins must not supply any current in the HIGH state, i.e., you can use the “HIGH” state as a logic output, but not operate an LED with it, for example.<\/li>\n
- In the LOW state, the pins may tolerate a maximum of 3 mA (the LED on PC13 is connected to 3.3 volts and lights up when PC13 is OUTPUT\/LOW).<\/li>\n
- They shall not work at a frequency higher than 2 MHz and shall not be loaded with more than 30 pF.<\/li>\n<\/ul>\n<\/li>\n
- The board can be operated via the 3.3-volt or 5-volt pins. VBAT only supplies power to the RTC and backup registers. <\/li>\n<\/ul>\n\n
“BlackPill” STM32F411<\/h4>\n\n
As with the BluePill, I also used Renzo Mischianti’s pinout for the BlackPill. If you want to delve even deeper into the details of the BlackPill boards, I recommend Renzo’s series of articles. This article<\/a> is a good starting point. <\/p>\n\n
![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/STM32-STM32F4-STM32F411-STM32F411CEU6-pinout-low-resolution-1024x591.jpg\")
<\/a>Pinout BlackPill (STM32F411), courtesy of Renzo Mischianti<\/a> (respect copyright!)<\/figcaption><\/figure>\n\n Peculiarities of this BlackPill board:<\/strong> The same restrictions and notes for the pins apply as for the BluePill board, but considerably more pins are 5-volt-tolerant.<\/p>\n\n
Pinout Nucleo-L432KC<\/h4>\n\n
The Nucleo-L432LC board attempts to achieve a certain compatibility with the Arduino Nano boards. The pinout largely matches the pin designations and functionalities. <\/p>\n\n
![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/nucleo_l432kc_pinout-1024x549.webp\")
<\/a>Pinout Nucleo-L432KC Board (own creation)<\/figcaption><\/figure>\n\n Peculiarities of the Nucleo-L432KC<\/strong>:<\/p>\n
- \n
- The GPIOs are only compatible with 3.3 volts.<\/li>\n
- Pins D7 and D8 are not connected to anything. I will come back to this in the solder bridges section below. <\/li>\n
- You can use the “3.3V” and “5V” pins to supply other components with power. The maximum permissible current depends on the type of power supply of the board. See the UM1956<\/a> user manual. <\/li>\n
- To supply the board via the 3.3V and 5V pins, you must change the configuration of the solder bridges SBxy<\/em> (see below).<\/li>\n
- You can supply the board with 7 to 12 volts via VIN.<\/li>\n<\/ul>\n\n
Pinout Nucleo-F446RE and Arduino GIGA R1 WIFI<\/h4>\n\n
You can find a pinout diagram of the Nucleo-F446RE here<\/a>. A total of 50 GPIOs are available with this board. You can find a pinout diagram of the Arduino GIGA R1 WIFI here<\/a> on the Arduino pages. This board even has a whopping 76 GPIOs. <\/p>\n\n
![\"STM32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/arduino_giga-1024x370.webp\")
<\/a>Nucleo-F446RE and Arduino GIGA R1 WIFI<\/figcaption><\/figure>\n\n Solder bridges of the Nucleo boards<\/h3>\n\n
If you look at the Nucleo-L432KC board (or other Nucleo boards), you will see many solder bridges labeled “SBxy<\/em>“. Some of them are open, the others are closed via 0 \u03a9 resistors. A detailed description of the solder bridges of the Nucleo-32 boards can be found in UM1956<\/a> mentioned above. Here are some selected settings: <\/p>\n
- \n
- To supply the board with power via the 3.3-volt pin, SB9 and SB14 must be open. As a restriction, the board-internal ST-LINK is then not available. <\/li>\n
- To supply the board via the 5-volt pin, SB9 must be open. The board-internal ST-LINK is then not available. The supply via the 5-volt pin and debugging via ST-LINK can be combined, but then a certain procedure must be followed (see UM1956 again). <\/li>\n
- If you want to use pins D7 and D8 as GPIOs (PC14\/PC15), then SB4, SB5, SB7 and SB17 must be open; SB6 and SB8 must be closed. However, you will then no longer be able to use the external crystal for the RTC. <\/li>\n<\/ul>\n
As you can see, it’s quite complex. And before you start soldering your board, be sure to read the UM1956 User Manual carefully!<\/strong><\/p>\n\n
The Nucleo-F446RE board also has even more solder bridges. Accordingly, there are also peculiarities here, such as the open solder bridges (SB48 \/ SB49) on PC14 and PC15. Explanations can be found in the UM2324<\/a> user manual. <\/p>\n\n
Hardware timer interrupts<\/h2>\n\n
But now we finally start with the practical part. First, let’s take a look at how to program timer overflow interrupts using the HardwareTimer class. The definition of the class can be found in HardwareTimer.h. This file is located in the directory …\\Arduino15\\packages\\STMicroelectronics\\hardware\\stm32\\2.11.0\\libraries\\SrcWrapper\\inc. The corresponding file HardwareTimer.cpp is located “nearby”, under …\\SrcWrapper\\src. If you want to delve deeper into the topic and get to know all the functions of the HardwareTimer class, it is worth taking a look at these files. <\/p>\n
The STM32 MCUs have several timers (TIMx<\/em>). You can easily find out what these are in the data sheet of the underlying microcontroller. It also states whether they are 16-bit or 32-bit timers. <\/p>\n\n
I prefer to use the TIM2 timer for the examples, as it is available on all the boards under consideration. On the BluePill TIM2 is a 16-bit timer; on the BlackPill and the Nucleo-L432KC it is a 32-bit timer. <\/p>\n\n
One interrupt<\/h3>\n\n
Control via the prescale factor and overflow value<\/h4>\n\n
Let’s take a look at the first example:<\/p>\n<\/p>\n
HardwareTimer myTim(TIM2);\n\nvoid setup() { \n uint32_t prescaleFactor = 10000; \/\/ fits well to the BlackPill\n \/\/ uint32_t prescaleFactor = 7200; \/\/ fits well to the BluePill\n \/\/ uint32_t prescaleFactor = 8000; \/\/ fits well to the L432KC\n \/\/ uint32_t prescaleFactor = 8400; \/\/ fits well to the F446RE\n uint32_t timerOverflow = 10000;\n Serial.begin(115200);\n myTim.setPrescaleFactor(prescaleFactor);\n myTim.setOverflow(timerOverflow);\n myTim.attachInterrupt(onTimer);\n myTim.resume();\n}\n\nvoid loop() {}\n\nvoid onTimer() {\n Serial.println(\"1 second\");\n}<\/pre>\n\n\n
You will receive the message “1 second” on the serial monitor every second.<\/p>\n\n
Explanations to the sketch<\/h5>\n\n
Use
HardwareTimer myTim(TIM2)<\/code> to create the myTim object and assign TIM2 to it. Define the prescaler factor withsetPrescaleFactor()<\/code>. It can have a value between 1 and216<\/sup>. The count frequency of the timer is the system clock divided by the prescaler factor. You should select it so that you can calculate comfortably with it. The examples in the sketch regulate the counting frequency down to 10 kHz. You set the overflow withsetOverflow()<\/code>. For 16-bit timers, the maximum value is216<\/sup>, for 32-bit timers it is a maximum of232<\/sup>-1, astimerOverflow<\/code> is passed as a 32-bit number. <\/p>\nIn the example above, overflow is 10000, and therefore the overflow frequency is 1 Hz according to the following formula:<\/p>\n\n
<\/p>\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-5ff83c5a4c1153c3b7803f077508e4d2_l3.png\" "\\"Rendered")
<\/p><\/p>\n\nAccordingly, the minimum interrupt frequency when using a 16-timer on a BlackPill board is 100 [MHz] \/ (216<\/sup> *216<\/sup>) = ~0.023 [Hz]. For a 32-bit timer, it would be ~3.55*10-7<\/sup> [Hz], which corresponds to a period of approx. 32.5 days. <\/p>\n\n
You pass the interrupt service routine (ISR) to be executed to the function
attachInterrupt<\/code>. Useresume()<\/code> to start or continue the counter. <\/p>\n\nControl via the period<\/h4>\n\n
Alternatively, you can simply set the period. Then you don’t have to calculate and can port the sketch unchanged to other boards: <\/p>\n<\/p>\n
HardwareTimer myTim(TIM2);\n\nvoid setup() {\n uint32_t timerOverflow = 1000000; \n Serial.begin(115200);\n myTim.setOverflow(timerOverflow, MICROSEC_FORMAT);\n myTim.attachInterrupt(onTimer);\n myTim.resume();\n}\n\nvoid loop() {}\n\nvoid onTimer() {\n Serial.println(\"1 second\");\n}<\/pre>\n\n\n
I think the sketch is self-explanatory.<\/p>\n\n
Control via the frequency<\/h4>\n\n
You can also set the overflow frequency as a further option. However, 1 Hz is the slowest setting you can make. <\/p>\n<\/p>\n
HardwareTimer myTim(TIM2);\n\nvoid setup() {\n uint32_t timerOverflow = 1; \/\/ 1 Hz is the slowest frequency\n Serial.begin(115200);\n myTim.setOverflow(timerOverflow, HERTZ_FORMAT);\n myTim.attachInterrupt(onTimer);\n myTim.resume();\n}\n\nvoid loop() {}\n\nvoid onTimer() {\n Serial.println(\"1 second\");\n}<\/pre>\n\n\n
Multiple interrupts<\/h3>\n\n
You can, of course, also set up several interrupts. Here is an example that uses arrays for the timer objects and ISRs. LEDs are “toggled” in the ISRs. If you want to try out the sketch, connect LEDs to the corresponding pins. <\/p>\n<\/p>\n
\nHardwareTimer myTim0(TIM1);\nHardwareTimer myTim1(TIM2);\nHardwareTimer myTim2(TIM3); \/\/ TIM15 for L432KC; TIM13 for F446RE\nHardwareTimer myTim3(TIM4); \/\/ TIM16 for L432KC; TIM14 for F446RE\nHardwareTimer* myTimers[4] = {&myTim0, &myTim1, &myTim2, &myTim3};\n\nconst int ledPin[4] = {PA0, PA1, PA2, PA3}; \/\/ A0, A1, A2, A3: for L432KC\n\nuint32_t timerOverflow[4] = {500000, 1200000, 1700000, 2200000};\n\nvoid onTimer0() {\n digitalWrite(ledPin[0], !digitalRead(ledPin[0]));\n}\n\nvoid onTimer1() {\n digitalWrite(ledPin[1], !digitalRead(ledPin[1]));\n}\n\nvoid onTimer2() {\n digitalWrite(ledPin[2], !digitalRead(ledPin[2]));\n}\n\nvoid onTimer3() {\n digitalWrite(ledPin[3], !digitalRead(ledPin[3]));\n}\n\n\nvoid (*onTimer[4])(void) = {onTimer0, onTimer1, onTimer2, onTimer3}; \n\nvoid setup () {\n for (int i=0; i<4; i++){\n pinMode(ledPin[i], OUTPUT);\n myTimers[i]->setOverflow(timerOverflow[i], MICROSEC_FORMAT);\n myTimers[i]->attachInterrupt(onTimer[i]);\n myTimers[i]->resume();\n }\n}\n\nvoid loop() {}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Timer interrupts for the Arduino GIGA R1 WIFI Board<\/h3>\n\n
Since the HardwareTimer class is firmly anchored in the STM32 Arduino Core package, it does not work with the Arduino GIGA R1 WIFI board if you use the standard Arduino board package.<\/p>\n
Alternatively, you can use the Portenta_H7_TimerInterrupt library, which you can install via the Arduino library manager. It was written for the Portenta H7 board, but also works with the Arduino GIGA R1 WIFI, as both have the same microcontroller. <\/p>\n
When compiling the example sketches you will get the error message: “This code is intended to run on the MBED ARDUINO_PORTENTA_H7 platform! Please check your Tools->Board setting” <\/em>. The compiler also tells you which file produced this error. It is Portenta_H7_ISR_Timer.hpp on the one hand and Portenta_H7_TimerInterrupt.h on the other. <\/p>\n
Go to the files and search for the line (probably 30):<\/p>\n
#if ( ( defined(ARDUINO_PORTENTA_H7_M7) || defined(ARDUINO_PORTENTA_H7_M4) ) && defined(ARDUINO_ARCH_MBED) )<\/code><\/p>\nChange it to:<\/p>\n
#if ( ( defined(ARDUINO_PORTENTA_H7_M7) || defined(ARDUINO_PORTENTA_H7_M4) || defined(ARDUINO_GIGA) ) && defined(ARDUINO_ARCH_MBED) )<\/code><\/p>\nYou can proceed similarly in the example sketches or you can comment out the relevant lines. Then it should work. <\/p>\n\n
Pulse Width Modulation (PWM)<\/h2>\n\n
Pulse width modulation (PWM) can also be easily implemented using the hardware timer class. Here is a simple example:<\/p>\n<\/p>\n
HardwareTimer Timer(TIM1); \n\nvoid setup() {\n uint32_t channel = 3;\n int pwmPin = PA10; \/\/ D0 for L432KC; D2 for F446RE\n uint32_t frequency = 1;\n uint32_t dutyCycle = 20; \/\/ 20%\n Timer.setPWM(channel, pwmPin, frequency, dutyCycle);\n}\n\nvoid loop() {}<\/pre>\n\n\n
The outputs for the various timers and channels are assigned to specific pins. For the boards discussed here, you will find the assignment in the pinout diagrams. Otherwise, take a look at the corresponding data sheet. If you upload the above program and connect an LED to the PWM pin, you will see how it lights up every second for 200 ms. <\/p>\n
You would expect to automatically receive an inverted output at the T1C3N output (e.g., PB1 on the BlackPill). But this is not the case. <\/p>\n
You can call callback functions at the end of the period and\/or the DutyCyle to initiate further actions. Here is a small example:<\/p>\n<\/p>\n
HardwareTimer Timer(TIM1);\n\nvoid setup() {\n uint32_t channel = 3;\n int pwmPin = PA10; \/\/ PA10 = D0 on the L432KC and D2 on the F446RE\n uint32_t frequency = 1;\n uint32_t dutyCycle = 20; \/\/ 20 %\n\n Serial.begin(115200);\n Timer.setPWM(channel, pwmPin, frequency, dutyCycle, periodCompleted, compareMatch);\n}\n\nvoid loop() {}\n\nvoid periodCompleted(){\n Serial.print(\"Hi\");\n}\n\nvoid compareMatch(){\n Serial.println(\"Ho\");\n}<\/pre>\n\n\n
You have a little more options with this variant:<\/p>\n<\/p>\n
HardwareTimer Timer(TIM1);\n\nvoid setup() {\n \/\/ uint32_t compareValue = 2000;\n Timer.setPrescaleFactor(10000); \/\/ -> 10 KHz f\u00fcr BlackPill (STMF411); adjust to your board\n Timer.setOverflow(10000); \/\/ -> 1 Hz \n Timer.setMode(3, TIMER_OUTPUT_COMPARE_PWM1, PA10); \/\/ channel, mode, pwmPin\n Timer.setCaptureCompare(3, 20, PERCENT_COMPARE_FORMAT); \/\/ channel, duty cycle (%), format \n \/\/ Timer.setCaptureCompare(3, compareValue); \/\/ channel, compareValue\n Timer.resume();\n}\n\nvoid loop() {}<\/pre>\n\n\n
TIMER_OUTPUT_COMPARE_PWM1 is one of the possible timer modes. These modes are defined as enum (TimerModes_t) in HardwareTimer.h. Look there if you want to try the other modes. <\/p>\n
PERCENT_COMPARE_FORMAT is one of the possible compare formats. These are defined in the enum
TimerCompareFormat_t<\/code> in HardwareTimer.h. If you do not pass a format tosetCaptureCompare()<\/code>, then TICK_COMPARE_FORMAT is used as the default. In this case, you pass the compare value as an absolute counter value. <\/p>\n\nPWM with the Arduino GIGA R1 WIFI<\/h3>\n\n
For PWM on the Arduino GIGA R1 WIFI, you can use the Portenta_H7_PWM<\/a> and Portenta_H7_Slow_PWM<\/a> libraries. However, as described above for the Portenta_H7_TimerInterrupt library, you must also add the board definition for the Arduino GIGA R1 WIFI. <\/p>\n\n
Analog-to-digital converter (ADC)<\/h2>\n\n
Next, let’s take a look at the ADC of the STM32 boards. Please note the following regarding the reference voltage: <\/p>\n
- \n
- The maximum resolution is 12 bits. The BluePill and BlackPill boards do not have a VREF pin. VDD is the standard reference. <\/li>\n
- Although there is a VREF pin on the Nucleo-L432KC, you can only tap the reference voltage there, but not apply it.<\/li>\n
- An external reference can be used with the Nucleo-F446RE if the solder bridges are set accordingly.<\/li>\n<\/ul>\n
For programming you can use the usual Arduino functions. For the Arduino GIGA R1 WIFI board there is the Arduino_AdvanceAnalog<\/a> library, which supports the use of its three ADCs. <\/p>\n\n
Testing the accuracy of the ADC<\/h3>\n\n
I applied voltages between 0 and 3.3 volts, converted them with analogRead() and checked the result with my multimeter. I know from my multimeter that it is very precise. I averaged 50 readings at a time, which reduced the noise to a few millivolts. <\/p>\n
Here is the sketch: <\/p>\n<\/p>\n
const float vRef = 3.3;\n\nvoid setup() {\n Serial.begin(115200);\n analogReadResolution(12);\n}\n\nvoid loop() {\n unsigned long int rawVal = 0;\n float voltage = 0.0;\n for (int i=0; i<50; i++) {\n rawVal += analogRead(PA1);\n delay(1);\n }\n voltage = (rawVal * vRef) \/ (4095 * 50);\n Serial.print(\"Raw: \");\n Serial.print(rawVal);\n Serial.print(\"\\tVoltage [V]: \");\n Serial.println(voltage, 3);\n delay(1000);\n}<\/pre>\n\n\n
And here is a typical output:<\/p>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/output_adc_test.png\")
<\/a>Output adc_test.ino<\/figcaption><\/figure>\n\n And here are the results over the entire voltage range of the BlackPill board:<\/p>\n\n
![\"STM32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/blackpill_adc_test.png\")
<\/a>ADC test with a blackpill board (STM32F411)<\/figcaption><\/figure>\n\n The result looks pretty good. The linearity is perfect. If you look closely, you can see that the slope of the ADC line is a little bit lower than that of the multimeter line. The reason was the operating voltage of the BlackPill board, which was not 3.3 volts but 3.311 volts. After adjusting
vref<\/code> in the sketch above, the lines were even better aligned. <\/p>\nSimilarly good results were achieved with the BluePill board (STM32F103C8) and the Nucleo-L432KC. <\/p>\n\n
Digital-to-analog converter DAC<\/h2>\n\n
Normally, when using
analogWrite()<\/code>, you generate a PWM signal. However, if you applyanalogWrite()<\/code> to a DAC pin, you will automatically receive a real analog signal. DAC outputs can be found on the Nucleo boards and the Arduino GIGA R1 WIFI, but not on BluePill and BlackPill. <\/p>\n\nUse the following sketch to enter raw DAC values and output the calculated voltages:<\/p>\n<\/p>\n
void setup() {\n Serial.begin(115200);\n analogWriteResolution(12); \/\/ 12 bit resolution\n}\n\nvoid loop() {\n float vref = 3.3;\n if(Serial.available()){\n int rawVoltage = Serial.parseInt();\n analogWrite(A3, rawVoltage);\n Serial.print(rawVoltage);\n Serial.print(\" -> \");\n float voltage = (vref * rawVoltage \/ 4095.0);\n Serial.print(voltage, 3);\n Serial.println(\" [V] (calc.)\");\n }\n}<\/pre>\n\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/output_dac_check.png\")
<\/a>Output dac_test.ino<\/figcaption><\/figure>\n\n I used the sketch to compare the calculated voltage with the actual voltage. Here is the result: <\/p>\n\n
![\"STM32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/nucleo_dac_test-1-1024x514.png\")
<\/a>DAC output: Measured values vs. calculated values<\/figcaption><\/figure>\n\n Over a wide range, the actual values match the calculated values perfectly. Only at the ends does the curve bend away from the actual values. I was unable to generate voltages lower than 0.045 volts (
analogWrite(0)<\/code>) or higher than 3.28 volts (analogWrite(4095)<\/code>). Apart from that, I was very satisfied with the result. If you want to be even more precise, measure the actual board voltage at (V)REF and correctvref<\/code> in the sketch above accordingly. <\/p>\nI was able to generate voltages between 0.02 volts and 3.226 volts on the Arduino GIGA R1 WIFI. However, the board voltage here was only 3.262 volts. <\/p>\n\n
External interrupts<\/h2>\n\n
You can set up external interrupts (EXTI) on almost all GPIOs. You should only avoid PB2 (on the BlackPill), PC13, PC14, and PC15. <\/p>\n
However, there is one more restriction. You have 16 EXTI lines (0-15) at your disposal. However, the EXTI lines can only be assigned to pins whose number corresponds to the EXTI line. So EXTI0<\/strong> \u2192 PA0<\/strong>, PB0<\/strong>; EXTI1<\/strong> \u2192 PA1<\/strong>, PB1<\/strong>; etc. And you can only assign one interrupt per line. Consequence: You can set up interrupts on PA0 and PB1 in parallel, but not on PA0 and PB0. <\/p>\n\n
I tried setting up four external interrupts with a BlackPill board. Each of the four pins is connected to GND via a pushbutton. <\/p>\n\n
![\"STM32](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/interrupt_example_circuit-1024x335.png\")
<\/a>Circuit for interrupt example<\/figcaption><\/figure>\n\n The pins are set to INPUT_PULLUP mode. The associated interrupts are triggered on the falling edge, i.e. when the buttons are pressed. The triggering pin is displayed on the serial monitor. Here is the sketch: <\/p>\n<\/p>\n
\n\/* tested on a BlackPill (F411CE) *\/\nint intPin[4] = {PA4, PA1, PB3, PB6};\nvolatile bool keyPressed = false;\nvolatile int intKey = 0;\n\nvoid onKey0 () {\n keyPressed = true;\n intKey = 0;\n}\n\nvoid onKey1 () {\n keyPressed = true;\n intKey = 1;\n}\n\nvoid onKey2 () {\n keyPressed = true;\n intKey = 2;\n}\n\nvoid onKey3 () {\n keyPressed = true;\n intKey = 3;\n}\n\nvoid (*onKey[4])(void) = {onKey0, onKey1, onKey2, onKey3}; \n\nvoid setup() {\n Serial.begin(115200);\n for (int i=0; i<4; i++) {\n pinMode(intPin[i], INPUT_PULLUP);\n attachInterrupt (digitalPinToInterrupt(intPin[i]), onKey[i], FALLING);\n delay(10); \n }\n}\n\nvoid loop() {\n if (keyPressed) {\n Serial.print(\"Key \");\n Serial.print(intKey);\n Serial.println(\" has been pressed\");\n delay(500);\n intKey = 0;\n keyPressed = false;\n }\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
I2<\/sup>C<\/h2>\n\n
You can use two I\u00b2C interfaces on the BluePill (STM32F103C8). On the BlackPill (STM32F411), the Nucleo-L432KC, the Nucleo-F446RE and the Arduino GIGA R1 WIFI there are three interfaces. If you only use one interface and do not define anything else, then SDA and SCL are located on the following pins: <\/p>\n
- \n
- BluePill \/ BlackPill: SDA<\/span> – PB7<\/span> \/ SCL<\/span> – PB6<\/span><\/li>\n
- Nucleo-L432KC: SDA<\/span> – PB_7<\/span> (D4) \/ SCL<\/span> – PB_6<\/span> (D5) <\/li>\n
- Nucleo-F446RE: SDA<\/span> – PB_9<\/span> (D14) \/ SCL<\/span> – PB_8<\/span> (D15) <\/li>\n
- Arduino GIGA R1 WIFI: SDA<\/span> – PB11<\/span> (D20) \/ SCL<\/span> – PH4<\/span> (D21)<\/li>\n<\/ul>\n\n
Illustrative example: MPU6000\/MPU6050\/MPU6500\/MPU9250<\/h3>\n\n
I would like to explain the use of I2<\/sup>C on the STM32 boards using practical examples. I have selected the MPU6000, MPU6050, MPU6500 and MPU9250 acceleration sensors for this purpose. The sketches presented here work for all four sensors. I refer to them collectively as “MPUXXXX”. <\/p>\n\n
This is not intended to be an article about these sensors, but a brief explanation is certainly necessary so that we can concentrate on the relevant I2<\/sup>C functions straight away.<\/p>\n
- \n
- The MPUXXXX are woken up by an entry in their Power Management Register 1 (MPUXXXX_PWR_MGMT_1) and then continuously measure the acceleration of its x, y and z axes.<\/li>\n
- The acceleration values are 16-bit numbers that are read “in one go” from 6 registers, starting with the MPUXXXX_ACCEL_XOUT_H register (MSB of the acceleration in the x direction).<\/li>\n
- The 6 bytes are then converted into the three acceleration values accX, accY and accZ.<\/li>\n
- In the examples, the resolution is +\/- 2 g, i.e. 214<\/sup> (= 16384) corresponds to one g.<\/li>\n<\/ul>\n\n
Connection<\/h4>\n\n
Here you can see two MPU6500\/MPU920 connected to I2C-1 (default) and I2C-2 of a BlackPillboard:<\/p>\n\n
![\"Two](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/ic2_blackpill_mpu9250-3-1024x452.png\")
<\/a>Two MPU6500\/9250 via I2C on the BlackPill<\/figcaption><\/figure>\n\n One I\u00b2C device attched to the standard pins<\/h3>\n\n
If you use the standard interface with the standard pins, there are no surprises regarding the I2C functions:<\/p>\n<\/p>\n
\n#include \"Wire.h\" \n#define MPUXXXX_ADDR 0x68 \/\/ Alternatively set AD0 to HIGH --> Address = 0x69\n\/\/ MPUXXXX registers\n#define MPUXXXX_PWR_MGMT_1 0x6B\n#define MPUXXXX_ACCEL_XOUT_H 0x3B\n\nchar result[7]; \/\/ for formatted output\n\nvoid setup() {\n Serial.begin(115200);\n Wire.begin();\n writeRegister(MPUXXXX_PWR_MGMT_1, 0x00); \/\/ wake up MPUXXXX\n}\n\nvoid loop() {\n uint8_t data[6];\n int16_t accX, accY, accZ;\n \n readRegister(MPUXXXX_ACCEL_XOUT_H, data, 6);\n \n accX = data[0] << 8 | data[1];\n accY = data[2] << 8 | data[3]; \n accZ = data[4] << 8 | data[5]; \n \n Serial.print(\"AcX = \"); Serial.print(toStr(accX));\n Serial.print(\" | AcY = \"); Serial.print(toStr(accY));\n Serial.print(\" | AcZ = \"); Serial.println(toStr(accZ));\n\n delay(1000);\n}\n\nvoid writeRegister(uint8_t reg, uint8_t data) {\n Wire.beginTransmission(MPUXXXX_ADDR);\n Wire.write(reg); \n Wire.write(data); \n Wire.endTransmission(true);\n}\n\nvoid readRegister(uint8_t reg, uint8_t* buffer, uint8_t length) {\n Wire.beginTransmission(MPUXXXX_ADDR);\n Wire.write(reg);\n Wire.endTransmission(false); \n Wire.requestFrom((uint8_t)MPUXXXX_ADDR, length);\n for (int i=0; i<length; i++){\n buffer[i] = Wire.read();\n }\n}\n\nchar* toStr(int16_t character) { \n sprintf(result, \"%6d\", character);\n return result;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
For the sake of completeness, here is a sample output:<\/p>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/output_i2c_standard.png\")
<\/a>Output i2c_standard.ino<\/figcaption><\/figure>\n\n One I\u00b2C device attached to alternative pins<\/h3>\n\n
If you want to use alternative I\u00b2C pins, you must create a TwoWire object and pass the pins to it. It does not matter whether these are alternative pins of the I2C standard<\/sup>interface or alternative interfaces. <\/p>\n<\/p>\n
\n#include \"Wire.h\" \n#define MPUXXXX_ADDR 0x68 \/\/ Alternatively set AD0 to HIGH --> Address = 0x69\n\/\/ MPUXXXX registers\n#define MPUXXXX_PWR_MGMT_1 0x6B\n#define MPUXXXX_ACCEL_XOUT_H 0x3B\n\nchar result[7]; \/\/ for formatted output\n\n\/* create a TwoWire object *\/\nTwoWire myWire(PB9, PB8); \/\/ SDA, SCL\n\nvoid setup() {\n Serial.begin(115200);\n myWire.begin();\n writeRegister(MPUXXXX_PWR_MGMT_1, 0x00); \/\/ wake up MPUXXXX\n}\n\nvoid loop() {\n uint8_t data[6];\n int16_t accX, accY, accZ;\n \n readRegister(MPUXXXX_ACCEL_XOUT_H, data, 6);\n \n accX = data[0] << 8 | data[1];\n accY = data[2] << 8 | data[3]; \n accZ = data[4] << 8 | data[5]; \n \n Serial.print(\"AcX = \"); Serial.print(toStr(accX));\n Serial.print(\" | AcY = \"); Serial.print(toStr(accY));\n Serial.print(\" | AcZ = \"); Serial.println(toStr(accZ));\n\n delay(1000);\n}\n\nvoid writeRegister(uint8_t reg, uint8_t data) {\n myWire.beginTransmission(MPUXXXX_ADDR);\n myWire.write(reg); \n myWire.write(data); \n myWire.endTransmission(true);\n}\n\nvoid readRegister(uint8_t reg, uint8_t* buffer, uint8_t length) {\n myWire.beginTransmission(MPUXXXX_ADDR);\n myWire.write(reg);\n myWire.endTransmission(false); \n myWire.requestFrom((uint8_t)MPUXXXX_ADDR, length);\n for (int i=0; i<length; i++){\n buffer[i] = myWire.read();\n }\n}\n\nchar* toStr(int16_t character) { \n sprintf(result, \"%6d\", character);\n return result;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Using multiple I\u00b2C interfaces<\/h3>\n\n
If you want to use several I2<\/sup>C interfaces, you must create TwoWire objects for each one. If you define functions that use the TwoWire objects (such as
writeRegister()<\/code> andreadRegister()<\/code>), then you pass the TwoWire objects as a pointer or as a reference. <\/p>\n<\/p>\n\n#include \"Wire.h\" \n#define MPUXXXX_ADDR 0x68 \/\/ Alternatively set AD0 to HIGH --> Address = 0x69\n\/\/ MPUXXXX registers\n#define MPUXXXX_PWR_MGMT_1 0x6B\n#define MPUXXXX_ACCEL_XOUT_H 0x3B\n\nchar result[7]; \/\/ for formatted output\n\n\/* create two TwoWire instances *\/\nTwoWire Wire_1(PB7, PB6); \/\/ you could also use the default Wire object instead\nTwoWire Wire_2(PB3, PB10);\n\nvoid setup() {\n Serial.begin(115200);\n Wire_1.begin();\n Wire_2.begin();\n writeRegister(&Wire_1, MPUXXXX_PWR_MGMT_1, 0x00); \/\/ wake up MPUXXXX-1\n writeRegister(&Wire_2, MPUXXXX_PWR_MGMT_1, 0x00); \/\/ wake up MPUXXXX-2\n}\n\nvoid loop() {\n uint8_t data[6];\n int16_t accX_1, accY_1, accZ_1, accX_2, accY_2, accZ_2;\n \n readRegister(&Wire_1, MPUXXXX_ACCEL_XOUT_H, data, 6);\n \n accX_1 = (data[0] << 8) | data[1];\n accY_1 = (data[2] << 8) | data[3];\n accZ_1 = (data[4] << 8) | data[5];\n\n Serial.print(\"AcX_1 = \"); Serial.print(toStr(accX_1));\n Serial.print(\" | AcY_1 = \"); Serial.print(toStr(accY_1));\n Serial.print(\" | AcZ_1 = \"); Serial.println(toStr(accZ_1));\n Serial.flush();\n\n readRegister(&Wire_2, MPUXXXX_ACCEL_XOUT_H, data, 6);\n \n accX_2 = (data[0] << 8) | data[1];\n accY_2 = (data[2] << 8) | data[3];\n accZ_2 = (data[4] << 8) | data[5];\n\n Serial.print(\"AcX_2 = \"); Serial.print(toStr(accX_2));\n Serial.print(\" | AcY_2 = \"); Serial.print(toStr(accY_2));\n Serial.print(\" | AcZ_2 = \"); Serial.println(toStr(accZ_2));\n Serial.println();\n\n delay(1000);\n}\n\nvoid writeRegister(TwoWire *_wire, uint8_t reg, uint8_t data) {\n _wire->beginTransmission(MPUXXXX_ADDR);\n _wire->write(reg); \n _wire->write(data); \n _wire->endTransmission(true);\n}\n\nvoid readRegister(TwoWire *_wire, uint8_t reg, uint8_t* buffer, uint8_t length) {\n _wire->beginTransmission(MPUXXXX_ADDR);\n _wire->write(reg);\n _wire->endTransmission(false); \n _wire->requestFrom((uint8_t)MPUXXXX_ADDR, length);\n for (int i=0; i<length; i++){\n buffer[i] = _wire->read();\n }\n}\n\nchar* toStr(int16_t character) { \n sprintf(result, \"%6d\", character);\n return result;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Here is the corresponding output:<\/p>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2025\/08\/output_i2c_two_interfaces.png\")
<\/a>Output i2c_two_interfaces.ino<\/figcaption><\/figure>\n\n Using libraries<\/h3>\n\n
- Nucleo-L432KC: SDA<\/span> – PB_7<\/span> (D4) \/ SCL<\/span> – PB_6<\/span> (D5) <\/li>\n
- BluePill \/ BlackPill: SDA<\/span> – PB7<\/span> \/ SCL<\/span> – PB6<\/span><\/li>\n
- To supply the board via the 3.3V and 5V pins, you must change the configuration of the solder bridges SBxy<\/em> (see below).<\/li>\n
- HAL (Hardware Abstraction Layer)<\/strong>: Higher abstraction, higher portability, but more overhead.<\/li>\n<\/ol>\n<\/li>\n
- CMSIS (Cortex Microcontroller Software Interface Standard)<\/strong>: Is specified by ARM and is supplied with ST. IRQ names and core functions, for example, are defined there. <\/li>\n
- Hardware timer interrupts<\/a><\/li>\n