<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>STM32 on Electronics Lifehack!</title>
    <link>https://electwork.net/en/tags/stm32/</link>
    <description>Recent content in STM32 on Electronics Lifehack!</description>
    <image>
      <title>Electronics Lifehack!</title>
      <url>https://electwork.net/images/ogp-default.jpg?v=3</url>
      <link>https://electwork.net/images/ogp-default.jpg?v=3</link>
    </image>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Mon, 20 Jul 2026 00:00:00 +0900</lastBuildDate><atom:link href="https://electwork.net/en/tags/stm32/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>I2C vs SPI vs UART: Wiring, Speed, and How to Choose</title>
      <link>https://electwork.net/en/posts/i2c-spi-uart-comparison/</link>
      <pubDate>Mon, 20 Jul 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/i2c-spi-uart-comparison/</guid>
      <description>How I2C, SPI and UART differ, compared by signal count, speed, multi-device support and wiring distance. Covers pull-up sizing, SPI modes 0-3 and baud rate, with a decision flow for Arduino, ESP32 and STM32.</description>
    </item>
    
    <item>
      <title>STM32 Series #12: Optimization and Assembly in C</title>
      <link>https://electwork.net/en/posts/stm32-episode12/</link>
      <pubDate>Fri, 08 May 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode12/</guid>
      <description>The final episode: catch the moment C becomes machine code. How GCC optimization (-O0/-O2/-Os) rewrites your code, why forgetting volatile causes a hang, and how to read Thumb-2 instructions with objdump.</description>
    </item>
    
    <item>
      <title>STM32 Linker Script and Map File: Find What Eats Flash/RAM</title>
      <link>https://electwork.net/en/posts/stm32-episode11/</link>
      <pubDate>Sat, 02 May 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode11/</guid>
      <description>Hands-on STM32 linker script and map file walkthrough on a NUCLEO-F401RE: what .text/.data/.bss really are, LMA vs VMA, and reading arm-none-eabi-size to find what eats Flash and RAM.</description>
    </item>
    
    <item>
      <title>STM32 Series #10: DMA — Transfers That Free the CPU</title>
      <link>https://electwork.net/en/posts/stm32-episode10/</link>
      <pubDate>Thu, 30 Apr 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode10/</guid>
      <description>Stop letting UART transmissions stall your main loop — DMA fixes it. From STM32&amp;#39;s bus architecture to transfer-complete callbacks, buffer management, and the D-Cache coherency trap. Episode 10 of the series.</description>
    </item>
    
    <item>
      <title>STM32 Series #9: Interrupt Design Anti-Patterns</title>
      <link>https://electwork.net/en/posts/stm32-episode09/</link>
      <pubDate>Sun, 26 Apr 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode09/</guid>
      <description>Learn STM32 interrupt anti-patterns by deliberately breaking real code: ISR printf deadlock, volatile-missing optimization bugs, I2C timing breakdown, and non-atomic shared variable corruption.</description>
    </item>
    
    <item>
      <title>STM32 Series #8: Interrupts — Vector Table, NVIC, Context</title>
      <link>https://electwork.net/en/posts/stm32-episode08/</link>
      <pubDate>Fri, 17 Apr 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode08/</guid>
      <description>STM32 interrupts on the NUCLEO-F401RE, from zero: vector table structure, NVIC priority, context saving (8 registers auto-pushed to the stack), and a TIM2 periodic interrupt implementation.</description>
    </item>
    
    <item>
      <title>STM32 Series #7: The Weight of a Single Clock Cycle</title>
      <link>https://electwork.net/en/posts/stm32-episode07/</link>
      <pubDate>Wed, 08 Apr 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode07/</guid>
      <description>Measure execution time to µs precision with DWT CYCCNT on the STM32 NUCLEO-F401RE. Covers clock frequency, CPU cycles, how it differs from SysTick, and GPIO toggle plus oscilloscope measurement.</description>
    </item>
    
    <item>
      <title>STM32 Series #6: The Complete Pointer Accident Handbook</title>
      <link>https://electwork.net/en/posts/stm32-episode06/</link>
      <pubDate>Sat, 28 Mar 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode06/</guid>
      <description>Reproduce pointer misuse on the STM32 NUCLEO-F401RE and study six failure modes — HardFault, dangling pointers, stack lifetime, out-of-bounds arrays, undefined behavior, and optimization bugs — in the debugger.</description>
    </item>
    
    <item>
      <title>STM32 Series #5: Pointers as Typed Addresses</title>
      <link>https://electwork.net/en/posts/stm32-episode05/</link>
      <pubDate>Wed, 25 Mar 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode05/</guid>
      <description>C pointers explained as &amp;#39;typed addresses&amp;#39;: declaration, dereferencing, the type-address relationship, casts, and memory-mapped I/O on STM32. See how CMSIS headers abstract registers with pointers.</description>
    </item>
    
    <item>
      <title>STM32 Series #4: The World of Bits — Register Ops and BSRR</title>
      <link>https://electwork.net/en/posts/stm32-episode04/</link>
      <pubDate>Sat, 14 Mar 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode04/</guid>
      <description>Manipulate STM32 (NUCLEO-F401RE) GPIO registers directly: bit masks and shifts, the Read-Modify-Write (RMW) hazard, and the atomic BSRR register. Includes a measured HAL vs register speed comparison.</description>
    </item>
    
    <item>
      <title>STM32 Series #3: Struct Padding and Alignment in Memory</title>
      <link>https://electwork.net/en/posts/stm32-episode03/</link>
      <pubDate>Fri, 06 Mar 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode03/</guid>
      <description>C struct padding and alignment observed in the STM32 debugger&amp;#39;s Memory view: array layout in SRAM, padding bytes between members, sizeof() surprises, volatile, and RAM-saving member reordering.</description>
    </item>
    
    <item>
      <title>STM32 Series #2: Where Variables Live — Flash, RAM, and the Stack</title>
      <link>https://electwork.net/en/posts/stm32-episode02/</link>
      <pubDate>Sun, 01 Mar 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode02/</guid>
      <description>Learn the STM32 memory map (Flash / SRAM / peripheral registers) and watch where variables land. Verify locals on the stack, globals in SRAM, and constants in Flash at real addresses in the debugger.</description>
    </item>
    
    <item>
      <title>STM32 Series #1: The Microcontroller as an Address World</title>
      <link>https://electwork.net/en/posts/stm32-episode01/</link>
      <pubDate>Mon, 23 Feb 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode01/</guid>
      <description>Use STM32CubeIDE&amp;#39;s debugger to watch the microcontroller&amp;#39;s internal state change as a program runs — as concrete addresses. Program counter, peripheral registers, and SRAM variables are all managed by address.</description>
    </item>
    
    <item>
      <title>STM32 Series #0: Why Embedded Programming Looks Hard — Place and Time</title>
      <link>https://electwork.net/en/posts/stm32-episode00/</link>
      <pubDate>Tue, 17 Feb 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-episode00/</guid>
      <description>Why embedded programming seems hard, explained clearly. Pointers, interrupts, DMA and the stack all make sense through two lenses: &amp;#39;place&amp;#39; (memory as a physical location) and &amp;#39;time&amp;#39; (execution timing).</description>
    </item>
    
    <item>
      <title>13-Part Series: The Embedded World Beyond Pointers</title>
      <link>https://electwork.net/en/posts/stm32-series/</link>
      <pubDate>Thu, 12 Feb 2026 00:00:00 +0900</pubDate>
      
      <guid>https://electwork.net/en/posts/stm32-series/</guid>
      <description>Learn embedded fundamentals by digging into the &amp;#39;why&amp;#39; behind Arduino: pointers as typed addresses, registers as bit collections, interrupts as time control. 13 episodes using NUCLEO-F401RE and STM32CubeIDE.</description>
    </item>
    
  </channel>
</rss>
