ARM Cortex-M : Modular Embedded Systems Design (FREE!)

Explore the project structure and required components for a modular embedded robot, detailing modularization tools, data flow graphs, and circuit design. Learn to align hardware, software, and documentation—from microcontroller and ultrasonic sensors to DC motors and servo actuators—with cortex and assembly fundamentals and hands-on hardware assembly.

Break complex tasks into machos and view robot parts as modules, define each module’s function and relations, and reduce coupling using code graph, the data flow graph, and the flowchart.

Represent software modules with cyclists and hardware modules with rectangles in a call graph, showing initiator and callee relationships, prototypes, and assembly code within a modular Cortex-M system.

Explore the data flow graph of a modular embedded robot, showing ultrasonic distance input flowing through routines to the central controller and motor hardware.

Discover how embedded software uses a foreground main loop and a timer-driven background interrupt service routine to read ultrasonic and infrared sensors and decide moves within bounded time.

Delve into the instruction set architecture through bonus sections on the cortex, assembly primer, and bare metal embedded C programming primer, featuring essential lessons from related courses.

Explore assembly language syntax by examining the four fields of an instruction—label, opcode, operand, and optional comment—and see how optional directives shape code assembly and readability.

Explore the arm cortex-m assembly directives, including thump at the top, code and data sections, area, export, end, dc, dcd, dcw, and dot text for calling from C.

Overview of tm4c123 tiva c launchpad, a Texas Instruments cortex-m microcontroller board with 256 kb flash, 2 kb ram, up to 80 mhz, debugger and usb port for hands-on experiments.

Explore the project 1 overview by examining a sample program, identifying two directives, nationalizing ports, and implementing the loop and initialization logic that turns on the light.

Learn seven ARM opcodes for the first program, including move, load, store, branch, link and return, and no-op, with examples and register and memory access rules.

Create a new embedded project, choose a microcontroller, add CMSIS core and startup files, set 16 megahertz, configure the debug driver, and customize editor colors and fonts.

Create main.s as an assembly file, save with the .s extension, add it to your project, and enable port 3 for the red lcd using labeled pins.

Activate the port clock, unlock PD7 if needed, set the pin direction in the dir register, and enable the pin using the I/O enable register for Port F.

Explore how directives shape compilation, export directives to make code callable from C, and how to initialize a GPIO port F using address loading and registers.

Explore logical operations with two inputs—including and, or, and exclusive or—alongside how to read reset values, convert hex and binary, and use symbolic names for registers via equ directives.

The lecture shows activating the clock by writing to the clock register with str, then setting the direction and digital enable for pf1, and returning from the subroutine.

Develop a looping subroutine in ARM assembly, wiring data, destination, and source registers, and configure the reset handler as the program start. Explore symbolic names and board testing.

Watch this revision on embedded c development with selected bare metal videos to revise embedded c programming, run the experiment, and prepare for the full software structure.

Learn to build a simple counting program for a tm4c/lm4f microcontroller using the simulator, creating a main function and a counter variable, incrementing it, compiling, and debugging without hardware clocks.

Explore the debugger's view for ARM Cortex-M modular embedded systems design by inspecting memory, local variables, and disassembly to see machine code and assembly in real time.

Examine how memory view and disassembly view align by inspecting memory addresses, verifying that instructions match the disassembly, and switching to 16-bit blocks to display 16-bit instruction data.

Explore how the code initializes a local counter, updates registers and memory, and tracks the program counter as you step through the main function, the logos view, and the disassembly.

Create a CMSIS-compliant embedded project, configure the board and clock, unlock pins, and write a main program that uses two switches to light LEDs on the Launchpad.

Configure a CMSIS compliant project by selecting the correct device and pack, including the device header, and cleaning up structure members before compiling and flashing the board.

Explore modular embedded design with cmsis by creating separate delay modules, organizing prototypes and headers, and integrating include files to compile and debug cortex-m projects.

Create a new GPL project and implement a button-driven LED toggle on the launchpad by enabling Port F clock and reading button state in a loop.

Explore timer registers in the Cortex-M design, including the configuration register in the cmt structure to set 16-bit timers, load intervals, and manage interrupts via icr and mode.

Examine timer size on the ARM Cortex-M, contrasting 16-bit and 32-bit timers, plus a 16-bit timer with a prescaler, to reveal delays from milliseconds to seconds.

Program a 16-bit one-shot timer on ARM Cortex-M microcontrollers, configuring the clock source and timer one-shot operation. Use symbolic names and data sheets to improve readability and energy efficiency.

Program 16-bit one-shot timers on an ARM cortex-m by configuring registers, enabling clocks, and generating a single time interrupt, guided by data sheets and practical steps.

Develop the skills to program 16-bit timers in periodic mode on ARM Cortex-M, moving beyond one-shot mode to extend delays, configure the timer, and implement a loop-based timing routine.

Learn to code timers in 16-bit period mode on ARM Cortex-M, configure period, clear and reset timers, and implement one-shot timing behavior.

Use timers to count events and measure intervals between events through edge detection, with practical examples using switches and a laser-LDR setup to count people.

Enable the timer clock, configure the 16-bit timer mode (periodic or one-shot), and set capture mode with CCP settings to count events.

Count rising edges with timer 3 on ARM Cortex-M by configuring 16-bit edge-triggered counting and enabling port B input to update a global event counter.

Measure time between events using timers by capturing rising and falling edge timestamps, compute their difference, and convert to time units based on clock frequency for ultrasonic module timing.

Learn to measure time between events with timers using an ultrasonic HC-SR04 sensor and convert edge time difference from trigger and echo to distance in centimeters with input capture mode.

Learn to measure the time between ultrasonic sensor events using a pair of timers, configure echo and trigger pins, and implement code to compute distance from the measured interval.

Configure a 16-bit timer to measure time between ultrasonic sensor pulses by capturing edge events. Initialize ports and trigger/echo pins, enable timing, and compute distance in centimeters from timestamps.

Learn how to measure time between events using a timer on ARM Cortex‑M, including initializing the timer, reading distance in centimeters from an ultrasonic sensor, and employing timer interrupts.

Learn how to measure time between events with a 16-bit timer on a Cortex-M, configure timer registers, capture edges, and compute distance from an ultrasonic sensor.

Explore timer interrupt programming on ARM Cortex-M by learning the difference between interrupts and polling, and how to create an interrupt service routine that triggers when a timer fires.

Explore timer interrupt programming on ARM Cortex-M by building a pseudo real-time system with three threads, delivering 1 Hz and 10 Hz interrupts to drive red, green, and blue LEDs.

Explore assembling the robot vixen's head module, detailing ultrasonics hardware, copper board placement, construction steps, and the central data flow driving the ultrasonic routine via a timer interrupt service routine.

Create a cms project for 1-2-3 microcontroller, configure target options and ICD debugging, organize code into application and head groups, and begin writing assembly for initialization and head driver functions.

Develop the head module interface by adding a header with prototypes and doxygen-style comments, declare constants for timing, speed of sound, and ultrasonic echo handling.

Develop the header implementation for the head drivers, initialize timers, and configure the echo pin on port b 6 in edge capture mode to enable precise timing.

Develop a timer driver for ARM Cortex-M: build header interface and implementation to provide microsecond delays, initialize a 1 Hz interrupt, and plan 100 Hz support.

Test and integrate the head module by creating a lights group, initializing pins, and wiring head and light modules in main.c with the header interface and interrupt setup.

Populate the head module's interrupt service routine to update a distance variable from the ultrasonic sensor. Enable timer interrupts and test with LEDs when the distance is under seven centimeters.