Stm32World Wiki - User contributions [en]

File:Colibri 8-IO Expansion-LEDs.svg

2026-10-21T09:58:07Z

Niclas: Niclas uploaded a new version of File:Colibri 8-IO Expansion-LEDs.svg

== Summary ==
Schematics for Colibri_8 IO Expansion, LEDs

File:Colibri 8-Power Supply.svg

2026-10-21T09:57:38Z

Niclas: Niclas uploaded a new version of File:Colibri 8-Power Supply.svg

== Summary ==
Colibri 8 powers supply schematics

File:Colibri 8-IO Expansion-X1.svg

2026-10-21T09:57:03Z

Niclas: Niclas uploaded a new version of File:Colibri 8-IO Expansion-X1.svg

== Summary ==
Schematics of the I/O slot on Colibri 8. This is repeated 7 times.

File:Colibri 8-IO Expansion.svg

2026-10-21T09:56:33Z

Niclas: Niclas uploaded a new version of File:Colibri 8-IO Expansion.svg

== Summary ==
Schematics of the I/O subsystem on Colibri 8

File:Colibri 8.svg

2026-10-21T09:55:58Z

Niclas: Schematics of Colibri 8

== Summary ==
Schematics of Colibri 8

Colibri 8

2026-10-21T09:55:41Z

Niclas: /* Schematics */

[[Category:Colibri]][[Category:Work in progress]]{{metadesc|Colibri 8 carrier board}}

DIN-rail mounted Colibri carrier board with 1 MCU slot and 7 I/O clots. MCU slot is to be populated with any of the MCU variants available.
[[File:Colibri_8_photo1.jpg|thumb|250px]]
[[File:Colibri_8_photo2.jpg|thumb|250px]]

= Features =

== MCU slot ==
The MCU slot is the standard [[Colibri MCU slot]] for accepting any of the available MCU modules. The MCU module can
be programmed in many different ways, and see the [[Colibri Programming Languages]] page for details on that.

The MCU in the MCU slot will be the manager of all the hardware resources;
* SPI bus and SPI slot select device
* I2C bus and I2C Mux
* Galvanically Isolated RS-485 port, for SCADA and other supervisory systems.
* 16MB flash memory
* 128kB EEPROM memory
* Temperature and Humidity sensor

== I/O module slots ==
There are seven I/O module slots on this carrier board. Most I/O modules can be used, but there are I/O modules that
will depend on the power supply, for instance [[Colibri Triac1]] will only work if the ''Colibri 8'' are powered by an AC source.
Also [[Colibri DIO1]] must '''NOT''' be used on systems with AC power supply.

== I2C communications ==
The I2C bus from the MCU module must be multiplexed to allow for many I/O modules of the same type to be used in different I/O slots.

The multiplexer is a TCA9548APWR on address 0x70 (0b1110000x), and each bit in the "data byte" written to the multiplexer will enable
that I/O slot's I2C bus. I2C bus 0 is the ''Colibri 8'' carrier board itself, i.e. to the EEPROM. It is important that only one I2C
bus is enable at a time.

== SPI communications ==
Each I/O slot has a SPI Chip Select (CS, active low) individually addressable, and two shared chip selects
(no defined state, I/O module dependent, often unused) for addressing more than one SPI device on a single I/O module.

SPI communications happens at 1Mbps by default.

== I/O slot power ==
Each I/O slot has +3.3V, +5V and +12V available on the connector. On the ''Colibri 8'' the power for +3.3V and +5V can be turned on/off
individually by the MCU, meaning the MCU can for instance turn off the +5V on X2, for instance to re-initialize some circuit.

Additionally, the external power that is used to power the ''Colibri 8'' device is also available on the I/O slot header. This is how some
I/O modules become dependent on the type of power that drives the ''Colibri 8'', for instance the [[Colibri DIO1]] that will malfunction and
possibly break if AC voltage is used.

== Power input ==
The built-in power supply is versatile and accepts either AC or DC voltages, over a vast range;

* 7-36 Volt AC
* 6-50 Volt DC

== USB-C port ==
There is a USB-C port for upstream communication with PC or other devices, typically used for Service and Maintenance.

== Jolt Connect programming header ==
A standard Jolt Connect compatible programming header is available. The device will NOT be powered through that header.

= I2C Addresses =
TCA9548 = 0x70 ; Selects which I/O slot the I2C should be connected to.

; Slot 0 is selected in MUX (TCA9548)
TCA6424 = 0x22 ; IO Expander for RESET, POWER and SPI select
M24M01 = 0x50-0x51 ; 1 Mbit of EEPROM

= Architecture =
[[File:Architecture-colibri-8.svg]]

= Schematics =
<div class="res-img">
[[File:Colibri_8.svg|2400px]]
[[File:Colibri_8-IO_Expansion.svg|2400px]]
[[File:Colibri 8-IO Expansion-X1.svg|2400px]]
[[File:Colibri_8-Power Supply.svg|2400px]]
[[File:Colibri 8-IO Expansion-LEDs.svg|2400px]]
</div>

= Errata =
* In Revision A, the secondary USART on the MCU slot was not yet defined, so the RS-485 transceiver is connected to the programming USART (USART2). This has been corrected for later revisions.

= Documentation =
[[File:Colibri_8-rev_A-schematics.pdf|Colibri 8 Schematics]]

File:Colibri mcu6-rev A-schematics.svg

2026-10-20T12:35:28Z

Niclas: Schematics of Colibri MCU6.

== Summary ==
Schematics of Colibri MCU6.

File:Colibri mcu6-rev A top left render.png

2026-10-20T12:34:48Z

Niclas: Top left Render of Colibri MCU6.

== Summary ==
Top left Render of Colibri MCU6.

File:Colibri mcu6-rev A top right render.png

2026-10-20T12:34:31Z

Niclas: Top tight Render of Colibri MCU6.

== Summary ==
Top tight Render of Colibri MCU6.

File:Colibri mcu6-rev A bot right render.png

2026-10-20T12:34:05Z

Niclas: Niclas uploaded a new version of File:Colibri mcu6-rev A bot right render.png

== Summary ==
Top right Render of Colibri MCU6.

File:Colibri mcu6-rev A bot left render.png

2026-10-20T12:33:11Z

Niclas: Bottom left Render of Colibri MCU6.

== Summary ==
Bottom left Render of Colibri MCU6.

File:Colibri mcu6-rev A bot render.png

2026-10-20T12:32:21Z

Niclas: Bottom Render of Colibri MCU6.

== Summary ==
Bottom Render of Colibri MCU6.

File:Colibri mcu6-rev A bot right render.png

2026-10-20T12:31:44Z

Niclas: Top right Render of Colibri MCU6.

== Summary ==
Top right Render of Colibri MCU6.

File:Colibri mcu6-rev A top render.png

2026-10-20T12:31:14Z

Niclas: Top Render of Colibri MCU6.

== Summary ==
Top Render of Colibri MCU6.

Colibri MCU6

2026-10-20T12:30:10Z

Niclas:

[[Category:Components and Modules]][[Category:Modules]][[Category:Colibri]]{{metadesc|Colibri MCU6 module}}
[[File:Colibri_mcu6-rev_A_top_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_right_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_render.png|thumb]]

[[Colibri]] MCU6 is a processor module for the [[Colibri]] carrier boards, using STM32H735RG and a 16MB external flash for the [[Colibri Runtime]]

= Hardware =
The MCU6 is a relatively simple MCU module, on an M.2 board with the size 22x42mm and the Key E configuration.

Besides the [[STM32H735]] MCU there are also
* 128 Mbits (16MB) flash memory for application use.
* a dual-colored (Green/Red) LED
* 16MHz HSE crystal

'''NOTE: All modules in Colibri are NOT electrically compatible with the M.2 connector standard. DO NOT plug Colibri modules into any M.2 socket other than Colibri (or compatible) ones. And DO NOT plug any M.2 modules (Key E is typically WiFi/BLE) into a Colibri carrier board.

= Programming =
This MCU module is intended to be running the [[Colibri Runtime]] firmware, which will handle the peripherals, the carrier board subsystem, the Comm module and the loading/running the software for the I/O modules mounted on the carrier board. [[Colibri Runtime]] in turn is intended to be programmed with Lua and/or a new exciting [[Colibri-hakkas| visual programming language]] that is in the making.

== Low Level ==
If you intend to program this (i.e. not using [[Colibri Runtime]]), then confer with the schematics below and schematics for the carrier boards, comm modules and I/O modules intended to be used. The standard SWDIO/SWCLK pins are available in the pin header together with UART0 and UART1 for effective low level development environment.

== C/C++ ==
Typically use STM32CubeIDE, CLion or VScode.

= Zephyr =
Zephyr is an MCU-independent embedded OS, with a very modular approach to software, which fits quite well with the modular support of Streamline and Colibri products.

Read more about how [[Colibri Zephyr]] is intended (work in progress) to operate on the [[Colibri]] family.

== Schematics ==

<div class="res-img">
[[File:Colibri_mcu6-rev_A-schematics.svg|2400px]]
</div>

== Gallery ==

<gallery>
File:Colibri_mcu6-rev_A_top_render.png
File:Colibri_mcu6-rev_A_bot_render.png
File:Colibri_mcu6-rev_A_bot_right_render.png
File:Colibri_mcu6-rev_A_bot_left_render.png
File:Colibri_mcu6-rev_A_top_right_render.png
File:Colibri_mcu6-rev_A_top_left_render.png
</gallery>

Colibri MCU6

2026-10-20T12:28:38Z

Niclas:

[[Category:Components and Modules]][[Category:Modules]][[Category:Colibri]]{{metadesc|Colibri MCU6 module}}
[[File:Colibri_mcu6-rev_A_top_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_right_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_render.png|thumb]]

[[Colibri]] MCU6 is a processor module for the [[Colibri]] carrier boards, using STM32H735RG and a 16MB external flash for the [[Colibri Runtime]]

= Hardware =
The MCU6 is a relatively simple MCU module, on an M.2 board with the size 22x42mm and the Key E configuration.

Besides the [[STM32H735]] MCU there are also
* 128 Mbits (16MB) flash memory for application use.
* a dual-colored (Green/Red) LED
* 16MHz HSE crystal

'''NOTE: All modules in Colibri are NOT electrically compatible with the M.2 connector standard. DO NOT plug Colibri modules into any M.2 socket other than Colibri (or compatible) ones. And DO NOT plug any M.2 modules (Key E is typically WiFi/BLE) into a Colibri carrier board.

= Programming =
This MCU module is intended to be running the [Colibri Runtime] firmware, which will handle the peripherals, the carrier board subsystem, the Comm module and the loading/running the software for the I/O modules mounted on the carrier board. [Colibri Runtime] in turn is intended to be programmed with Lua and/or a new exciting [Colibri-hakkas] visual programming language] that is in the making.

== Low Level ==
If you intend to program this (i.e. not using [[Colibri Runtime]]), then confer with the schematics below and schematics for the carrier boards, comm modules and I/O modules intended to be used. The standard SWDIO/SWCLK pins are available in the pin header together with UART0 and UART1 for effective low level development environment.

== C/C++ ==
Typically use STM32CubeIDE, CLion or VScode.

= Zephyr =
Zephyr is an MCU-independent embedded OS, with a very modular approach to software, which fits quite well with the modular support of Streamline and Colibri products.

Read more about how [[Colibri Zephyr]] is intended (work in progress) to operate on the [[Colibri]] family.

== Schematics ==

<div class="res-img">
[[File:Colibri_mcu6-rev_A-schematics.svg|2400px]]
</div>

== Gallery ==

<gallery>
File:Colibri_mcu6-rev_A_top_render.png
File:Colibri_mcu6-rev_A_bot_render.png
File:Colibri_mcu6-rev_A_bot_right_render.png
File:Colibri_mcu6-rev_A_bot_left_render.png
File:Colibri_mcu6-rev_A_top_right_render.png
File:Colibri_mcu6-rev_A_top_left_render.png
</gallery>

Colibri MCU6

2026-10-20T12:28:10Z

Niclas: Created page with "Category:Components and ModulesCategory:ModulesCategory:Colibri{{metadesc|Colibri MCU6 module}} thumb File:Colibri_mcu..."

[[Category:Components and Modules]][[Category:Modules]][[Category:Colibri]]{{metadesc|Colibri MCU6 module}}
[[File:Colibri_mcu6-rev_A_top_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_right_render.png|thumb]]
[[File:Colibri_mcu6-rev_A_bot_render.png|thumb]]

[[Colibri]] MCU6 is a processor module for the [[Colibri]] carrier boards, using STM32H735RG and a 16MB external flash for the [[Colibri Runtime]]

= Hardware =
The MCU6 is a relatively simple MCU module, on an M.2 board with the size 22x42mm and the Key E configuration.

Besides the [[STM32H735]] MCU there are also
* 128 Mbits (16MB) flash memory for application use.
* a dual-colored (Green/Red) LED
* 16MHz HSE crystal

'''NOTE: All modules in Colibri are NOT electrically compatible with the M.2 connector standard. DO NOT plug Colibri modules into any M.2 socket other than Colibri (or compatible) ones. And DO NOT plug any M.2 modules (Key E is typically WiFi/BLE) into a Colibri carrier board.

= Programming =
This MCU module is intended to be running the [Colibri Runtime] firmware, which will handle the peripherals, the carrier board subsystem, the Comm module and the loading/running the software for the I/O modules mounted on the carrier board. [Colibri Runtime] in turn is intended to be programmed with Lua and/or a new exciting [[Colibri-hakkas] visual programming language] that is in the making.

== Low Level ==
If you intend to program this (i.e. not using [[Colibri Runtime]]), then confer with the schematics below and schematics for the carrier boards, comm modules and I/O modules intended to be used. The standard SWDIO/SWCLK pins are available in the pin header together with UART0 and UART1 for effective low level development environment.

== C/C++ ==
Typically use STM32CubeIDE, CLion or VScode.

= Zephyr =
Zephyr is an MCU-independent embedded OS, with a very modular approach to software, which fits quite well with the modular support of Streamline and Colibri products.

Read more about how [[Colibri Zephyr]] is intended (work in progress) to operate on the [[Colibri]] family.

== Schematics ==

<div class="res-img">
[[File:Colibri_mcu6-rev_A-schematics.svg|2400px]]
</div>

== Gallery ==

<gallery>
File:Colibri_mcu6-rev_A_top_render.png
File:Colibri_mcu6-rev_A_bot_render.png
File:Colibri_mcu6-rev_A_bot_right_render.png
File:Colibri_mcu6-rev_A_bot_left_render.png
File:Colibri_mcu6-rev_A_top_right_render.png
File:Colibri_mcu6-rev_A_top_left_render.png
</gallery>

Colibri

2026-10-14T05:39:32Z

Niclas: /* Modules & Carriers */

[[Category:Colibri]][[Category:Work in progress]]{{metadesc|Colibri Automation System}}

<div class="thumb tright">
<div class="thumbinner" style="width: 250px;">
<div style="width: 250px; height: 150px; overflow: hidden; position: relative; background: #000;">
<div style="position: absolute; top: -20px; left: -15px;">
[[File:Colibri_8_photo1.jpg|250px|link=File:Colibri_8_photo1.jpg|alt=Colibri 8 PCB]]
</div>
</div>
</div>
</div>
[[File:Colibri-3-6.jpg|thumb|250px]]
[[File:Colibri_3a_photo1.jpg|thumb|250px]]
[[File:Colibri rs485u-2.jpg|180px|thumb]]
[[File:Colibri aic-RevA-2.jpg|180px|thumb]]

Check out the [[Colibri Videos]] on Youtube.

Colibri is a low-cost automation system, primarily intended for building automation, home automation, energy supervision, agriculture supervision and similar systems. Main features beside costs are;
* Flexible I/O system, via MCU modules, Comm modules and I/O modules in M.2 Key E sockets. Many types already developed.
* Power supply of 9-36 Volt, either AC or DC (some I/O cards won't work with DC supply, and some not with AC supply)
* Each I/O slot can be powered-up/down individually from the MCU.
* Each I/O slot is addressable individually.
* MCU communicates with each I/O slot via I2C and/or SPI. The I2C bus is multiplexed to avoid address collision. SPI uses one Chip Select per I/O slot and 2 additional Chip Select if multi SPI devices are on a single I/O module.
* Each I/O module has an 1Mbit EEPROM with calibration parameters and a program for the MCU module to execute. This is accomplished with "PIC" (Position Independent Code) and executing from RAM.
* Some I/O modules have on-board secondary processors for time-critical or other reasons, for instance RS-485 communication, digital inputs (pulse counting) and PID regulator.

== Architecture Overview ==
<div class="res-img">
[[File:Colibri_Architecture-1.svg|240px]]
</div>

Colors in this view represents who creates the software for each part.

== Programming ==
The Colibri system is designed around two main external projects, [[Colibri Zephyr|Zephyr]] and [http://www.lua.org Lua].

Zephyr provides a lot of ''operating system'' type of features, like task scheduling, concurrency data types, timers, peripheral drivers and cross-platform compatibility to be able to support STM32, RP2354 and possibly other MCU families.

We experimented a bit with WebAssembly, but found the practical barrier a bit too high as well as memory footprint is much more difficult to manage.

Without WebAssembly we are still able to allow for;
* I/O modules that are unknown to the MCU module to be installed without re-flashing the firmware (using PIC)
* Uploading of user programs, without flashing the firmware, upload Lua text files
* Sandboxed execution to limit issues that user programs can create,
* Simplified tool chain,

The WebAssembly approach might be revisited in the future.

== Carrier Boards ==
* ''Colibri 3a'' has 2 I/O slots and one MCU slot, one USB-C port to the MCU slot, Jolt Connect pin header for programming. (Postponed to be re-evaluated)
* ''Colibri 8'' has 7 I/O slots, a Communcation slot, MCU slot, one USB-C port to the MCU slot, Jolt Connect pin header for programming.
* Planned; ''Colibri 8pi'' is like the ''Colibri 8'' but with a full-fledged Raspberry Pi Compute Module 5. 1 Colibri MCU slot, Comm slot and 7 I/O slots,
* Planned; ''Colibri 16pi'' is like the ''Colibri 8pi'', but with 15 I/O slots rather than 7.

== MCU Modules ==
There is a choice, and more will follow;

* ''[[Colibri MCU1]]'' - (deprecated) MCU module with a STM32WLE5, 256kB Flash, 64kB RAM, on-chip LoRa and LoraWAN protocol available in STM32CubeMX.
* ''[[Colibri MCU2]]'' - MCU module with a STM32H562RG, 1024kB Flash, 640kB RAM and a 16MB external flash memory.
* ''[[Colibri MCU3]]'' - (deprecated) MCU module with a STM32F405RG, 1MB Flash, 192kB+4kB RAM and a 16MB external flash memory.
* ''[[Colibri MCU4]]'' - (deprecated) MCU module with a STM32L475RG, 1MB Flash, 128kB RAM and a 16MB external flash memory.
* ''[[Colibri MCU5]]'' - (deprecated) MCU module with a STM32F103RE, 512kB Flash and 64kB RAM. No external flash memory.
* ''[[Colibri MCU7]]'' - MCU module with a RP2350A, 16MB external Flash and 520kB RAM

== Comm Modules ==
Comm modules exist to establish a communication link with the device in one of the currently 4 planned types;

* ''[[Colibri Comm Ethernet]]'' - TCP/IP communications, incl Modbus/TCP, MQTT and HTTPS.
* ''[[Colibri Comm LoraWAN]]'' - LoraWAN, primarily to report sensor data and status.
* ''[[Colibri Comm RS485]]'' - For RS485-based protocols, primarily Modbus, but potentially BACnet and others.
* ''[[Colibri Comm WiFi]]'' - Wireless TCP/IP communications, incl Modbus/TCP, MQTT and HTTPS.

== I/O Modules ==
The Colibri system is based around the M.2 connector and a non-standard bus for I2C and SPI communications. Each I/O module has an [[Colibri_EEPROM_Layout|EEPROM memory]] available to identify which module is present in each I/O slot, links to documentation, calibration parameters, testing results and (up to) 8kB of C code for the MCU module to execute.

== [[Colibri Form Factor|Form Factor]] ==

Both Colibri I/O modules, Comm modules and MCU modules are 22x42mm and has an edge connector called M.2 Key E, '''but it doesn't follow the M.2 specification for Key E'''. The distance between the I/O slots are specified to 23.5mm, theoretically making it possible for multi-slot I/O modules (none are planned).

The Comm module MUST be have a free zone of at least 5mm between its edge and the edge of the next modules on either side.

<span style="color:#FF4444">'''WARNING!!! Do NOT plug Colibri I/O modules nor any MCU module into other equipment. Do NOT plug any M.2 card into a Colibri system, unless that card/board is specifically made for Colibri.'''</span>

== Modules & Carriers ==

{| class=wikitable
|-
! Name
! Type
! Description
! Status
|-
| ''[[Colibri 3a]]''
| Carrier
| Minimal Colibri carrier board with 2 I/O slots and one MCU slot. MCU slot is to be populated with any of the MCU variants available.
| Deprecated, on hold.
|-
| ''[[Colibri 8]]''
| Carrier
| Colibri carrier board with Colibri MCU slot and 7 Colibri I/O slots. A galvanically isolated RS-485 port connected to the secondary USART of the MCU slot.
| Early Access
|-
| ''[[Colibri-8pi]]''
| Carrier
| Colibri carrier board with Raspberry Pi CM5, Colibri MCU slot, 7 Colibri I/O slots, two Ethernet ports, 3 USB ports and SDcard connector.
| Planned
|-
| ''[[Colibri-16pi]]''
| Carrier
| Colibri carrier board with Raspberry Pi CM5, Colibri MCU slot, 15 Colibri I/O slots, two Ethernet ports, 3 USB ports and SDcard connector.
| Planned
|-
| ''[[Colibri 1dp]]''
| Carrier
| Minimal Colibri Host with a single MCU slot and 0-500Pa air pressure sensor.
| Prototype - Re-evaluated after introduction of Comm modules.
|-
| ''[[Colibri MCU2]]''
| MCU module
| MCU module with a STM32H562RG and a 16MB flash memory.
| Active
|-
| ''[[Colibri MCU7]]''
| MCU module
| MCU module with a Raspberry Pi RP2354B and a 16MB flash memory.
| Designed
|-
| ''[[Colibri Comm Ethernet]]''
| Comm module
| TCP/IP communications, incl Modbus/TCP, MQTT and HTTPS.
| Designed
|-
| ''[[Colibri Comm LoraWAN]]''
| Comm module
| LoraWAN, primarily to report sensor data and status.
| Designed
|-
| ''[[Colibri Comm RS485]]''
| Comm module
| For RS485-based protocols, primarily Modbus, but potentially BACnet and others.
| Designed
|-
| ''[[Colibri Comm WiFi]]''
| Comm module
| Wireless TCP/IP communications, incl Modbus/TCP, MQTT and HTTPS.
| Designed
|-
| ''[[M.2 E Breakout]]''
| M.2 breakout board
| Generic breakout board for M.2 E key boards.
| Active
|-
| ''[[Colibri AIC]]''
| I/O module
| Two analog 0-20mA inputs
| Active
|-
| ''[[Colibri AIV]]''
| I/O module
| Two analog 0-10V inputs
| Active
|-
| ''[[Colibri AQV]]''
| I/O module
| Two analog 0-10V outputs
| Active
|-
| ''[[Colibri DII]]''
| I/O module
| Two ISOLATED digital inputs, for state, counter, pulsewidth measurement. On-board STM32C071 for ability to count very fast pulses and high accuracy PWM measurements.
| Designed
|-
| ''[[Colibri DIO1]]''
| I/O module
| IEC 61131-2 compliant, 4-channels digital inputs and outputs.
| Active
|-
| ''[[Colibri DIU]]''
| I/O module
| Four digital inputs, for state, counter, pulsewidth measurement. On-board STM32C071 for ability to count very fast pulses and high accuracy PWM measurements.
| Designed
|-
| ''[[Colibri DP1]]''
| I/O module
| A 0-500Pa air pressure sensor mounted on I/O module.
| Designed
|-
| ''[[Colibri DP2]]''
| I/O module
| A 0-10kPa air pressure sensor mounted on I/O module.
| Planned
|-
| ''[[Colibri DP3]]''
| I/O module
| A 0-100kPa air pressure sensor mounted on I/O module.
| Planned
|-
| ''[[Colibri Fallback]]''
| I/O module
| Single SPDT relay
| Designed
|-
| ''[[Colibri FET]]''
| I/O module
| Four digital outputs, FET outputs sinking to GND. Max 1 Amp per channel.
| Designed
|-
| ''[[Colibri PID1]]''
| I/O module
| PID regulator, with a PT1000 input and a 0-10V analog output. On-board STM32C071 for host-independent operation.
| Prototype
|-
| ''[[Colibri Pt100]]''
| I/O module
| One port for 3-wire or 4-wire Pt100 temperature sensor.
| Designed
|-
| ''[[Colibri Pt1000]]''
| I/O module
| Two PT1000 temperature sensor inputs.
| Prototype
|-
| ''[[Colibri RS485I]]''
| I/O module
| Isolated RS-485 port. On-board STM32C071 to implement protocols, such as Modbus RTU.
| Designed
|-
| ''[[Colibri RS485U]]''
| I/O module
| Two non-isolated RS-485 ports. On-board STM32C071 implementing Modbus protocol.
| Designed
|-
| ''[[Colibri SSR]]''
| I/O module
| Two Solid State Relays, ON/OFF.
| Prototype
|-
| ''[[Colibri TRIAC1]]''
| I/O module
| Four Triac outputs, driving 24V AC.
| Prototype
|}

= License =
All Schematics are licensed with the GPLv3, meaning that you are free to make your own designs or manufacture devices using these. We expect that if you derive new design, that you publish these, preferably on this website.

The software will also be published with GPLv3, when something is workable.

= Resources =

Colibri Relay

2026-10-06T10:15:15Z

Niclas:

[[Category:Colibri]]{{metadesc|Colibri Relay module}}
[[File:Colibri_relay-rev_A_top_render.png|thumb]]

Colibri Relay is an digital output I/O module with one SPDT (single-pole, dual-throw) relay.

=== What about that name? ===
We have extensively used this in HVAC renovation projects, where the customer wants to keep the previous system in place, as an insurance against we going out of business, something breaks or in case the software goes haywire. So, we connect the valve to pin "b", the Colibri output signal on pin "a" and the old system's output signal on pin "c". We can remotely control if we want to swap over to previous system, or if the owners wants to do it, they just turn the Colibri system OFF.

=== I2C Addresses ===
M24M01 = 0x50-0x51
PCA9536 = 0x41

= EEPROM factory layout =

See the [[Colibri EEPROM Layout]] page for the full picture.

== Calibration data in EEPROM ==
Work in progress. Not available in product if ordered now.

{| class=wikitable
|-
! Address
! Length
! Description
|}

== Test Report ==
Work in progress. Not available in product if ordered now.

{| class=wikitable
|-
! Address
! Length
! Description
|-
| 0x0100
| 4
| Year * 12 + month
|-
| 0x0104
| 4
| Date * 24 + hour
|-
| 0x0108
| 8
| Reserved for future use.
|-
| 0x0110
| 4
| EEPROM write/read/erase test. 32 cycles. Each cycle is represented in one bit. 0=Success, 1=Fail.
|}

== Schematics ==
<div class="res-img">
[[File:Colibri_relay-rev_A-schematics.svg|2400px]]
</div>

== Gallery ==
<gallery>
File:Colibri_relay-rev_A_top_render.png
File:Colibri_relay-rev_A_bot_render.png
File:Colibri_relay-rev_A_top_right_render.png
File:Colibri_relay-rev_A_top_left_render.png
</gallery>

Colibri Fallback

2026-10-06T10:13:58Z

Niclas: Niclas moved page Colibri Fallback to Colibri Relay: Fallback is a legacy name and too narrow.

#REDIRECT [[Colibri Relay]]

Colibri Relay

2026-10-06T10:13:58Z

Niclas: Niclas moved page Colibri Fallback to Colibri Relay: Fallback is a legacy name and too narrow.

[[Category:Colibri]]{{metadesc|Colibri Fallback module}}
[[File:Colibri_fallback-rev_A_top_render.png|thumb]]

Colibri Fallback is an digital output I/O module with one SPDT (single-pole, dual-throw) relay.

=== What about that name? ===
We have extensively used this in HVAC renovation projects, where the customer wants to keep the previous system in place, as an insurance against we going out of business, something breaks or in case the software goes haywire. So, we connect the valve to pin "b", the Colibri output signal on pin "a" and the old system's output signal on pin "c". We can remotely control if we want to swap over to previous system, or if the owners wants to do it, they just turn the Colibri system OFF.

=== I2C Addresses ===
M24M01 = 0x50-0x51
PCA9536 = 0x41

= EEPROM factory layout =

See the [[Colibri EEPROM Layout]] page for the full picture.

== Calibration data in EEPROM ==
Work in progress. Not available in product if ordered now.

{| class=wikitable
|-
! Address
! Length
! Description
|}

== Test Report ==
Work in progress. Not available in product if ordered now.

{| class=wikitable
|-
! Address
! Length
! Description
|-
| 0x0100
| 4
| Year * 12 + month
|-
| 0x0104
| 4
| Date * 24 + hour
|-
| 0x0108
| 8
| Reserved for future use.
|-
| 0x0110
| 4
| EEPROM write/read/erase test. 32 cycles. Each cycle is represented in one bit. 0=Success, 1=Fail.
|}

== Schematics ==
<div class="res-img">
[[File:Colibri_fallback-rev_A-schematics.svg|2400px]]
</div>

== Gallery ==
<gallery>
File:Colibri_fallback-rev_A_top_render.png
File:Colibri_fallback-rev_A_bot_render.png
File:Colibri_fallback-rev_A_top_right_render.png
File:Colibri_fallback-rev_A_top_left_render.png
</gallery>

Colibri Tutorial

2026-10-06T09:59:24Z

Niclas: Created page with "Category:Work in progress{{metadesc|Colibri Automation System}} <div class="thumb tright"> <div class="thumbinner" style="width: 250px;"> <div style="width: 250px;..."

[[Category:Work in progress]]{{metadesc|Colibri Automation System}}

<div class="thumb tright">
<div class="thumbinner" style="width: 250px;">
<div style="width: 250px; height: 150px; overflow: hidden; position: relative; background: #000;">
<div style="position: absolute; top: -20px; left: -15px;">
[[File:Colibri_8_photo1.jpg|250px|link=File:Colibri_8_photo1.jpg|alt=Colibri 8 PCB]]
</div>
</div>
</div>
</div>
[[File:Colibri-3-6.jpg|thumb|250px]]
[[File:Colibri_3a_photo1.jpg|thumb|250px]]
[[File:Colibri rs485u-2.jpg|180px|thumb]]
[[File:Colibri aic-RevA-2.jpg|180px|thumb]]

= Tutorial Overview =

* [[Colibri Tutorial - Requirements|Requirements]] - Requirements for Hardware and Software
* [[Colibri Tutorial - Design|Design]] - Solutions for the Requirements in Hardware and Software
* [[Colibri Tutorial - Architecture|Architecture]] - Details of Software Architecture
* [[Colibri Tutorial - Colibri 3b|Colibri 3b carrier board]] - Features and functions of the Colibri 3b carrier board.
* [[Colibri Tutorial - Colibri MCU2|Colibri MCU2, MCU module with STM32H562 ]] -
* [[Colibri Tutorial - Colibri Relay|Colibri Relay, One SPDT relay]] -
* [[Colibri Tutorial - Colibri AQV|Colibri AQV, Two 0-10V analog outputs]] -
* [[Colibri Tutorial - Colibri AIV|Colibri AIV, Two 0-10V analog inputs]] -
* [[Colibri Tutorial - Colibri Comm Ethernet|Colibri Comm Ethernet, Comm module with Ethernet ]] -
* [[Colibri Tutorial - Colibri AIC|Colibri AIC, Two 0-20mA analog outputs]] -
* [[Colibri Tutorial - Colibri Pt1000|Colibri Pt1000, Two Pt1000 inputs]] -
* [[Colibri Tutorial - Colibri Comm RS485|Colibri Comm RS485, Comm module with isolated RS485 ]] -
* [[Colibri Tutorial - Colibri SSR|Colibri SSR, Two Solid State Relays ]] -
* [[Colibri Tutorial - Colibri FET|Colibri FET, Four digital sink outputs]] -
* [[Colibri Tutorial - Colibri 8|Colibri 8 carrier board]] - Features and functions of the Colibri 8 carrier board.
* [[Colibri Tutorial - Colibri DIO1|Colibri DIO1, Four IEC61131-2 compliant inputs/outputs]] -
* [[Colibri Tutorial - Colibri Comm Lora|Colibri Comm Lora, Comm module with LoraWan ]] -
* [[Colibri Tutorial - Colibri DIU|Colibri DIU, Four non-isolated digital inputs]] -
* [[Colibri Tutorial - Colibri DII|Colibri DII, Two isolated digital inputs]] -
* [[Colibri Tutorial - Colibri MCU6|Colibri MCU6, MCU module with STM32H735 ]] -
* [[Colibri Tutorial - Colibri PID1|Colibri PID1, PID regulator, Pt1000 to 0-10V output ]] -
* [[Colibri Tutorial - Colibri Pt100|Colibri Pt100, One 3-wire or 4-wire Pt100 input]] -
* [[Colibri Tutorial - Colibri Comm Wifi|Colibri Comm Wifi, Comm module with Wifi ]] -
* [[Colibri Tutorial - Colibri RS485u|Colibri RS485u, Two non-isolated RS485 transceivers ]] -
* [[Colibri Tutorial - Colibri RS485i|Colibri RS485i, One isolated RS485 transceiver ]] -
* [[Colibri Tutorial - Colibri DP1|Colibri DP1, 0-500Pa pressure sensor]] -
* [[Colibri Tutorial - Colibri MCU7|Colibri MCU7, MCU module with RP2350 ]] -
* [[Colibri Tutorial - Colibri Triac1|Colibri Triac1, Four Triac outputs ]] -

Streamline

2026-10-02T06:08:43Z

Niclas: /* Miscellaneous */

[[Category:STM32]][[Category:Streamline]][[Category:CurrentMakers]][[Category:Work in progress]]{{metadesc|Streamline Development Boards Home}}
[[File:Streamline Backplane with 2 blades - top right 3.jpg|300px|thumb|Streamline Backplane with 2 blades - 1 Connect and 1 MCU]]
This page documents the new [[CurrentMakers]] [[Streamline]] series of [[Green]] development boards. If you are looking for the previous series, that is document here: [[STM32World Legacy]].

[[Streamline]] boards are available here: [https://currentmakers.com/products/streamline/ Streamline on CurrentMakers]

{{clear}}
== Rationale ==
[[File:3 STM32World Modules stacked.jpg|300px|thumb]]
A number of [[STM32World Legacy]] boards have been developed, and produced, and in general the "system" worked very well. It did however have one fatal flaw which was the sole cause of it never being considered for more widespread production. This flaw was the board to board connector.

The original boards used a 2x20 standard pin header on each side giving a result of 80 pins. In terms of connectivity this was a pretty good solution. It did however present some issues:

# Cost - the long pin 2x20 connectors are fairly expensive - around $0.80 each - so $1.60 per board. This may not sound that high but when producing a lot it becomes a serious cost.
# Manufacturing - the headers can not be manufactured with traditional SMD technologies but require a manual step or hand soldering.
# Fragile - when shipping or disconnecting boards it is hard not to bend one or more pins and once bend it becomes extremely difficult to reconnect them.

To get around this flaw a new "connector" was considered and after a long search the best solution was the standard PCI-E X8 connector.

== Videos ==

{{#ev:youtube|5xQqV7BhYxM}}

Receiving the first prototypes ever:

{{#ev:youtube|YS1w_8ghCf4}}

== Backplane ==

The overall idea is to base [[StreamLine]] around a passive backplane. The backplane contains a number of PCI connectors with 2 x 49 pins (98) that is simply connected in a parallel bus.

<div class="res-img">
[[File:Sl bp 5 top left.png|1000px]]
</div>

In each end of the bus all the A and B signals are broken out into regular pin headers.

=== Backplane rendering ===

<gallery>
File:Backplane top render.png
File:Backplane front render.png
File:Backplane front left render.png
File:Sl bp 5 top.png
File:Sl bp 5 top left.png
File:Sl bp 5 top right.png
</gallery>

== Modules ==

=== [[Backplane]]s ===

{| class="wikitable"
|-
! Name
! Image
! Description
! Status
|-
| [[Streamline Backplane 5]]
| [[File:sl_bp_5_top_left.png|80px]]
| Basic 5 position backplane
| [https://currentmakers.com/products/streamline/streamline_backplane_5/ Available]
|}

=== [[Blade]]s ===

==== STM32 ====

{| class="wikitable"
|-
! Name
! Image
! Description
! Status
|-
| [[Streamline Connect]] (ST-Link firmware)
| [[File:Sl prog top left render.png|80px]]
| Streamline Programmer & Debugger. This module is essentially identical to [[Jolt Connect]]
| [https://currentmakers.com/products/streamline/streamline_connect/ Available]
|-
| [[Streamline MCU STM32F407]]
| [[File:Sl mcu stm32f407 top left render.png|80px]]
| Streamline MCU board including a [[STM32F407]]
| [https://currentmakers.com/products/streamline/streamline_mcu_stm32f407/ Available]
|-
| [[Streamline MCU STM32H562]]
| [[File:Sl mcu stm32h562 top left render.png|80px]]
| Streamline MCU board including a [[STM32H562]]
| [https://currentmakers.com/products/streamline/streamline_mcu_stm32h562/ Available]
|-
| [[Streamline MCU STM32L475]]
| [[File:Sl mcu stm32l475 top left render.png|80px]]
| Streamline MCU board including a [[STM32L475]]
| [https://currentmakers.com/products/streamline/streamline_mcu_stm32l475/ Available]
|-
| [[Streamline MCU STM32C551]]
| [[File:Sl_mcu_stm32c551_top_left_render.png|80px]]
| Streamline MCU board including a [[STM32C551]]
| [https://currentmakers.com/products/streamline/streamline_mcu_stm32c551/ Available]
|-
| [[Streamline MCU STM32H723]]
| [[File:Sl_mcu_stm32h723_top_left_render.png|80px]]
| Streamline MCU board including a STM32H723
| Prototype
|}

==== Other MCU's ====

{| class="wikitable"
|-
! Name
! Image
! Description
! Status
|-
| [[Streamline Connect]] (DAPlink FIrmware)
| [[File:Sl prog top left render.png|80px]]
| Streamline Programmer & Debugger. This module is essentially identical to [[Jolt Connect]]
| [https://currentmakers.com/products/streamline/streamline_connect/ Available]
|-
| [[Streamline MCU RP2354]]
| [[File:Sl mcu rp2354 top left render.png|80px]]
| Streamline MCU board including a [[RP2354]]
| [https://currentmakers.com/products/streamline/streamline_mcu_rp2354/ Available]
|-
| [[Streamline MCU ESP32S6]]
| [[File:Sl mcu esp32s6 top left render.png|80px]]
| Streamline MCU board including a [[ESP32S6]]
| Planned
|}

==== Miscellaneous ====

{| class="wikitable"
|-
! Name
! Image
! Description
! Status
|-
| [[Streamline Neopixel 8x8]]
| [[File:Sl neopixel 8x8 top left render.png|80px]]
| Module with an 8x8 matrix of Neopixel WS2812 LEDs
| [https://currentmakers.com/products/streamline/streamline_neopixel_8x8/ Available]
|-
| [[Streamline Storage SD]]
| [[File:Sl storage sd top left render rev A.png|80px]]
| Module with Micro-SD slot
| [https://currentmakers.com/products/streamline/streamline_sd/ Available]
|-
| [[Streamline Storage Flash]]
| [[File:Sl storage flash top left render.png|80px]]
| Module with 16 MB Flash storage ([[W25q128]])
| [https://currentmakers.com/products/streamline/streamline_flash/ Available]
|-
| [[Streamline Storage EEPROM]]
| [[File:Sl storage eeprom top left render.png|80px]]
| Module with 512kB EEPROM storage ([[M24M01]])
| [https://currentmakers.com/products/streamline/streamline_eeprom/ Available]
|-
| [[Streamline IO Audio DAC]]
| [[File:Sl_io_pcm5102_top_left_render.png|80px]]
| PCM5102 I2S Audio DAC
| [https://currentmakers.com/products/streamline/streamline_io_audio_dac/ Available]
|-
| [[Streamline IO CAN]]
| [[File:Sl_io_can_top_left_render.png|80px]]
| CAN bus interface
| [https://currentmakers.com/products/streamline/streamline_io_can/ Available]
|-
| [[Streamline Ethernet]]
| [[File:Streamline_ethernet_top_left_render.png|80px]]
| Ethernet interface for STM32F407
| [https://currentmakers.com/products/streamline/streamline_ethernet/ Available]
|-
| [[Streamline SPI-Ethernet]]
| [[File:Streamline_seth_top_left_render.png|80px]]
| Ethernet interface via the SPI bus
| Prototype
|-
| [[Streamline RS485]]
| [[File:Streamline_rs485_top_left_render.png|80px]]
| Non-isolated RS485 interface
| Prototype
|-
| Streamline Real Time Clock
|
| Real time clock with on board coin cell battery (or supercap) backup
| Idea
|-
| Streamline ESC
|
| Electronic speed control for BLDC motors
| Idea
|-
| Streamline HS USB
|
| HS USB blade using [[USB3300]]
| Idea
|-
| Streamline WiFi
|
| WiFi interface
| Idea
|-
| Streamline Temperature/Humidity
|
| Sensor of temperature and humidity
| Idea
|-
| Streamline Compass
|
| Compass
| Idea
|-
| Streamline Gyro
|
| Gyro
| Idea
|-
| Streamline Accelerometer
|
| Accelerometer
| Idea
|-
| Streamline GPS
|
| GPS
| Idea
|-
| Streamline FM Radio
|
| FM and DAB radio receiver
| Idea
|}

== Standard Pinout ==

The pinout table is based on a [[MCU]] board with a 100 pin STM32F407. Boards using [[STM32]] [[MCU]]s with less pins will leave some of the pins unused.

* [[Streamline Peripheral Pin Mapping]] - peripheral-by-peripheral pin mapping.
* [[Streamline Header Mapping]] - Backplane-to-GPIO and GPIO-to-Backplane mapping.

== Prototype Photos ==

<gallery>
File:Streamline Backplane with 2 blades - top right 3.jpg
File:Streamline Backplane with 2 blades - top right 2.jpg
File:Streamline Backplane with 2 blades - top right.jpg
File:Streamline Backplane with 2 blades - top left.jpg
File:Streamline Backplane with 2 blades - front.jpg
File:Streamline Multiple Blades.jpg
File:Streamline MCU STM32L475 - top view.jpg
File:Streamline MCU STM32L475 - bottom view.jpg
File:Streamline MCU STM32H562 - top view.jpg
File:Streamline MCU STM32H562 - bottom view.jpg
File:Streamline MCU STM32F407 - top view.jpg
File:Streamline MCU STM32F407 - bottom view.jpg
File:Streamline Connect - top view.jpg
File:Streamline Connect - bottom view.jpg
</gallery>

== Miscellaneous Links ==

* [https://currentmakers.com CurrentMakers main site]
* [https://github.com/currentmakers/streamline_kicad_libraries Streamline KiCAD Libraries]

Streamline Peripheral Pin Mapping

2026-09-26T07:42:33Z

Niclas: /* SWD */

[[Category:Streamline]][[Category:Work in progress]]

== General notes ==
<span style="background:#0C0">field</span> means that all MCUs can be mapped identically.

<span style="background:#CC0">field</span> means it is missing the peripheral.

<span style="background:#F44">field</span> means that pins are not same across all MCUs.

<span style="background:#0FF">field</span> is I2Sx_MCK only exist on one pin.

=== RP2350 ===

Trying to avoid 12 - 19 as these can be used for HSTX but they should be wired to backplane.

== LED & Button ==
{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="3" | All
| bgcolor=#0C0|LED
| PC13
| PC13
| PC13
| PC13
| PC13
| PC13
| GPIO37
|-
| bgcolor=#0C0|Button
| PC15
| PC15
| PC15
| PC15
| PC15
| PC15
| GPIO47
|}

== SWD ==

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="3" | All
| bgcolor=#0C0|SWDIO
| PA13
| PA13
| PA13
| PA13
| PA13
| PA13
| SWDIO
| rowspan="2" | RP Pico Dedicated pin
|-
| bgcolor=#0C0|SWCLK
| PA14
| PA14
| PA14
| PA14
| PA14
| PA14
| SWCLK
|-
| bgcolor=#CC0|SWO
| PB3
| PB3
| PB3
| bgcolor=#CC0|N/A
| PB3
| PB3
| TBD
| N/A
|}

== UARTs ==

{| class="wikitable sortable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="2" | USART1
| bgcolor=#0C0|TX
| PA9
| PA9
| PA9
| PA9
| PA9
| PA9
| GPIO0
| rowspan="2" | Connect default<br/>RP2350 UART0
|-
| bgcolor=#0C0|RX
| PA10
| PA10
| PA10
| PA10
| PA10
| PA10
| GPIO1
|-
| rowspan="2" | USART1A
| bgcolor=#0C0|TX
| PB6
| PB6
| PB6
| PB6
| PB6
| PB6
|
| rowspan="2" |
|-
| bgcolor=#0C0|RX
| PB7
| PB7
| PB7
| PB7
| PB7
| PB7
|
|-
| rowspan="2" | USART2
| bgcolor=#0C0|TX
| PA2
| PA2
| PA2
| PA2
| PA2
| PA2
| GPIO44
| rowspan="2" | RP2350 UART1
|-
| bgcolor=#0C0|RX
| PA3
| PA3
| PA3
| PA3
| PA3
| PA3
| GPIO45
|-
| rowspan="2" | USART2A
| bgcolor=#0C0|TX
| PD5
| PD5
| PD5
| PD5
| PD5
| PD5
| GPIO4
| rowspan="2" | RP2350 UART1
|-
| bgcolor=#0C0|RX
| PD6
| PD6
| PD6
| PD6
| PD6
| PD6
| GPIO5
|-
| rowspan="2" | USART3
| bgcolor=#CC0|TX
| PB10
| PB10
| PB10
| bgcolor=#CC0|N/A
| PB10
| PB10
|
| rowspan="2" |
|-
| bgcolor=#CC0|RX
| PB11
| PB11
| PB11
| bgcolor=#CC0|N/A
| PB11
| PB11
|
|-
| rowspan="2" | USART3A1
| bgcolor=#CC0|TX
| PD8
| PD8
| PD8
| bgcolor=#CC0|N/A
| PD8
| PD8
| GPIO6
| rowspan="2" |
|-
| bgcolor=#CC0|RX
| PD9
| PD9
| PD9
| bgcolor=#CC0|N/A
| PD9
| PD9
| GPIO7
|-
| rowspan="2" | USART3A2
| bgcolor=#CC0|TX
| PC10
| PC10
| PC10
| bgcolor=#CC0|N/A
| PC10
| PC10
| bgcolor=#CC0|N/A
|
|-
| bgcolor=#CC0|RX
| PC11
| PC11
| PC11
| bgcolor=#CC0|N/A
| PC11
| PC11
| bgcolor=#CC0|N/A
|
|-
| rowspan="2" | UART4
| bgcolor=#CC0|TX
| PA0
| PA0
| PA0
| bgcolor=#CC0|N/A
| PA0
| PA0
|
| rowspan="2" |
|-
| bgcolor=#CC0|RX
| PA1
| PA1
| PA1
| bgcolor=#CC0|N/A
| PA1
| PA1
|
|-
| rowspan="2" | UART4A
| bgcolor=#CC0|TX
| PC10
| PC10
| PC10
| bgcolor=#CC0|N/A
| PC10
| PC10
|
| rowspan="2" |
|-
| bgcolor=#CC0|RX
| PC11
| PC11
| PC11
| bgcolor=#CC0|N/A
| PC11
| PC11
|
|-
| rowspan="2" | UART5
| bgcolor=#CC0|TX
| PC12
| PC12
| PC12
| bgcolor=#CC0|N/A
| PC12
| PC12
| TBD
|
|-
| bgcolor=#CC0|RX
| PD2
| PD2
| PD2
| bgcolor=#CC0|N/A
| PD2
| PD2
| TBD
|
|-
| rowspan="2" | USART6
| bgcolor=#CC0|TX
| PC6
| bgcolor=#CC0|N/A
| PC6
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC6
| TBD
|
|-
| bgcolor=#CC0|RX
| PC7
| bgcolor=#CC0|N/A
| PC7
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC7
| TBD
|
|}

== CAN ==

{| class="wikitable sortable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="2" | CAN1
| bgcolor=#CC0|TX
| PA12
| PA12
| PA12
| bgcolor=#CC0|N/A
| PA12
| PA12
| TBD
| rowspan=2 | Conflict with USB
|-
| bgcolor=#CC0|RX
| PA11
| PA11
| PA11
| bgcolor=#CC0|N/A
| PA11
| PA11
| TBD
|-
| rowspan="2" | CAN1A
| bgcolor=#CC0|TX
| PD1
| PD1
| PD1
| bgcolor=#CC0|N/A
| PD1
| PD1
| TBD
|-
| bgcolor=#CC0|RX
| PD0
| PD0
| PD0
| bgcolor=#CC0|N/A
| PD0
| PD0
| TBD
|-
| rowspan="2" | CAN2
| bgcolor=#CC0|TX
| PB13
| bgcolor=#CC0|N/A
| PB13
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB13
| TBD
|-
| bgcolor=#CC0|RX
| PB12
| bgcolor=#CC0|N/A
| PB13
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB13
| TBD
|-
| rowspan="2" | CAN2A
| bgcolor=#CC0|TX
| PB6
| bgcolor=#CC0|N/A
| PB6
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB6
| TBD
|-
| bgcolor=#CC0|RX
| PB5
| bgcolor=#CC0|N/A
| PB6
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB6
| TBD
|}

== USB ==
STM32F407=HS/FS host/device/otg

STM32L475=FS host/device/otg no crystal

STM32H562=FS PD

STM32C071=FS no crystal

STM32C551=FS host/device

STM32H723=HS/FS host/device/otg

RP2354=FS host/device

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="2" | All
| bgcolor=#0C0|DM
| PA11
| PA11
| PA11
| PA11
| PA11
| PA11
| DM
| rowspan="2" | RP2350 dedicated pins
|-
| bgcolor=#0C0|DP
| PA12
| PA12
| PA12
| PA12
| PA12
| PA12
| DP
|}

== I2C ==

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="2" | I2C1
| bgcolor=#0C0|SCL
| PB6
| PB6
| PB6
| PB6
| PB6
| PB6
| GPIO9
| rowspan="2" | RP2350 ICL0
|-
| bgcolor=#0C0|SDA
| PB7
| PB7
| PB7
| PB7
| PB7
| PB7
| GPIO8
|-
| rowspan="2" | I2C1A
| bgcolor=#0C0|SCL
| PB8
| PB8
| PB8
| PB8
| PB8
| PB8
| TBD
|
|-
| bgcolor=#0C0|SDA
| PB9
| PB9
| PB9
| PB9
| PB9
| PB9
| TBD
|
|-
| rowspan="2" | I2C2
| bgcolor=#0C0|SCL
| PB10
| PB10
| PB10
| PB10
| PB10
| PB10
| GPIO3
| rowspan="2" | RP2350 I2C1
|-
| bgcolor=#0C0|SDA
| PB11
| PB11
| PB11
| PB11
| PB11
| PB11
| GPIO2
|-
| rowspan="2" | I2C3
| bgcolor=#F44|SCL
| PA8
| bgcolor=#F44|PC0
| PA8
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PA8
| TBD
|
|-
| bgcolor=#F44|SDA
| PC9
| bgcolor=#F44|PC1
| PC9
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC9
| TBD
|
|}

== SPI ==

{| class="wikitable sortable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
! Remarks
|-
| rowspan="3" | SPI1
| bgcolor=#0C0|SCK
| PA5
| PA5
| PA5
| PA5
| PA5
| PA5
| GPIO42
| rowspan="3" | RP2350 SPI1
|-
| bgcolor=#0C0|MISO
| PA6
| PA6
| PA6
| PA6
| PA6
| PA6
| GPIO40
|-
| bgcolor=#0C0|MOSI
| PA7
| PA7
| PA7
| PA7
| PA7
| PA7
| GPIO43
|-
| rowspan="3" | SPI1A
| bgcolor=#0C0|SCK
| PB3
| PB3
| PB3
| PB3
| PB3
| PB3
|
| rowspan="3" | PB3 conflicts with SWO
|-
| bgcolor=#0C0|MISO
| PB4
| PB4
| PB4
| PB4
| PB4
| PB4
|
|-
| bgcolor=#0C0|MOSI
| PB5
| PB5
| PB5
| PB5
| PB5
| PB5
|
|-
| rowspan="3" | SPI2
| bgcolor=#0C0|SCK
| PB10
| PB10
| PB10
| PB10
| PB10
| PB10
|
| rowspan="3" |
|-
| bgcolor=#0C0|MISO
| PC2
| PC2
| PC2
| PC2
| PC2
| PC2
|
|-
| bgcolor=#0C0|MOSI
| PC3
| PC3
| PC3
| PC3
| PC3
| PC3
|
|-
| rowspan="3" | SPI2A
| bgcolor=#0C0|SCK
| PB13
| PB13
| PB13
| PB13
| PB13
| PB13
| GPIO22
| rowspan="3" | RP2350 SPI0
|-
| bgcolor=#0C0|MISO
| PB14
| PB14
| PB14
| PB14
| PB14
| PB14
| GPIO20
|-
| bgcolor=#0C0|MOSI
| PB15
| PB15
| PB15
| PB15
| PB15
| PB15
| GPIO23
|-
| rowspan="3" | SPI3
| bgcolor=#CC0|SCK
| PC10
| PC10
| PC10
| bgcolor=#CC0|N/A
| PC10
| PC10
|
|
|-
| bgcolor=#CC0|MISO
| PC11
| PC11
| PC11
| bgcolor=#CC0|N/A
| PC11
| PC11
|
|
|-
| bgcolor=#CC0|MOSI
| PC12
| PC12
| PC12
| bgcolor=#CC0|N/A
| PC12
| PC12
|
|
|-
| rowspan="3" | SPI3A
| bgcolor=#CC0|SCK
| PB3
| PB3
| PB3
| bgcolor=#CC0|N/A
| PB3
| PB3
|
| Conflicts with SWO
|-
| bgcolor=#CC0|MISO
| PB4
| PB4
| PB4
| bgcolor=#CC0|N/A
| PB4
| PB4
|
|
|-
| bgcolor=#CC0|MOSI
| PB5
| PB5
| PB5
| bgcolor=#CC0|N/A
| PB5
| PB5
|
|
|}

== SDIO ==
STM32F407: SDIO

STM32L475: SDMMC

STM32H562: SDMMC

STM32C071: N/A

STM32C551: N/A

STM32H723: SDMMC

{| class="wikitable sortable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="6" | Only
| bgcolor=#CC0|CMD
| PD2
| PD2
| PD2
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PD2
| GPIO30
|-
| bgcolor=#CC0|CK
| PC12
| PC12
| PC12
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC12
| GPIO31
|-
| bgcolor=#CC0|D0
| PC8
| PC8
| PC8
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC8
| GPIO35
|-
| bgcolor=#CC0|D1
| PC9
| PC9
| PC9
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC9
| GPIO34
|-
| bgcolor=#CC0|D2
| PC10
| PC10
| PC10
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC10
| GPIO33
|-
| bgcolor=#CC0|D3
| PC11
| PC11
| PC11
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PC11
| GPIO32
|}

== Ethernet (RMII) ==
STM32F407:

STM32L475:

STM32H562:

STM32C071:

STM32C551:

STM32H723:

RP2354: With PIO, https://github.com/rscott2049/pico-rmii-ethernet_nce

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="10" | Only
| bgcolor=#CC0| MDIO
| PA2
| bgcolor=#CC0 | N/A
| PA2
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PA2
| GPIO44
|-
| bgcolor=#CC0| REF_CLK
| PA1
| bgcolor=#CC0 | N/A
| PA1
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PA1
| GPIO41
|-
| bgcolor=#CC0| MDC
| PC1
| bgcolor=#CC0 | N/A
| PC1
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PC1
| GPIO47
|-
| bgcolor=#CC0| TX_EN
| PB11
| bgcolor=#CC0 | N/A
| PB11
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PB11
| GPIO2
|-
| bgcolor=#CC0| TXD0
| PB12
| bgcolor=#CC0 | N/A
| PB12
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PB12
| GPIO24
|-
| bgcolor=#F44| TXD1
| PB13
| bgcolor=#CC0 | N/A
| bgcolor=#F44 | PB15
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PB13
| GPIO22
|-
| bgcolor=#CC0| RXD0
| PC4
| bgcolor=#CC0 | N/A
| PC4
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PC4
| GPIO10
|-
| bgcolor=#CC0| RXD1
| PC5
| bgcolor=#CC0 | N/A
| PC5
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PC5
| GPIO11
|-
| bgcolor=#CC0| CRS_DV
| PA7
| bgcolor=#CC0 | N/A
| PA7
| bgcolor=#CC0 | N/A
| bgcolor=#CC0 | N/A
| PA7
| GPIO43
|}

== ULPI ==
STM32F407: ULPI

STM32L475: N/A

STM32H562: N/A

STM32C071: N/A

STM32C551: N/A

STM32H723: ULPI

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="12" | Only
| bgcolor=#CC0| STP
| PC0
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| PC0
| bgcolor=#CC0| N/A
|-
| bgcolor=#CC0| DIR
| PC2
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| PC2
| bgcolor=#CC0| N/A
|-
| bgcolor=#CC0| NXT
| PC3
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| PC3
| bgcolor=#CC0| N/A
|-
| bgcolor=#CC0| CK
| PA5
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| bgcolor=#CC0| N/A
| PA5
| bgcolor=#CC0| N/A
|-
| bgcolor=#CC0|D0
| PA3
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PA3
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D1
| PB0
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB0
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D2
| PB1
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB1
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D3
| PB10
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB10
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D4
| PB11
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB11
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D5
| PB12
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB12
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D6
| PB13
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB13
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|D7
| PB5
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PB5
| bgcolor=#CC0|N/A
|}

== I2S ==
STM32F407: I2S2, I2S3

STM32L475: SAI1, SAI2 (serial audio interface)

STM32H562: I2S1, I2S2, I2S3

STM32C071: I2S1 (half duplex only)

STM32C551: I2S1, I2S2, I2S3

STM32H723: I2S1, I2S2, I2S3

{| class="wikitable sortable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="5" | I2S1
| bgcolor=#F44|MCK
| bgcolor=#CC0|N/A
| bgcolor=#F44|PB8
| PC4
| bgcolor=#F44|PA6, PA11, PD5, PB4, PB6
| PC4
| PC4
| GPIO10
|-
| bgcolor=#F44|SDI
| bgcolor=#CC0|N/A
| bgcolor=#F44|PB5
| PA6
| bgcolor=#F44|PA2,PA7,PA12,PB5,PD6,PB6††
| PA6
| PA6
| GPIO40
|-
| bgcolor=#F44|SDO
| bgcolor=#CC0|N/A
| bgcolor=#F44|PC3
| PA7
| PA7
| PA7
| PA7
| GPIO43
|-
| bgcolor=#F44|CK
| bgcolor=#CC0|N/A
| bgcolor=#F44|PB10
| PA5
| PA5
| PA5
| PA5
| GPIO42
|-
| bgcolor=#F44|WS
| bgcolor=#CC0|N/A
| bgcolor=#F44|PB9
| PA4
| bgcolor=#F44|PA1,PA5,PD8,PB3,PB6
| PA4
| PA4
| GPIO27
|-
| rowspan="5" | I2S2
| bgcolor=#F44|MCK
| PC6
| bgcolor=#F44|PB14
| PC6
| bgcolor=#CC0|N/A
| PC6
| PC6
| GPIO26
|-
| bgcolor=#F44|SDI
| PC2
| bgcolor=#F44|PC12
| PC2
| bgcolor=#CC0|N/A
| PC2
| PC2
| GPIO25
|-
| bgcolor=#F44|SDO
| PC3
| bgcolor=#F44|PD11
| PC3
| bgcolor=#CC0|N/A
| PC3
| PC3
| GPIO21
|-
| bgcolor=#F44|CK
| PB10
| bgcolor=#F44|PD10
| PB10
| bgcolor=#CC0|N/A
| PB10
| PB10
| GPIO3
|-
| bgcolor=#CC0|WS
| PB12
| PB12
| PB12
| bgcolor=#CC0|N/A
| PB12
| PB12
| GPIO24
|-
| rowspan="5" | I2S2a
| bgcolor=#0FF|MCK
| bgcolor=#0FF|N/A
| PD9
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
|
|-
| bgcolor=#CC0|SDI
| PB14
| bgcolor=#CC0|N/A
| PB14
| bgcolor=#CC0|N/A
| PB14
| PB14
| GPIO20
|-
| bgcolor=#CC0|SDO
| PB15
| PB15
| PB15
| bgcolor=#CC0|N/A
| PB15
| PB15
| GPIO23
|-
| bgcolor=#CC0|CK
| PB13
| PB13
| PB13
| bgcolor=#CC0|N/A
| PB13
| PB13
| GPIO22
|-
| bgcolor=#CC0|WS
| PB9
| PB9
| PB9
| bgcolor=#CC0|N/A
| PB9
| PB9
| GPIO28
|-
| rowspan="5" | I2S3
| bgcolor=#CC0|MCK
| PC7
| bgcolor=#CC0|N/A
| PC7
| bgcolor=#CC0|N/A
| PC7
| PC7
|
|-
| bgcolor=#CC0|SDI
| PC11
| bgcolor=#CC0|N/A
| PC11
| bgcolor=#CC0|N/A
| PC11
| PC11
|
|-
| bgcolor=#CC0|SDO
| PC12
| bgcolor=#CC0|N/A
| PC12
| bgcolor=#CC0|N/A
| PC12
| PC12
|
|-
| bgcolor=#CC0|CK
| PC10
| bgcolor=#CC0|N/A
| PC10
| bgcolor=#CC0|N/A
| PC10
| PC10
|
|-
| bgcolor=#CC0|WS
| PA4
| bgcolor=#CC0|N/A
| PA4
| bgcolor=#CC0|N/A
| PA4
| PA4
|
|-
| rowspan="5" | I2S3a
| bgcolor=#0FF|MCK
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
| bgcolor=#0FF|N/A
|
|-
| bgcolor=#CC0|SDI
| PB4
| bgcolor=#CC0|N/A
| PB4
| bgcolor=#CC0|N/A
| PB4
| PB4
|
|-
| bgcolor=#CC0|SDO
| PB5
| bgcolor=#CC0|N/A
| PB5
| bgcolor=#CC0|N/A
| PB5
| PB5
|
|-
| bgcolor=#CC0|CK
| PB3
| bgcolor=#CC0|N/A
| PB3
| bgcolor=#CC0|N/A
| PB3
| PB3
|
|-
| bgcolor=#CC0|WS
| PA15
| bgcolor=#CC0|N/A
| PA15
| bgcolor=#CC0|N/A
| PA15,PB8,PE4 †††
| PA15
|
|}

Notes;

†† The STM32C071 has only one half-duplex I2S, and the _SD pin can either be in INPUT or OUTPUT mode. Many pins, how do we map?

††† I2S3_WS is ONLY mapped on PA15 (used for SWDIO), except on STM32C551 which ALSO has it on PB8.

== DACs ==

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="2" |DAC1
| bgcolor=#CC0|OUT1
| PA4
| PA4
| PA4
| bgcolor=#CC0|N/A
| PA4
| PA4
| bgcolor=#CC0|N/A
|-
| bgcolor=#CC0|OUT2
| PA5
| PA5
| PA5
| bgcolor=#CC0|N/A
| bgcolor=#CC0|N/A
| PA5
| bgcolor=#CC0|N/A
|}

== ADCs ==
ADCs are so numerous that comparative tables are difficult to establish.

STM32F407; 12 channels common for ADC1, ADC2 and ADC3. 4 channels for ADC1 and ADC2

STM32F407; 4 channels common for ADC1, ADC2 and ADC3. 12 channels for ADC1 and ADC2

STM32H562; All 16 channels common for ADC1 and ADC2, can also be configured as 8 differential pair inputs.

STM32C071; Only ADC1, 19 external channels.

STM32C551; 7 channels common for ADC1 and ADC2.

STM32H723; ADC1 and ADC2 are 16 bits, ADC3 is 12 bits. All 3 can also be configured as 8 differential pair inputs.

RP2354; One ADC, 12 bits, 0.5 Msps

{| class="wikitable"
! Variant
! PIN
! STM32F407
! STM32L475
! STM32H562
! STM32C071
! STM32C551
! STM32H723
! RP2354
|-
| rowspan="3" |ADC1
| Pins
| PA0-PA7,PC0-PC5,PB0-PB1
| PA0-PA7,PC0-PC5,PB0-PB1
| PA0-PA7,PC0-PC5,PB0-PB1
| PA0-PA8,PA13-PA14,PC0-PC5,PB0-PB2,PB10-PB12
| PA0-PA7,PC0-PC3
| PA0-PA7,PC0-PC2,PC4-PC5,PB0-PB1
| GPIO40-GPIO47
|-
| Channels
| 16
| 16
| 16
| 19
| 12
| 15
| 8
|-
| Msps
| 2.4
| 5
| 5
| 2.5
| 2.25
| 3.6
| 0.5
|-
| rowspan="3" |ADC2
| Pins
| PA0-PA7,PC0-PC5,PB0-PB1
| PA0-PA7,PC0-PC5,PB0-PB1
| PA0-PA7,PC0-PC5,PB0-PB1
| N/A
| PA0-PA3,PC1-PC5,PB0-PB2
| PA2-PA7,PC0-PC2,PC4-PC5,PB0-PB1
| N/A
|-
| Channels
| 16
| 16
| 16
| N/A
| 12
| 13
| N/A
|-
| Msps
| 2.4
| 5
| 5
| N/A
| 2.25
| 3.6
| N/A
|-
| rowspan="3" |ADC3
| Pins
| PA0-PA7,PC0-PC3
| PC0-PC3
| N/A
| N/A
| N/A
| PC0-PC3
| N/A
|-
| Channels
| 6
| 4
| N/A
| N/A
| N/A
| 4 (12 bits)
| N/A
|-
| Msps
| 2.4
| 5
| N/A
| N/A
| N/A
| 5
| N/A
|}

Learning C

2026-09-23T08:34:04Z

Niclas: /* Macros, Pragmas & Preprocessor */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>, and for <code>int</code> types it can also be <code>unsigned</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

The compiler will also allow various emissions and stacking.

<syntaxhighlight lang="C">
short i = 10;
long i = 10;
unsigned short i = 10;
unsigned long long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Type Casting ===

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax. One reason it is quite easy to end up with the worst spaghetti code possible, as the compiler will not guard against structural mismatching.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Arrays ==

To be added

== Pointers Demystified ==

To be added

=== Pointer Arithmetic ===

To be added

== Structs & Memory Alignment ==

To be added

== Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== The <code>volatile</code> Keyword ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Common Compile Errors ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:33:09Z

Niclas: /* Expressions */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>, and for <code>int</code> types it can also be <code>unsigned</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

The compiler will also allow various emissions and stacking.

<syntaxhighlight lang="C">
short i = 10;
long i = 10;
unsigned short i = 10;
unsigned long long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Type Casting ===

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax. One reason it is quite easy to end up with the worst spaghetti code possible, as the compiler will not guard against structural mismatching.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Arrays ==

To be added

== Pointers Demystified ==

To be added

=== Pointer Arithmetic ===

To be added

== Structs & Memory Alignment ==

To be added

== Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== The <code>volatile</code> Keyword ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:28:46Z

Niclas:

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>, and for <code>int</code> types it can also be <code>unsigned</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

The compiler will also allow various emissions and stacking.

<syntaxhighlight lang="C">
short i = 10;
long i = 10;
unsigned short i = 10;
unsigned long long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Type Casting ===

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax. One reason it is quite easy to end up with the worst spaghetti code possible, as the compiler will not guard against structural mismatching.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Arrays ==

To be added

== Pointers Demystified ==

To be added

=== Pointer Arithmetic ===

To be added

== Structs & Memory Alignment ==

To be added

== Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== The <code>volatile</code> Keyword ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:23:26Z

Niclas: /* Variable types */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>, and for <code>int</code> types it can also be <code>unsigned</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

The compiler will also allow various emissions and stacking.

<syntaxhighlight lang="C">
short i = 10;
long i = 10;
unsigned short i = 10;
unsigned long long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:21:11Z

Niclas: /* Variable types */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>, and for <code>int</code> types it can also be <code>unsigned</code>. The compiler will also allow various emissions, such as <code>long my_variable;</code>, and stacking such as <code>unsigned long long my_variable;</code>

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:16:59Z

Niclas: /* Loops & Iteration */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
while (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:16:46Z

Niclas: /* Loops & Iteration */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
while (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:16:17Z

Niclas: /* Embedded */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exit since there is nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:14:03Z

Niclas: /* Embedded */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop (called the "super loop" or "main loop"), or hand over control to an operating system that doesn't return.

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:12:12Z

Niclas: /* Embedded */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exit, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:06:07Z

Niclas: /* Expressions */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

=== Operators ===

=== Order of Evaluation ===

=== Precedence ===

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:05:16Z

Niclas: /* Control Flow & Decision Making */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Expressions ==

To be added

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:04:31Z

Niclas: /* Standard UNIX */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>. The convention is that returning a non-zero value indicates an error.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T08:03:46Z

Niclas: /* Standard UNIX */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>int argc</code> is a variable containing how many command-line arguments was received, and <code>char** argv</code> is an array (think of a list) with those arguments). The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T07:59:19Z

Niclas: /* Standard UNIX */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(void) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions interacting with the I/O system in the operating system, such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>void</code> explain that the function does not need any input arguments. The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T07:58:41Z

Niclas: /* Standard UNIX */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(void) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint (called "function prototype") for functions such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>void</code> explain that the function does not need any input arguments. The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T07:56:39Z

Niclas: /* Example */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(void) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint for functions such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>void</code> explain that the function does not need any input arguments. The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

Running the same on a Debian 64-bit OS,
<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 8
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 16
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 8
</pre>

Notice the difference of sizes of <code>int</code>, <code>long int</code> and others, but the same sizes of <code>uint8_t</code>, <code>uint16_t</code> and so forth.

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Learning C

2026-09-23T07:50:01Z

Niclas: /* Fixed width types */

[[Category:C]][[Category:Work in progress]]{{metadesc|Learning C tutorial}}
[[File:c-programming-language-1.jpg|thumb|300px|Cover of the 2nd edition of "The C Programming Language"]]
[[C]] is a general purpose programming language which was created in 1972 by Dennis Ritchie.

While it was originally designed to implement operating systems, the features which made the language ideal for that purpose, also make it ideal for developing software for small resource constrained [[MCU]]s.

On this page we will go through how to use C for embedded development.
{{clear}}
== Hello World - Desktop vs. MCU ==

When learning any programming language, the first "project" will typically be a small program which prints out "Hello World!". C was designed to give programmers relatively direct access to the target hardware. This was ideal for creating operating systems and indeed most, if not all, serious operating systems are largely implemented in C. This design also make [[C]] an ideal language for developing embedded software targeting small [[MCU]]s with very limited resources.

=== Standard UNIX ===

On a standard UNIX system, that program, implemented in standard C, would typically look something like this:

<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(void) {
printf("Hello World!\n");
return 0;
}
</syntaxhighlight>

Let us break down the classic C program line by line.

Line 1 contains a '''Preprocessor Directive'''. This essentially instruct the compiler to include a header file called <code>stdio.h</code> (Standard Input/Output). This file in turn contains the blueprint for functions such as <code>printf</code>.

In line 3 follows a function declaration, creating a function named <code>main</code>. Every C program includes a function called <code>main</code> and this function serves as the entry point. The <code>int</code> tell the compiler that this function will return an integer value and the <code>void</code> explain that the function does not need any input arguments. The actual function code is enclosed in a code block using curly brackets.

In line 4 we call the function <code>printf</code> which will print a string on the terminal executing the program. The <code>printf</code> is provided with an argument, which is a string enclosed in double-quotes <code>"Hello World!"</code>. The compiler will include this string as a constant.

Finally in line 5, we return the value <code>0</code>.

Most UNIX like systems have (or bloody should have) a C compiler, typically named <code>cc</code>, so above <code>hello.c</code> can be built into a binary executable thus:

<syntaxhighlight lang="Bash">
$ cc hello.c -o hello
</syntaxhighlight>

This will produce a binary ''hello'', which can now be executed:

<syntaxhighlight lang="Bash">
$ ./hello
Hello World!
</syntaxhighlight>

=== Embedded ===

On an embedded system using any [[MCU]] whether it be [[STM32]], [[RP2350]] or any other, things get a little bit more complicated. On a [[UNIX]] system, the kernel knows how to execute a binary, and the shell (for example Bash) know how to load it, pass parameters and interpret the return value. Typically, a [[MCU]] core will simply jump to a specific address - often <code>0x00000000</code>. The actual format of the binary depends on the [[MCU]] core in use and the architecture. There are seldom a general way to print information, so typically the developer will need to specify how to print. Finally, an embedded application will never actually exist, so the <code>main()</code> will typically run an infinite loop called the "super loop".

During boot, typically, part of the [[MCU]] will need to be initialized. It ''is'' possible to do this manually, but it will often be handled by some sdk provided by the vendor of the [[MCU]]. This startup code will typically lead up to calling <code>main()</code>.

Skipping the actual [[MCU]] initialization and only blinking a [[LED]] rather than printing a statement, a very minimal <code>main()</code> could look something like this:

<syntaxhighlight lang="C" line>
int main(void) {
uint16_t led = PIN('C', 13); // Blue LED
RCC->AHB1ENR |= BIT(PINBANK(led)); // Enable GPIO clock for LED
gpio_set_mode(led, GPIO_MODE_OUTPUT); // Set blue LED to output mode
for (;;) {
gpio_write(led, true);
spin(999999);
gpio_write(led, false);
spin(999999);
}
return 0;
}
</syntaxhighlight>

This will all appear quite incomprehensible for a C beginner, but for now let's just realize that a C program always have a <code>main()</code> function and on embedded systems this function will normally never exist since it's got nowhere else to go.

== Variables & Fixed-Width Types ==

Variables is one of the key concepts in (almost) any programming language. A variable is a named container which can contain any value of the type of the variable.

=== Variable declaration ===

The most basic variable declaration in [[C]] looks like this:

<syntaxhighlight lang="C">
int i = 10;
</syntaxhighlight>

This code snippet will declare (create) a variable by the name <code>i</code> with a '''type''' of <code>int</code> and assigning an initial value of <code>10</code>.

The type <code>int</code> is an integer. The actual number of bits in an int depends on the platform but on a 32 bit [[MCU]] it is most often 32 bits. The value is signed, so it can hold values in the following range:

<code>-2,147,483,648 to 2,147,483,647 (2^31 − 1)</code>

=== Variable types ===

[[C]] only defines a few basic types:

{| class="wikitable"
|-
! Type
! Range
! Description
|-
| char
| 0 - 255
| A single byte capable of holding one character
|-
| int
| -2,147,483,648 - 2,147,483,647
| An integer - on modern 32-bit [[MCU]]s typically a 32-bit value
|-
| float
| ±1.175 × 10⁻³⁸ to ±3.403 × 10³⁸
| 32-bit floating point value
|-
| double
| ±1.7 × 10^308
| 64-bit (8 byte) floating point
|}

The types can be modified by applying a so-called ''modifier'', which can be either <code>long</code> or <code>short</code>.

<syntaxhighlight lang="C">
long int i = 10;
</syntaxhighlight>

==== Fixed width types ====

In K&R, the following is mentioned:

<pre>
Each compiler is free to choose appropriate sizes for its own hardware, subject only
to the the restriction that shorts and ints are at least 16 bits, longs are
at least 32 bits, and short is no longer than int, which is no longer than long
</pre>

This unpredictable nature can be troublesome when creating libraries that need to work on multiple platforms, or used for protocol and data format implementations. For that reason, a library called <code>[https://en.cppreference.com/c/header/stdint stdint.h]</code> was added in C99 containing: <code>uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t</code> for unsigned and signed integer types of specific number of bits.

==== Example ====

Consider the following code running on a [[STM32]] [[MCU]]:

<syntaxhighlight lang="C" line>
printf("\n\n\n--------\nStarting\n");

printf("sizeof(char) = %d\n", sizeof(char));
printf("sizeof(short int) = %d\n", sizeof(short int));
printf("sizeof(int) = %d\n", sizeof(int));
printf("sizeof(long int) = %d\n", sizeof(long int));
printf("sizeof(long long int) = %d\n", sizeof(long long int));
printf("sizeof(float) = %d\n", sizeof(float));
printf("sizeof(double) = %d\n", sizeof(double));
printf("sizeof(long double) = %d\n", sizeof(long double));
printf("sizeof(uint8_t) = %d\n", sizeof(uint8_t));
printf("sizeof(uint16_t) = %d\n", sizeof(uint16_t));
printf("sizeof(uint32_t) = %d\n", sizeof(uint32_t));
printf("sizeof(uint64_t) = %d\n", sizeof(uint64_t));
printf("sizeof(void *) = %d\n", sizeof(void*));
</syntaxhighlight>

This will produce the following output:

<pre>
--------
Starting
sizeof(char) = 1
sizeof(short int) = 2
sizeof(int) = 4
sizeof(long int) = 4
sizeof(long long int) = 8
sizeof(float) = 4
sizeof(double) = 8
sizeof(long double) = 8
sizeof(uint8_t) = 1
sizeof(uint16_t) = 2
sizeof(uint32_t) = 4
sizeof(uint64_t) = 8
sizeof(void *) = 4
</pre>

=== Scope ===

Variables in [[C]] can be declared in different locations (scopes). If a variable is declared before any function declarations they are said to be ''global'', but a variable can also be declared inside a function which will limit the scope to that particular functions. For this reason, local variables can have the same name and each will refer to the local value.

== Control Flow & Decision Making ==

To be added

== Loops & Iteration ==

=== The Super Loop ===

As mentioned earlier, embedded programs are never supposed to exit, since they got nowhere to go really. They often achieve this by running an endless loop, known as the super loop:

<syntaxhighlight lang="C" line>
While (1) { // Loop forever
// Do something here
}
</syntaxhighlight>

The endless loop ''can'' be written in multiple ways. Another often seen approach is:

<syntaxhighlight lang="C" line>
for (;;) { // Loop forever
// Do something here
}
</syntaxhighlight>

Which one is the most efficient is a topic of an almost religious discussion. There might have been a time where one was better than the other (better as in wasting less cpu cycles) but with modern optimizing compilers I doubt very much that there will be any difference.

Fans of "The Hitchhikers Guide to the Galaxy" will appreciate:

<syntaxhighlight lang="C" line>
While (42) { // Loop forever
// Do something here
}
</syntaxhighlight>

This will execute exactly like the first one, taking advantage of the fact that anything non-zero is "true" per definition.

For the final approach we'll look at a feature seldom used in [[C]] programs. K&R describes:

<pre>
C provides the infinitely-abusable goto statement, and labels to branch to. Formally, the goto
statement is never necessary, and in practice it is almost always easy to write code without it.
</pre>

Apart from being hilarious it does open the possibility of doing:

<syntaxhighlight lang="C" line>
loop_start:
//Do something
goto loop_start;
</syntaxhighlight>

While I have ''never'' seen this in the wild, it is technically valid [[C]] syntax.

== Functions & Modular Code ==

To be added

== Bitwise Operations Masterclass ==

To be added

== Pointers Demystified ==

To be added

== Arrays & Pointer Arithmetic ==

To be added

== Structs & Memory Alignment ==

To be added

== The volatile Keyword ==

To be added

== Type Casting & Unions ==

To be added

== Function Pointers & Callbacks ==

To be added

== Enums & State Machines ==

To be added

== Dynamic Memory vs. Static Allocation ==

To be added

== Macros, Pragmas & Preprocessor ==

To be added

== Miscellaneous Links ==

* <span class="newwin">[[Media:The C Programming Language (Kernighan Ritchie).pdf|Kernighan & Ritchie: The C Programming Language (2nd Edition)]]</span>

Streamline MCU STM32H723

2026-09-17T13:05:41Z

Niclas:

[[Category:STM32]][[Category:Streamline]][[Category:Streamline Blade]]{{metadesc|STM32H723 Streamline MCU board documentation}}
[[File:sl_mcu_stm32h723-rev_A_top_right_render.png|350px|thumb|Streamline MCU STM32H723]]
The [[Streamline MCU STM32H723]] is a higher performant [[Streamline]] [[STM32]] [[MCU]] board build around a [[STM32H723]].
{{clear}}

== Specifications ==

{|
|-
|'''MCU'''
|STM32H723VE
|-
|'''Flash'''
|512kB
|-
|'''RAM'''
|564kB
|-
|'''Crystal'''
|16MHz
|-
|'''LED'''
|PC13 (open drain)
|-
|'''Button'''
|Boot0/PA14 (pulled down)
|}

== Schematics ==

<div class="res-img">
[[File:Sl mcu stm32h723.svg|2400px]]
</div>

== Gallery ==

<gallery>
File:sl_mcu_stm32h723-rev_A_top_render.png
File:sl_mcu_stm32h723-rev_A_top_right_render.png
File:sl_mcu_stm32h723-rev_A_top_left_render.png
File:sl_mcu_stm32h723-rev_A_bot_render.png
File:sl_mcu_stm32h723-rev_A_bot_right_render.png
File:sl_mcu_stm32h723-rev_A_bot_left_render.png
</gallery>

== Miscellaneous Links ==

* [https://www.st.com/resource/en/datasheet/stm32h723ve.pdf Datasheet]
* [https://www.st.com/resource/en/reference_manual/rm0468-stm32h723733-stm32h725735-and-stm32h730-value-line-advanced-armbased-32bit-mcus-stmicroelectronics.pdf STM32H723/725/730/733/735 Reference Manual]

Streamline MCU STM32H723

2026-09-17T13:05:21Z

Niclas:

[[Category:STM32]][[Category:Streamline]][[Category:Streamline Blade]]{{metadesc|STM32H723 Streamline MCU board documentation}}
[[File:sl_mcu_stm32h723-rev_A_top_right_render.png|350px|thumb|Streamline MCU STM32H723]]
The [[Streamline MCU STM32H723]] is a higher performant [[Streamline]] [[STM32]] [[MCU]] board build around a [[STM32H723]].
{{clear}}

== Specifications ==

{|
|-
|'''MCU'''
|STM32H723VE
|-
|'''Flash'''
|512kB
|-
|'''RAM'''
|564kB
|-
|'''Crystal'''
|16MHz
|-
|'''LED'''
|PC13 (open drain)
|-
|'''Button'''
|Boot0/PC15 (pulled down)
|}

== Schematics ==

<div class="res-img">
[[File:Sl mcu stm32h723.svg|2400px]]
</div>

== Gallery ==

<gallery>
File:sl_mcu_stm32h723-rev_A_top_render.png
File:sl_mcu_stm32h723-rev_A_top_right_render.png
File:sl_mcu_stm32h723-rev_A_top_left_render.png
File:sl_mcu_stm32h723-rev_A_bot_render.png
File:sl_mcu_stm32h723-rev_A_bot_right_render.png
File:sl_mcu_stm32h723-rev_A_bot_left_render.png
</gallery>

== Miscellaneous Links ==

* [https://www.st.com/resource/en/datasheet/stm32h723ve.pdf Datasheet]
* [https://www.st.com/resource/en/reference_manual/rm0468-stm32h723733-stm32h725735-and-stm32h730-value-line-advanced-armbased-32bit-mcus-stmicroelectronics.pdf STM32H723/725/730/733/735 Reference Manual]

File:Sl mcu rp2354 bot render.png

2026-09-17T13:01:07Z

Niclas: Niclas uploaded a new version of File:Sl mcu rp2354 bot render.png

File uploaded with MsUpload

File:Sl mcu rp2354 top left render.png

2026-09-17T13:00:33Z

Niclas: Niclas uploaded a new version of File:Sl mcu rp2354 top left render.png

File uploaded with MsUpload

File:Sl mcu rp2354 top render.png

2026-09-17T13:00:06Z

Niclas: Niclas uploaded a new version of File:Sl mcu rp2354 top render.png

File uploaded with MsUpload

File:Sl mcu rp2354 top right render.png

2026-09-17T12:59:34Z

Niclas: Niclas uploaded a new version of File:Sl mcu rp2354 top right render.png

File uploaded with MsUpload

File:Sl mcu rp2354.svg

2026-09-17T12:58:16Z

Niclas: Niclas uploaded a new version of File:Sl mcu rp2354.svg

File uploaded with MsUpload

File:Streamline seth.svg

2026-09-17T12:51:12Z

Niclas: Niclas uploaded a new version of File:Streamline seth.svg