Bare-metal peripheral driver
Deliverable: A GPIO and timer driver written from the reference manual with no vendor HAL, producing a precise PWM output verified on an oscilloscope.
Course
Embedded Systems
Firmware written close to the metal — registers, interrupts, timers and buses — debugged on real hardware, because embedded bugs live where a simulator cannot show them.
- Duration: 5 months
- Classroom
- Level: advanced
What you will be able to do
- Write embedded C that manipulates registers deliberately
- Configure GPIO, timers, ADC and PWM from the datasheet
- Write interrupt service routines that are short and safe
- Communicate over UART, I2C and SPI and debug a bus with a scope
- Structure firmware as a state machine or under an RTOS
- Debug with a hardware debugger rather than by adding print statements
Who this course is for
- Electronics, electrical and computer engineering graduates and diploma holders
- Developers moving from application code to firmware
- Comfortable with C programming
- Ability to read a schematic is expected
Syllabus
7 modules · 5 months
Module 1. Embedded C
- Pointers, memory and what the compiler actually emits
- Bit manipulation and register access
- volatile, const and why they matter here
- Fixed-point arithmetic and avoiding floating point
Module 2. Microcontroller architecture
- Cortex-M core, memory map and the vector table
- Clock tree, PLL and configuring the system clock
- Reading a datasheet and a reference manual
- Startup code and the linker script
Module 3. Peripherals
- GPIO configuration and drive modes
- Timers, PWM and input capture
- ADC, sampling and reference voltage
- DMA and moving data without the CPU
Module 4. Interrupts and timing
- The NVIC, priorities and nesting
- Writing an ISR that does almost nothing
- Race conditions and atomic access
- Debouncing and timing without delay loops
Module 5. Communication
- UART, framing and baud rate error
- I2C addressing, ACK and clock stretching
- SPI modes and chip select discipline
- Debugging a bus on a logic analyser
Module 6. Firmware architecture
- Super loop, state machines and when each is right
- FreeRTOS tasks, queues and semaphores
- Priority inversion and the bugs concurrency brings
- Watchdogs and recovering from a hang
Module 7. Debugging and reliability
- Breakpoints, watchpoints and single stepping on hardware
- Reading a hard fault and finding its cause
- Power modes and measuring real consumption
- Firmware update and field recovery
Tools and technologies you will use
- ARM Cortex-M microcontrollers
- STM32CubeIDE or Keil
- FreeRTOS
- Oscilloscope and logic analyser
- ST-Link or J-Link debugger
Projects you will build
Sensor over I2C
Deliverable: A sensor read over I2C with error handling for a missing ACK, with the bus transaction captured on a logic analyser and annotated.
Interrupt-driven system
Deliverable: A system where all timing is interrupt or timer driven with no blocking delays, demonstrated responding correctly to two simultaneous events.
RTOS application with a diagnosed hard fault
Deliverable: A multi-task FreeRTOS application, plus a deliberately introduced hard fault traced from the stacked registers to the offending line.
Where this course can take you
- Embedded Software Engineer
- Firmware Developer
- Hardware Test Engineer
- Product Development Engineer
- Automotive Electronics Engineer
Duration, modes and fees
- Duration
- 5 months
- Delivery modes
- Classroom
- Fees
- Share your details for the current fee
- Fees vary by batch. Development boards, debuggers and test equipment are provided. Classroom mode only.
Placement assistance
Every student gets placement assistance — that is what 100% placement assistance means. It is support for all, not a job for all. We do not promise a specific salary, a specific number of interviews, or placement at any named company, and you should be wary of anyone who does.
What is included
- A place in the monthly placement drive, held every third Saturday
- The readiness programme every second Saturday — mock interviews and preparation
- CV review against the specific roles you are targeting
- Portfolio review, so your project work is presented the way a reviewer will read it
- Access to the vacancy pool employers send directly to the Samyak network
- Guidance on which roles realistically fit your background and which do not
- A place in the next drive, with coaching, if you are not selected in this one
What is not included
- Any guarantee of a job, an interview, or a particular salary
- Placement at a named or partner company
- Applying to jobs on your behalf
- Support before you have completed the course and its project work
- Visa, relocation or overseas placement assistance
Print statements are not debugging
Almost every beginner debugs firmware by adding UART prints, and it works right up until the bug is a timing problem — at which point the print changes the timing and the bug moves.
This course uses a hardware debugger from the second week. Breakpoints, watchpoints, single stepping, and reading the stacked registers after a hard fault to find the line that caused it. That last skill is the difference between an engineer and somebody guessing.
Write drivers from the reference manual
Vendor HAL libraries are useful and they hide the thing you are here to learn.
The first project bans them: configure GPIO and a timer by writing registers, from the reference manual, and verify the PWM on a scope. It takes considerably longer than calling a function, and afterwards the microcontroller is no longer a mystery box that sometimes misbehaves.
An ISR should do almost nothing
The most common embedded bug is a long interrupt handler.
Set a flag, clear the source, return. Anything else — a delay, a print, a bus transaction — blocks other interrupts and produces failures that appear once a day and cannot be reproduced. The interrupts module is as much about restraint as about mechanism.
Where this sits against IoT
The IoT course builds connected products with friendly frameworks and covers sensors, cloud and power. It is the right course for a systems view.
This is the firmware underneath — registers, buses, RTOS, hardware debugging. Take IoT if you want to build a product; take this if you want to be the person who writes what runs inside it.
Questions
Embedded Systems — frequently asked questions
How is this different from the IoT course?
IoT is a system course — sensors, connectivity, cloud, power — using friendly frameworks like Arduino. This is firmware engineering — registers, interrupts, buses, RTOS and hardware debugging on ARM Cortex-M. IoT teaches you to build a connected product; this teaches you to write the firmware inside one.
Do I need to know C well?
Yes, this one is a genuine prerequisite. Embedded C is C with pointers everywhere and no safety net, and someone still uncertain about pointer arithmetic will struggle from the second module. If C is shaky, take the core programming route first — it is the shorter path.
Why not use Arduino for everything?
Arduino is excellent for prototyping and the IoT course uses it deliberately. It also hides the register configuration, the interrupt priorities and the timing, which are exactly what an embedded engineering job requires you to control. This course writes drivers from the reference manual so the hardware stops being magic.
Do I need an oscilloscope at home?
No — scopes and logic analysers are in the lab and every project that needs one is done there. That is also why this course is classroom-only. Debugging a bus without seeing the signal is guesswork, and buying test equipment is not a reasonable entry requirement.
Enquire about Embedded Systems
Three details is all we need. A course advisor will call you back.
Related courses
- IoT (Internet of Things)
Connected hardware from sensor to dashboard — microcontrollers, wireless protocols, cloud ingestion and the power and reliability problems that decide whether a device survives deployment.
- PLC and SCADA Automation
Industrial automation taught on real hardware — ladder logic, analogue I/O, HMI and SCADA — with the interlock and safety discipline that separates a working panel from a dangerous one.
- PCB Design
Board design taken to manufacture — schematic, footprints, layout, planes and Gerbers — with the checks that decide whether a fab house builds it or sends it back.
- VLSI and VHDL
Hardware description taught as hardware, not as programming — RTL that synthesises, testbenches that prove it, and designs that meet timing on a real FPGA.
Next step
Talk to a course advisor
Tell us what you want to learn and we will help you pick the right course, batch and mode.