Complete ARM Cortex-M Bare-Metal Programming (TM4C123)

ARM designs processors with the RISC philosophy, prioritizing simple, single-cycle instructions and pipelines, and relies on compilers; they license architectures to brands such as Apple and Samsung.

Arm processors are designed to be small and power efficient for mobile and embedded devices, emphasizing risk architecture with high code density, endianness options, and conditional execution.

Explore how an arm core and buses coordinate peripherals like real-time clock and usart in embedded devices. See arp arbiter and apb bridge link memory and peripherals.

Explore cache and tightly coupled memory that boost ARM performance and enable deterministic real-time timing, comparing von Neumann unified caches with Harvard's separate caches and TCM near the core.

Explore the cortex-m vector table, its exception types and memory addresses, and why the least significant bit is one, noting about ten exceptions and the thumb two instruction set.

Explore the cortex-m family of 32-bit processors, including m0, m0+, m1, m3, m4, and m7; compare code density, energy efficiency, and interrupts up to 240 with priority options.

Distinguish microprocessors from microcontrollers by noting that a microprocessor offers a CPU only, while a microcontroller includes CPU, RAM, ROM, and internal peripherals.

Explore the cortex-m register bank of 16 registers, including 13 general purpose (R0–R12) with R13, R14, and R15 roles, plus PSR and the interrupt registers primask, faultmask, and basePRI.

Explore the debug view, customize locals and memory panels, and compare disassembly, machine code, opcodes, and mnemonics with memory addresses as the processor stops at the main function.

Explore the memory view and disassembly view, verify that each address stores the same instruction, and display instructions in 16-bit blocks using a signed short.

Explore counting in a bare-metal ARM Cortex-M program by applying increment and decrement to a counter, then loop to observe repeated counting.

Explore the Cortex-M memory map: 256k flash at 0x00000000-0x0003ffff, 32k sram at 0x20000000-0x20007fff, io at 0x40000000-0x4000ffff, and private peripheral space at 0xe0000000-0xe000ffff, then verify in the debugger memory view.

Explain endianness by contrasting big-endian and little-endian memory layouts, showing how 16-bit and 32-bit values occupy bytes and addresses, including MSB and LSB placement.

Explore upward compatibility across the cortex-m family, showing how code compiled for M0/M0+ and M1 can run on M3, M4, and M7, while noting downward compatibility is not guaranteed.

Explore the Texas Instruments TM4C123 launchpad, a cortex-m4 microcontroller with 256 kb flash, 32 kb RAM, and 80 MHz, featuring a debugger, USB ports, two inputs, and rgb led.

Create and save a new assembly file with the .s extension, add it to the TM4C123 project, and enable PF1 to drive the red LED via resistors.

Explore logical operations, or, and, and exclusive or, with inputs and outputs, enable ports, and access gpio registers, while using symbolic header files and addresses to simplify cortex-m programming.

Expand project two by mastering new opcodes, including CMP and BNE/BEQ, to drive a switch-activated led and implement delay subroutines with subs updating PSR flags.

We declare data area and a 32-bit variable amount, export it, implement amount_func to assign 89, then call from C and read the value to verify.

Experiment with a pointer to drop a value into a memory address, using an unsigned integer address, typecasting, and a pointer variable to access and store data.

define memory addresses as named registers with pre-processors to improve readability, using #define and braces for o'clock, direction, enable, and data registers.

Clarify the volatile keyword's role, its difference from unsigned int vs uint32_t, and how it prevents compiler optimizations on gpio registers in Cortex-M microcontrollers.

Learn to use bitwise operations to control GPIO port F LEDs, enabling and preserving specific bits with or, not, and operators, and improve readability with concise expressions.

Learn to write your own functions to avoid repetition, declare a delay function with void return type and prototype, place it outside main, and call it for the delay loop.

Import functions across files by modularizing code into delay.c and delay.h, then include prototypes in the main file to enable testing and consistent behavior on the board.

define and use C structures by declaring with struct and a name, add age and height fields (uint8_t), create instances, and explore anonymous declarations and typedef to simplify usage.

Access structure members with the dot operator to read and set fields like age and height, and apply it to simple computations in code.