Mastering Microcontroller: Timers, PWM, CAN, Low Power(MCU2)

Use the nucleo f446re STM32 development board by ST as the course’s basis, based on STM32F4x and STM32F446RE, with guidance on using similar boards and required driver and ST-LINK updates.

Power the board with a mini USB cable from your PC, observe red LED, and use blue user button and black reset button; download datasheet, reference manual, and schematic.

Install ST-Link drivers for your ST discovery or nucleo board to enable UART communication, using Windows 32/64-bit installers from ST, Ubuntu commands, and noting that Mac requires no driver.

Upgrade ST-Link firmware for V2 and V2-1 using the software on Windows, Mac, or Ubuntu. Connect the board, open update mode, and restart to complete the upgrade.

Choose your IDE for this course: STM32CubeIDE with cubeMX, or STM32 System Workbench with cubeMX. You may also use VS Code with debug plugin, though it is not yet covered.

migrate to stm32cubeide using version 1.19 for consistency, set up workspace and project, configure USART2 for virtual COM, and adopt a manual coding workflow while excluding code generator files.

Install STM32 CubeMX, download and log in, extract and install version 4.22, then open the CubeMX application, and regularly check for updates for STM32 F4 and F7 families.

Learn the STM32 cube project architecture using HAL driver APIs, not auto-generation, with CubeMX templates, CMSIS-Core, and peripheral driver files to test on hardware.

Understand the CubeMX generated project hierarchy: drivers, include, source, and startup files, plus CMSIS-core and HAL drivers. Build creates elf and bin binaries and enables hello world output over UART.

Learn the STM32 cube framework program flow, starting with proper basic microcontroller initialization and clock setup, before calling peripheral HAL APIs to ensure correct peripheral timing and system clocks.

Learn how main.c, msp.c, and it.c coordinate with the stm32 HAL to initialize peripherals, start UART communication, and handle interrupts through callbacks, bridging application code with Cube HAL.

Explore the stm32 header file hierarchy, including stm32f4xx.h for the device family, f446xx.h for the specific MCU, and stm32f4xx_hal.h for cube hal APIs, plus how startup relies on system_init.

Learn how to download course projects from GitHub and import them into Eclipse, organize an original and a personal workspace, and build CAN and timer projects for testing.

Create a cube hal based project template in CubeMX for stm32f4, import into eclipse, replace auto generated files with main.c, msp.c, and it.c, and initialize HAL with HAL_Init().

Learn processor-specific initialization via the cube hal cortex driver, exploring NVIC, SYSTICK, and MPU APIs in hal_cortex.c, and configure priority grouping with HAL_NVIC_SetPriorityGrouping, understanding preemption and subpriority (default group 4).

Define and link a UART2 handle, configure baud rate, word length, stop bits, parity, and mode, then call HAL_UART_Init for high-level peripheral initialization and set up for later low-level initialization.

Learn low level initializations for the USART2 peripheral, including enabling its clock, performing pin muxing, and configuring NVIC interrupts with priority in HAL UART setup.

Enable USART2 IRQ in the NVIC and set its priority to allow interrupt-driven data handling. The module covers pin muxing, clock enable, and low level initialization for low power operation.

Learn to send characters over uart using hal_uart_transmit in blocking mode, calculate data length with strlen, and handle timeout and status checks for reliable transmission.

Debug and fix UART data transmission using HLA_UART_transmit() API by enabling clocks for USART2 and GPIO port A, and implement systick handler to drive the STM32 Cube tick.

Convert a blocking uart receive into interrupt-based data receiving using the STM32 cube framework, learn uart interrupts, and prepare to move on to timers.

Convert a blocking polling UART into an interrupt-based receive flow using the non-blocking API. Implement USART2_IRQHandler and call HAL_UART_IRQHandler to process UART interrupts.

Explore non-blocking UART data reception using interrupt mode, implement receive complete callback to gather bytes into a global buffer until carriage return, leveraging the Cube framework callbacks.

Explore UART data reception using STM32 Cube framework in interrupt and polling modes, learn to navigate driver APIs, and prepare to work with timers, RTC, and CAN peripherals.

Explore microcontroller's clock architecture and the RCC HAL APIs for configuring HSI, HSE, and PLL-based SYSCLK, derive HCLK and PCLKx, and drive RTC and watchdog timers with LSI and LSE.

Enable system clock (HSI or HSC), optionally PLL; configure CPU, AHB, APB, and USB clocks with prescalers; set flash latency; switch to the sysclk using HAL_RCC_OscConfig and HAL_RCC_ClockConfig.

Configure the RCC with HAL_RCC_OscConfig and HAL_RCC_ClockConfig. Set HSE as the system clock to 8 MHz with HCLK 4 MHz, PCLK1 2 MHz, and PCLK2 2 MHz.

Configure the stm32 clock tree, enable hse as sysclk, and use apb1 and apb2 prescalers with HAL_RCC_ClockConfig to reach 4 mhz hclk and 0 ws flash latency.

Reconfigure the systick to generate a 1 ms interrupt using CMSIS SYSTICK_Config, after changing the system clock from 16 MHz to 4 MHz, and reinitialize UART baud rate accordingly.

Program the microcontroller and verify clock domains—SYSCLK, HCLK, PCLK1, and PCLK2—achieving 16 MHz after main. Preview the next lecture on HSI calibration and temperature behavior.

Calibrate the HSI clock to counter temperature drift using the HSITRIM 5-bit field in the RCC control register; 16 at 25 degree Celsius, measure with timer input capture for trimming.

Explore the pll engine to generate system clocks from HSE or HSI using M divider, N multiplier, and P divider, with VCO input 1–2 MHz and VCO output 100–432 MHz.

Configure the microcontroller's PLL to generate 50, 84, or 120 MHz from HSI or HSE, setting PLLM, PLLN, and PLLP, and apply with HAL_RCC_OscConfig for precise system clock and HCLK.

Explain configuring system clock with pll using hsi, adjusting apb1/apb2 prescalers, flash latency, and systick via SystemClock_Config; verify sysclk and hclk, and prepare to use hse in the next lecture.

Configure the microcontroller's PLL with an HSE input clock to produce 50 MHz, using a dedicated system clock config function and HSE bypass without calibration.

Configure the PLL to boost the HCLK to the STM32F446RE's 180 MHz maximum using HSE as the PLL source.

Discover how timers in STM32 microcontrollers count from zero to a programmed period, up or down, generating update events and interrupts for timebase, PWM, and ADC/DAC triggering.

Explore timer availability in stm32 mcus, including advanced timers like timer1 and timer8, 32-bit general purpose timers (timer2, timer5) and basic timers like timer6 and timer7.

Explore STM32 basic timer architecture including 16-bit counter, prescaler, and auto-reload register, and learn to generate 100 ms interrupts to toggle a GPIO in the IRQ handler.

Explore how prescaler and period values set the timer base, calculate a 100 ms interval with a 16 MHz clock, and address the 16-bit arr limitation.

Master timer 6 initialization with a 16 MHz clock, tuning prescaler and ARR to fit 64k. Implement HAL_TIM_Base_Init and HAL_TIM_Base_MspInit, enable TIM6 clock and NVIC IRQ 54 with priority 15.

Measure a signal’s time period using a timer’s input capture block with a square wave from LSE or HSI, then infer frequency and understand timer input channels and capture registers.

Explore how input capture on a general purpose timer records rising edges, saves capture values, and computes signal period and frequency from clock pulses using the arr and capture/compare registers.

Learn to measure input frequency or period with the timer input capture by configuring timer2 as the timebase using HAL_TIM_IC_Init and HAL_TIM_IC_ConfigChannel, with a 32-bit up counter and prescaler.

Configure the LSE on MCO1 PA8, verify clock output around 32.79 kHz, and route it to timer 2 channel 1 PA0 to measure the period.

Implement a timer input capture callback to capture CCR values on rising edges, compute the signal period and frequency, and transmit results via UART using HAL on the STM32 timer2.

Perform input capture testing by wiring PA8 to PA0 and observing signal frequency, then adjust the prescaler and switch LSE to HSI to verify 4 MHz timer input.

Configure HSI and divide the clock by four to output 4 MHz on MCO1, analyze input capture interrupts, then generate a 50 kHz test signal with Timer6 for Timer2 capture.

Perform an input capture exercise with a 50 kHz external signal, configuring timer6, starting the timer, and toggling GPIOA pin 5 to verify the measurement.