ARM Raspberry Pi Assembly Language From Ground Up™

Learn the computing device from transistors to assembly language on the ARM architecture, uncovering processor design, memory and buses, logic gates, and operating systems.

Explore how transistors form combinational logic with binary counting to build adders and dividers, and learn conversions between binary, decimal, and hexadecimal using 0x and 0b.

Discover the assembly workflow from code to executable: use the assembler to generate machine code and object files, apply directives, then link and debug with memory and register access.

Translate bits into commands by mapping 1s and 0s to mnemonics like add, strh, and move. See how hexadecimal notation and fields such as opcode and Rd encode ARM instructions.

Learn how assembly syntax uses four fields—label, opcode, operand, and comment—with optional labels and comments to document code and locate instructions in memory.

Explore the ARM design philosophy and the RISC architecture, where ARM licenses its designs to brands like Apple and Samsung, with simple, single-cycle instructions, pipelines, and many registers.

Enhance power efficiency and code density with Arm processors designed for mobile and embedded devices, contrasting risc and cisc with compiler versus processor complexity and conditional execution across endianness.

Explore how an ARM-based embedded device integrates a core, memory management, caches, interrupt controller, memory controller, AHB/APB buses and bridges to connect peripherals like RTC, USART, Ethernet, and timers.

Explore arm bus technology and the amba protocol, including bus master and bus slave roles, physical and protocol levels, and ahb with higher throughput.

Explore the memory hierarchy in embedded systems, from cache to main memory and secondary storage, and see how memory width and ARM THUMB instruction sets influence fetch cycles.

Discover how memory-mapped peripherals attach to the ARM processor via a memory controller and interrupt controller, using base addresses and registers on the AHB/APB buses to drive initialization and timing.

Explore the von Neumann and Harvard architectures and their memory layouts. Compare single and separate buses and how they affect data fetches, instruction access, and CPU design.

Explore how the ARM cache and tightly coupled memory, via the AMBA bus with data and instruction caches or separate TCM, enable fast, deterministic real-time performance.

Explore memory management extensions for ARM Raspberry Pi assembly language, including the MPU and MMU, their protection capabilities, and the role of translation tables in virtual-to-physical address mapping.

Explore coprocessor extensions that attach to the ARM core, extending the instruction set and registers. See how to access hardware floating point on the cortex M4 with code.

Enable SSH on the raspberry pi and find its local IP with ifconfig on wlan0, then connect remotely via SSH from macOS, Linux, or Windows using PuTTY or Teraterm.

Install tightvnc server and xrdp on your Raspberry Pi, locate its IP with ifconfig, and connect via Windows remote desktop using the pi user and password.

Install the code blocks IDE on Raspberry Pi using sudo apt get install code blocks. Locate it under programming and use it to develop and debug assembly code.

Grasp the ARM programmer’s model and data types from bits and bytes to 8-bit, 16-bit, 32-bit, and 64-bit words, including 32-bit ARM and 16-bit Thumb.

Explore how the ARM7TDMI uses banked registers, R13 SP, R14 LR, R15 PC, and CPSR/SPSR to manage modes and interrupts.

Learn the Cortex-M register bank, including r0–r12 general purpose, r13 with msp/psp, r14 link, r15 program counter, and xpsr with apsr, epsr, ipsr, plus mrs and msr access.

Explore how data moves through the ARM core via data buses and registers. Understand load/store flow, RISC architecture, and the ALU, barrel shifter, and address logic.

Explore how a three-stage ARM pipeline fetches, decodes, and executes instructions, filling the pipeline for one cycle per instruction, with a branch predictor and interrupt handling affecting performance.

Explore the ARM processor family, covering core-based families, ARMv7-A/R/M architectures, and the ARMv8 upgrade with hardware encryption, including Cortex-A, Cortex-R, and Cortex-M variants.

Explore the Cortex-A and Cortex-R families: Cortex-A targets high-end devices with large caches and graphics/OS support, while Cortex-R emphasizes real-time, safety-critical tasks in cars, medical devices, and more.

Explore the Cortex-M microcontroller family from M0 to M7, including M23 and M33, their use cases, development boards, and hardware encryption for IoT security.

Explore the programmer's view of the ARM processor, detailing eight components: ALU, barrel shifter, MAC, register file, memory, registers, instruction decoder, and address register; covers ARM, Thumb, and Thumb-2 sets.

Learn the structure of an assembly module, including area and code blocks, read-only sections, and entry point. Understand exporting the start point and the startup sequence with a reset handler.

Compare the ARM, Thumb, and Thumb-2 instruction sets, contrast 32-bit ARM and 16-bit Thumb operations, and explain how Cortex-M3 and M4 cores rely on Thumb-2.

Explore predefined register names in the ARM assembler, including R0–R15 and a1–a4 aliases, SP, LR, PC, CPSR, SPSR, and APSR. Declare your own names to rename registers for readability.

Learn how directives or pseudo-ops control the assembly process, including area, dcb, dcw, dcd, equ, space, and end, and how thumb, code, and data sections organize memory.

Explore how GCC ARM assembly directives are written for the Raspberry Pi, including dot data, dot global, dot equ, dot space, and dot align.

Contrast gcc-assembled raspberry pi code under raspbian with car uvision assembly, covering virtual memory addressing, os services, comments, and label colon conventions.

Discover two methods to write Raspberry Pi assembly: a shell workflow using mkdir, vim, and assemble-link-run, code blocks ide workflow, including floating point options and proper operating system termination.

Learn to debug with gdb by building with -g and launching gdb to run the program. Use commands like break, run, list, disassemble, step, continue, and inspect registers and memory.

This lecture shows how to create an assembly project in code blocks for the ARM Raspberry Pi, allocate memory with the dot space directive, and store values using ldr/str instructions.

Explore unary and binary assembly operators in ARM, including bitwise and, eor, or, shifts (shl, shr), rotates (rol), and modulo (A:MOD:B, A%B) with Keil and GNU syntax.

Swap the contents of two 32-bit registers using the exclusive or operator in ARM Raspberry Pi assembly, showing r0 and r1 swap values.

Rename registers in ARM assembly using equ and req directives to assign symbolic names for readable code, then move values and perform addition.

Navigate the Raspberry Pi terminal to create an assembly project, write lesson1.s with vim, export a start label, move 75 to r0, assemble, link, and run to display 75.

Learn how to write, assemble, link, and debug an ARM assembly program on the Raspberry Pi terminal, using registers, breakpoints, stepping, and the disassembly view to inspect memory and instructions.

Explore load-store instructions and addressing within the memory system. Understand how memory is an array of 8-bit elements with rom, ram, and embedded memory maps for cortex-m devices like stm32.

Learn how load-store instructions move data between memory and registers using LDR/STR and variants like LDRB, LDRH, LDRSB, computing effective addresses with base and offset and pre- and post-indexed addressing.

Demonstrate load and store behavior for memory-to-register transfers, including LDRH, LDRSB, and LDRSH, with focus on halfword and byte sizes, zero- and sign-extensions, and the absence of signed stores.

Explore how to store data in memory using an address, with examples of storing 0xFEEDBABE from r3 to 0x8000 and automatic increment after store.

Explore pre-indexed addressing in ARM assembly, where the effective address is the base register plus an offset; an exclamation mark writes back the updated address to the base register.

Learn post-indexed addressing in ARM assembly. Compute the effective address from the unmodified base register Rn, then add the offset and update Rn after the store.

Explore endianness in ARM systems by comparing little and big endian storage. ARM defaults to little endian but can switch via hardware like the bigend pin, affecting network traffic encoding.

Define memory areas by building a coefficient table in memory using dcb and dcd, reading bytes with ldrb, and identifying the little endian layout at 0x400 in the memory window.

Explore how the mov instruction encodes an 8-bit immediate using the rotate_imm field in a 32-bit Arm instruction, focusing on the least significant 12 bits.

Explore how the ARM rotation scheme uses an inline barrel shifter to generate constants from 12-bit instructions and load them directly into registers.

Demonstrates loading constants with the ldr instruction using the equals pseudo, enabling safe, changeable constants like SRAM_BASE 0x04000000 to be loaded into a register.

Learn how to load 32‑bit constants with movw and movt, using movw for the lower half and movt for the top half of the register. They are often used together.

Learn how ADR and ADRL load addresses into registers within specific range limits, switch to ADRL when out of range, and use LDR with labels or literals to access constants.

Learn to solve a simple linear equation in ARM assembly by moving Q, R, and S into registers, computing P as Q plus R plus S, and verifying 11 result.

Store constants in memory to solve P = Q+R+S in ARM Raspberry Pi assembly, reserving memory for P and loading Q, R, S into registers.

Master solving a simple linear equation in ARM Raspberry Pi assembly using register indirect addressing with a pointer to variables and offsets.

This lesson tightens a simple arm Raspberry Pi assembly example into a compact solution for p equals q plus r plus s, reusing three registers and memory offsets.

Delete the main.c file from both the project and disk to prevent load errors, ensuring main.s is used as the program entry.

Add missing source files to your project by right-clicking the project, selecting add files, and double-clicking main dot s to re-include it.

Explore arithmetic and logic instructions, focusing on how flags update in PSR/CPSR status registers and how to use the s suffix with ALU operations to control conditional execution.

The n flag marks negative results in two's complement, and the adds instruction sets the n bit when msb is 1; the v flag signals signed overflow beyond 32-bit range.

Learn how the z flag indicates a zero result after an operation, and how checking its state detects zero outcomes. Explore how the carry flag is set for additions that reach or exceed 2^32 or when a subtraction yields a positive result, enabling 64-bit precision.

Explore how compare and test instructions update condition codes using CMP, CMN, TST, and TEQ. Learn to read and write the CPSR with MRS and MSR to inspect flags.

Learn ARM boolean operations with two-register logic, including moven for one's complement negation, and, or, xor, plus bit clear to clear selected bits.

Experiment with cpsr flags in ARM assembly by performing subtract operations with s suffix, observing updates to n, z, c, and v in the cpsr.

Experiment with the carry flag by loading large numbers into registers. Use add s and adc to observe cpsr bits n z c v when large sums carry.

Explore how the CPSR carry and overflow flags respond to 32-bit additions, using adc to accumulate carries into r9 and observe c and v behavior.

Explore shifts and rotations in the ARM data path, highlighting the barrel shifter between the register bank and the ALU, enabling 32-bit constants and arithmetic shifts and two rotates.

Explore how logical shift left and right multiplies or divides by powers of two, fills discarded bits with zeros, and contrasts unsigned with signed arithmetic shifts that preserve the sign.

Explore 32-bit Arm rotations, turning left or right shifts into a circular buffer where the MSB becomes the LSB, with a 33-bit rotate using the carry flag.

Learn practical Arm Raspberry Pi assembly language shift and rotate operations using lsl, lsr, and ror, including register-based shifts, left rotations via 32 minus n, and extracting top bytes.

Explore ARM addition and subtraction instructions, using the carry flag with adc, sbc, and rsc to perform 64-bit operations across 32-bit registers, including upper and lower halves.

Learn to create an arm assembly program that finds the maximum value in a dataset by loading data, looping with comparisons, and updating a max register.

learn to write an ARM assembly program that sums an 8-bit data set containing signed numbers, using load signed byte, an accumulator, and a loop to produce the total.

Discover ARM Raspberry Pi assembly language bit field inset, unsigned bit field extract, signed bit field extract, and bit field clear, with LSB and width parameters for manipulating bit fields.

Explore saturated math operations to prevent overflow by clipping signed data to range bounds with SSAT. Understand the qubit sticky bit in the APSR register that signals saturation.

Learn Arm multiplication instructions, including 32x32 and 64-bit results with signed and unsigned variants, and multiply-accumulate forms such as mul, mla, and smull for efficient computation.

Discover how the ARM barrel shifter and a 32-bit adder multiply by constants without a multiplier array, using shifts for powers of two and adds for others to save power.

Assemble and run a complex equation in ARM: compute (a+8b+7c-27)/4 with a=25, b=19, c=99; load values, use lsl, mla, sub, and asr to finalize.

Explore how ARM Cortex-M processors implement division with a hardware divider, perform r3 = r1 / r2, and handle division by zero via exceptions or zero result.

Develop a software division routine using subtraction in ARM assembly, dividing 2010 by 10 with r0, r1, and r2, and looping until completion.

Explore how Cortex-M DSP instructions perform 32-bit multiplies into 64-bit products, accumulate with optional 0x80000000 rounding, and apply SMLAR and SML instructions on Q31 data.

Explore fractional notation and arithmetic in assembly, mapping 32-bit patterns to signed, unsigned, or two's complement values. Learn to place the binary point and compute fractions with resolution.

Understand q notation as fixed‑point with q n formats and imaginary binary points, with alignment rules for add, subtract, multiply, and using hex constants in registers for e and pi.