• Why do we need this STM32_TimerInterrupt library
  • Features
  • Why using ISR-based Hardware Timer Interrupt is better
  • Currently supported Boards
  • Important Notes about ISR
• Changelog
• Prerequisites
• Installation
  • Use Arduino Library Manager
  • Manual Install
  • VS Code & PlatformIO
• Libraries' Patches
  • 1. For application requiring 2K+ HTML page
  • 2. For Ethernet library
  • 3. For EthernetLarge library
  • 4. For Etherne2 library
  • 5. For Ethernet3 library
  • 6. For UIPEthernet library
  • 7. For fixing ESP32 compile error
  • 8. For STM32 core F3 and F4 using UIPEthernet library
• HOWTO Fix Multiple Definitions Linker Error
• More useful Information about STM32 Timers
• New from v1.0.0
• Usage
  • 1. Using only Hardware Timer directly
    • 1.1 Init Hardware Timer
    • 1.2 Set Hardware Timer Interval and attach Timer Interrupt Handler function
  • 2. Using 16 ISR_based Timers from 1 Hardware Timer
    • 2.1 Init Hardware Timer and ISR-based Timer
    • 2.2 Set Hardware Timer Interval and attach Timer Interrupt Handler functions
• Examples
  • 1. Argument_None
  • 2. ISR_16_Timers_Array
  • 3. ISR_RPM_Measure
  • 4. ISR_Timer_Complex
  • 5. RPM_Measure
  • 6. SwitchDebounce
  • 7. TimerInterruptTest
  • 8. TimerInterruptLEDDemo
  • 9. Change_Interval.
  • 10. ISR_16_Timers_Array_Complex.
• Example ISR_16_Timers_Array_Complex
• Debug Terminal Output Samples
  • 1. ISR_Timer_Complex on STM32F7 Nucleo-144 NUCLEO_F767ZI using Built-in LAN8742A
  • 2. TimerInterruptTest on STM32F7 Nucleo-144 NUCLEO_F767ZI
  • 3. Argument_None on STM32F7 Nucleo-144 NUCLEO_F767ZI
  • 4. Change_Interval on STM32F7 Nucleo-144 NUCLEO_F767ZI
  • 5. ISR_16_Timers_Array_Complex on STM32F7 Nucleo-144 NUCLEO_F767ZI
  • 6. ISR_16_Timers_Array_Complex on STM32F1 BLUEPILL_F103C8
  • 7. ISR_16_Timers_Array_Complex on STM32H7 NUCLEO_H743ZI2
  • 8. ISR_16_Timers_Array_Complex on STM32L5 NUCLEO_L552ZE_Q
• Debug
• Troubleshooting
• Issues
• TO DO
• DONE
• Contributions and Thanks
• Contributing
• License
• Copyright

This library enables you to use Interrupt from Hardware Timers on an STM32-based board, such as STM32F/L/H/G/WB/MP1.

As Hardware Timers are rare, and very precious assets of any board, this library now enables you to use up to 16 ISR-based Timers, while consuming only 1 Hardware Timer. Timers' interval is very long (ulong millisecs).

Now with these new 16 ISR-based timers, the maximum interval is practically unlimited (limited only by unsigned long milliseconds) while the accuracy is nearly perfect compared to software timers.

The most important feature is they're ISR-based timers. Therefore, their executions are not blocked by bad-behaving functions / tasks. This important feature is absolutely necessary for mission-critical tasks.

The ISR_Timer_Complex example will demonstrate the nearly perfect accuracy compared to software timers by printing the actual elapsed millisecs of each type of timers.

Being ISR-based timers, their executions are not blocked by bad-behaving functions / tasks, such as connecting to WiFi, Internet and Blynk services. You can also have many (up to 16) timers to use.

This non-being-blocked important feature is absolutely necessary for mission-critical tasks.

You'll see blynkTimer Software is blocked while system is connecting to WiFi / Internet / Blynk, as well as by blocking task in loop(), using delay() function as an example. The elapsed time then is very unaccurate

Imagine you have a system with a mission-critical function, measuring water level and control the sump pump or doing something much more important. You normally use a software timer to poll, or even place the function in loop(). But what if another function is blocking the loop() or setup().

So your function might not be executed, and the result would be disastrous.

You'd prefer to have your function called, no matter what happening with other functions (busy loop, bug, etc.).

The correct choice is to use a Hardware Timer with Interrupt to call your function.

These hardware timers, using interrupt, still work even if other functions are blocking. Moreover, they are much more precise (certainly depending on clock frequency accuracy) than other software timers using millis() or micros(). That's necessary if you need to measure some data requiring better accuracy.

Functions using normal software timers, relying on loop() and calling millis(), won't work if the loop() or setup() is blocked by certain operation. For example, certain function is blocking while it's connecting to WiFi or some services.

The catch is your function is now part of an ISR (Interrupt Service Routine), and must be lean / mean, and follow certain rules. More to read on:

HOWTO Attach Interrupt

1. STM32 boards with built-in Ethernet LAN8742A such as :

• Nucleo-144 (F429ZI, F767ZI, NUCLEO_H743ZI2, NUCLEO_L552ZE_Q)
• Discovery (STM32F746G-DISCOVERY)
• All STM32 boards (STM32F/L/H/G/WB/MP1) with 32K+ Flash, with Built-in Ethernet

2. STM32F/L/H/G/WB/MP1 boards (with 32+K Flash) running W5x00 or ENC28J60 shields)

• Nucleo-144
• Nucleo-64
• Discovery
• Generic STM32F0, STM32F1, STM32F2, STM32F3, STM32F4, STM32F7 (with 64+K Flash): x8 and up
• STM32L0, STM32L1, STM32L4, STM32L5
• STM32G0, STM32G4
• STM32H7
• STM32WB
• STM32MP1
• LoRa boards
• 3-D printer boards
• Generic Flight Controllers
• Midatronics boards

1. Inside the attached function, delay() won't work and the value returned by millis() will not increment. Serial data received while in the function may be lost. You should declare as volatile any variables that you modify within the attached function.

2. Typically global variables are used to pass data between an ISR and the main program. To make sure variables shared between an ISR and the main program are updated correctly, declare them as volatile.

1. Arduino IDE 1.8.19+ for Arduino.
2. Arduino Core for STM32 v2.3.0+ for STM32F/L/H/G/WB/MP1 boards.
3. Blynk library 1.1.0+. to use with certain example.
4. For built-in LAN8742A Ethernet:

• STM32Ethernet library v1.3.0+ for built-in LAN8742A Ethernet on (Nucleo-144, Discovery).
• LwIP library v2.1.2+ for built-in LAN8742A Ethernet on (Nucleo-144, Discovery).

5. For W5x00 Ethernet:

• Ethernet_Generic library v2.7.1+ for W5100, W5200 and W5500.

6. For ENC28J60 Ethernet:

• EthernetENC library v2.0.3+ for ENC28J60. . New and Better
• UIPEthernet library v2.0.12+ for ENC28J60.

7. To use with certain example

• SimpleTimer library for ISR_16_Timers_Array example.

The best and easiest way is to use Arduino Library Manager. Search for STM32_TimerInterrupt, then select / install the latest version. You can also use this link for more detailed instructions.

Another way to install is to:

1. Navigate to STM32_TimerInterrupt page.
2. Download the latest release STM32_TimerInterrupt-master.zip.
3. Extract the zip file to STM32_TimerInterrupt-master directory
4. Copy whole STM32_TimerInterrupt-master folder to Arduino libraries' directory such as ~/Arduino/libraries/.

1. Install VS Code
2. Install PlatformIO
3. Install STM32_TimerInterrupt library by using Library Manager. Search for STM32_TimerInterrupt in Platform.io Author's Libraries
4. Use included platformio.ini file from examples to ensure that all dependent libraries will installed automatically. Please visit documentation for the other options and examples at Project Configuration File

If your application requires 2K+ HTML page, the current Ethernet library must be modified if you are using W5200/W5500 Ethernet shields. W5100 is not supported for 2K+ buffer. If you use boards requiring different CS/SS pin for W5x00 Ethernet shield, for example ESP32, ESP8266, nRF52, etc., you also have to modify the following libraries to be able to specify the CS/SS pin correctly.

To fix Ethernet library, just copy these following files into the Ethernet library directory to overwrite the old files:

• Ethernet.h
• Ethernet.cpp
• EthernetServer.cpp
• w5100.h
• w5100.cpp

To fix EthernetLarge library, just copy these following files into the EthernetLarge library directory to overwrite the old files:

• EthernetLarge.h
• EthernetLarge.cpp
• EthernetServer.cpp
• w5100.h
• w5100.cpp

To fix Ethernet2 library, just copy these following files into the Ethernet2 library directory to overwrite the old files:

• Ethernet2.h
• Ethernet2.cpp

To add UDP Multicast support, necessary for the UPnP_Generic library:

• EthernetUdp2.h
• EthernetUdp2.cpp

5. To fix Ethernet3 library, just copy these following files into the Ethernet3 library directory to overwrite the old files:

• Ethernet3.h
• Ethernet3.cpp

To be able to compile and run on nRF52 boards with ENC28J60 using UIPEthernet library, you have to copy these following files into the UIPEthernet utility directory to overwrite the old files:

• UIPEthernet.h
• UIPEthernet.cpp
• Enc28J60Network.h
• Enc28J60Network.cpp

To fix ESP32 compile error, just copy the following file into the ESP32 cores/esp32 directory (e.g. ./arduino-1.8.12/hardware/espressif/cores/esp32) to overwrite the old file:

• Server.h

Check if you need to install the UIPEthernet patch new STM32 core F3/F4 compatibility to avoid errors #include HardwareSPI.h on some STM32 boards (Nucleo-32 F303K8, etc.)

The current library implementation, using xyz-Impl.h instead of standard xyz.cpp, possibly creates certain Multiple Definitions Linker error in certain use cases.

You can use

in many files. But be sure to use the following #include in just 1 .h, .cpp or .ino file, which must not be included in any other file, to avoid Multiple Definitions Linker Error

The Timers of STM32s are numerous, yet very sophisticated and powerful.

In general, across the STM32 microcontrollers families, the timer peripherals that have the same name also have the same features set, but there are a few exceptions.

For example, the TIM1 timer peripheral is shared across the STM32F1 Series, STM32F2 Series and STM32F4 Series, but for the specific case of STM32F30x microcontrollers family, the TIM1 timer peripheral features a bit richer features set than the TIM1 present in the other families.

The general purpose timers embedded by the STM32 microcontrollers share the same backbone structure; they differ only on the level of features embedded by a given timer peripheral.

The level of features integration for a given timer peripheral is decided based on the applications field that it targets.

The timer peripherals can be classified as: * Advanced-configuration timers like TIM1 and TIM8 among others. * General-purpose configuration timers like TIM2 and TIM3 among others * Lite-configuration timers like TIM9, TIM10, TIM12 and TIM16 among others * Basic-configuration timers like TIM6 and TIM7 among others.

For example, STM32F103C8T6 has one advance timer, while STM32F103VET6 has two advanced timers. Nucleo-144 STM32F767ZI boards have 14 Timers, TIM1-TIM14.

More information can be found at Embedded-Lab STM32 TIMERS

To be sure which Timer is available for the board you're using, check the Core Package's related files. For example, for Nucleo-144 STM32F767ZI, check these files:

1. ~/.arduino15/packages/STM32/hardware/stm32/1.9.0/system/Drivers/CMSIS/Device/ST/STM32F7xx/Include/stm32f7xx.h
2. ~/.arduino15/packages/STM32/hardware/stm32/1.9.0/system/Drivers/CMSIS/Device/ST/STM32F7xx/Include/stm32f767xx.h

The information will be as follows:

and

Now with these new 16 ISR-based timers (while consuming only 1 hardware timer), the maximum interval is practically unlimited (limited only by unsigned long milliseconds). The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers Therefore, their executions are not blocked by bad-behaving functions / tasks. This important feature is absolutely necessary for mission-critical tasks.

The ISR_Timer_Complex example will demonstrate the nearly perfect accuracy compared to software timers by printing the actual elapsed millisecs of each type of timers. Being ISR-based timers, their executions are not blocked by bad-behaving functions / tasks, such as connecting to WiFi, Internet and Blynk services. You can also have many (up to 16) timers to use. This non-being-blocked important feature is absolutely necessary for mission-critical tasks. You'll see blynkTimer Software is blocked while system is connecting to WiFi / Internet / Blynk, as well as by blocking task in loop(), using delay() function as an example. The elapsed time then is very unaccurate

Before using any Timer, you have to make sure the Timer has not been used by any other purpose.

1. Argument_None
2. ISR_16_Timers_Array
3. ISR_RPM_Measure
4. ISR_Timer_Complex
5. RPM_Measure
6. SwitchDebounce
7. TimerInterruptTest
8. TimerInterruptLEDDemo
9. Change_Interval. New
10. ISR_16_Timers_Array_Complex. New

The following is the sample terminal output when running example ISR_Timer_Complex on STM32F7 Nucleo-144 NUCLEO_F767ZI using Built-in LAN8742A Ethernet and STM32Ethernet Library to demonstrate the accuracy of ISR Hardware Timer, especially when system is very busy. The ISR timer is programmed for 2s, is activated exactly after 2.000s !!!

While software timer, programmed for 2s, is activated after 9.782s !!!. Then in loop(), it's also activated every 3s.