We may earn an affiliate commission when you visit our partners.
Akshay Gill and MakerMax Inc.

✓ Do you like working with microcontrollers, sensors, and other embedded devices?

✓ Do you want a successful career in embedded systems, but can't find the right resources?

✓ Are you preparing for a job interview in embedded systems?

✓ Do you already have a career in embedded systems, but want to start working on more engaging projects?

This course on the "Foundations of embedded systems with ARM Cortex and STM32" is the right choice. Try it for 30 days with a no questions asked, money back guarantee, and you will thank yourself for making the right decision.

Your instructor

Read more

✓ Do you like working with microcontrollers, sensors, and other embedded devices?

✓ Do you want a successful career in embedded systems, but can't find the right resources?

✓ Are you preparing for a job interview in embedded systems?

✓ Do you already have a career in embedded systems, but want to start working on more engaging projects?

This course on the "Foundations of embedded systems with ARM Cortex and STM32" is the right choice. Try it for 30 days with a no questions asked, money back guarantee, and you will thank yourself for making the right decision.

Your instructor

You will be learning the material from the best of the best in the industry. Akshay has over 10+ years of solid experience and has worked for companies like Tesla, on crucial projects for the Model S, X and 3 cars.

He has a passion for teaching, and once you've experienced his teaching style, it is hard to go anywhere else. He is patient with students, and understands the learning journey you will go through, and will be there to guide you along the way.

Akshay has been teaching since his first years at University and as won awards in teaching and entrepreneurship.

In one sentence, how is this course different from other embedded systems courses?

If you are looking for a course that is built from the ground-up with quality in mind, proven to make you successful in embedded systems, this is it.

What hardware is needed for this course?

The instructor is using a STM32 Nucleo development board for this course. However, you are free to choose any ARM Cortex board you wish to. The learning from the content is transferable across different platforms.

You can choose to develop on Windows, Linux or Mac as per your preference. All 3 are supported in this course.

Your 14 day journey to success

We recommend spreading out the content of the course over 14 days as it has proven to maximise your learning, giving you a chance to absorb the information and practice hands-on as you go.Section 1 - You will learn about the ARM Cortex architecture. Understanding this will allow you to select the right microcontroller for your project. With the deep understanding of ARM Cortex architecture, you will also be able to debug applications like a pro. Section 2 - The ARM Cortex programmers model, is hardly taught anywhere but such a crucial piece to understanding how the processor functions and how the C code that you write interfaces with the hardware after compilation.Section 3 - The ARM Cortex exception model and vector table is an important step to understanding how the working of the processor when things don't go as intended. In embedded systems, exceptions need to be handled elegantly in order to produce a safe functioning product. Section 4 - ARM Cortex blocks like the System Control Block, Floating point unit, bus interfaces will be covered. This will give you an understanding of how core blocks inside the microcontroller are connected to each other and their usefulness.Section 5 - The first and an important step for a project is to be able to choose the right microcontroller. You will need to take all sorts of considerations into mind before making the choice. Making the right choice here will make your project successful in the short term and the long term as well. Section 6 - Peripherals let the processor talk to the outside world. When developing applications for microcontrollers, every project you will work on will interface to one or more of these peripherals. Having this understanding will allow you to successfully interface devices with the microcontroller.Section 7 - Special features of the microcontroller, go through 3 unique features that you will most likely be interfacing with in your projects.

Section 8 - Hands-on lab to set up your computer with a development environment that will run on Windows, Linux or Mac. Having this setup will allow you to work on the lab exercises in this course and on your projects after course completion.

Section 9 - Understanding UART communication is immensely important, and almost every embedded job interview will ask you a question about it. You will be able to become a pro at UART and interface all kinds of devices with the microcontroller after working on the lab exercises included with the course.

Section 10 - I2C communication runs over 2 wires and is used extensively in a lot of embeded devices. The lectures and timed challenge lab exercise for I2C will train you to be a professional in this communication interface. Having this understanding will allow you to interface with millions of I2C devices available in the market and use them for your projects.

Section 11 - GPIO is a peripheral that will definitely be in every single application you work on. With the hands-on learning in this section, you will understand different ways in which ports and pins can be setup to allow you to interface various types of devices with the GPIO peripheral.

Section 12 - DAC and TIM peripherals will open the world of timing, and digital to analog conversion for you. This is an extensive area where microcontrollers are used and the lab exercises included in this section will give you an excellent understanding of how these two peripherals can be used in your custom application.

Section 13 - These days we just download an IDE and are good to go. But have you ever wondered what the different components inside an IDE (Integrated development environment) are? Going through these exercises will allow you to get that understanding which will make debugging so much easier going forward. Understanding the development environment from ground-up allows you to be confident when things go wrong.

Section 14 - We talk about the next steps and a continued learning program to allow you to take the learnings from this course and continue to apply them in future projects. We also talk about how you can use the information learned in this course to guarantee a successful career in embedded systems.

Enroll now

What's inside

Learning objectives

  • In-depth understanding of the arm cortex fundamentals
  • Set up a free and open source toolchain on your computer to program, flash and debug arm based microcontrollers
  • Core register functionality like stack pointers, link registers, program counters, control registers, vector tables
  • Understand different types of exceptions on the arm cortex-m processor and what each of them mean
  • Understand different peripherals and how to program them
  • Hardware abstraction layer (hal) libraries and how to use them
  • Feel confident and comfortable programming applications on the cortex-m platform
  • What is a programmers model and how it works for an arm cortex-m
  • Unprivileged and privileged software execution levels
  • Vector table offset register (vtor) and its uses
  • Big endian format vs little endian format
  • Openocd (open source debugger)
  • Stcubemx application and how to generate hal drivers
  • Show more
  • Show less

Syllabus

Course basics
Important points before you get started
With the deep understanding of ARM Cortex architecture, you will also be able to debug applications like a pro!
Read more
ARM Cortex Family

Acronym ISA (0:28) stands for Instruction Set Architecture.

Cortex-M4 Instruction Set
ARM vs Thumb instructions quiz
Guidelines
Overview of the Nucleo F303RE board

All the reference documents that you will need in this course, with descriptions for each of them.

How the processor functions and how the C code that you write interfaces with the hardware after compilation
Programmer's Model
General Registers and Process Specific Registers
Special Registers
Lab Session #1 - Programmers Model - General and Special Registers
Programmers Model Quiz

Attached is the document I use in this lecture to show the definitions of special registers.

How the working of the processor when things don't go as intended
Exception Model and Vector Table
Lab Session #3 - Reset Exception Handler and the Vector Table
Vector Table Offset Register (VTOR)
Lab Session #4 - Using VTOR to move vector table to SRAM
Exception Model Quiz
How core blocks inside the microcontroller are connected to each other and their usefulness
Core Blocks inside the ARM microcontroller
Big Endian vs Little Endian
STM32F3x System Overview, Bus Interface
To be able to choose the right microcontroller for your project and set it up on a breadboard for a quick test!
How to choose a microcontroller for your project
Powering up a microcontroller on a breadboard
Having this understanding will allow you to successfully interface devices with the microcontroller
Timers and counters
Prescalers
PLL - Phase lock loop
ADC - analog to digital converters
DAC - Digital to analog converters
I/O ports
AC - Analog comparators
3 unique features that you will most likely be interfacing with in your projects.
Interrupts
Reset sequence and watchdog timer
JTAG - Joint Test Action Group
Hands-on lab to set up your computer with a development environment that will run on Windows, Linux or Mac. Having this setup will allow you to work on the lab exercises in this course and after
Setting up the development environment
You will be able to become a pro at UART and interface all kinds of devices with the microcontroller after working on this lab exercise
A deep dive into UART and its implementation
Having this understanding will allow you to interface with millions of I2C devices available in the market and use them for your projects.
The I2C protocol
I2C open drain
TIMED CHALLENGE: I2C driver development
Allow you to interface various types of devices with the GPIO peripheral.
Project 1 - GPIO Peripheral Driver Development
ADC lab exercise
Give you an excellent understanding of how DAC and TIM two peripherals can be used in your custom application
Project 2 - DAC and TIM Peripheral Driver Development
For those who want to learn how to set up an integrated development environment based on Eclipse from scratch. Understanding this allows you to be confident when things go wrong in application dev.
Section Introduction
Setting up the virtual machine
Setting up Linux OS on the virtual machine
Setting up the Eclipse development environment
Setting up the development toolchain
Creating a blinky project
Setting up the open source debugger (Part 1)
Setting up the open source debugger (Part 2)
Install STCubeMX for generating HAL drivers
Running the blinky project
FAQ and Troubleshooting
Toolchain installation instructions for MacOS users
Congratulations and Thank you!
Closing Notes

Good to know

Know what's good
, what to watch for
, and possible dealbreakers
Provides hands-on labs using the STM32 Nucleo development board, allowing learners to immediately apply concepts and build practical skills in embedded systems development
Covers the ARM Cortex programmer's model, which is a crucial piece to understanding how the processor functions and how the C code interfaces with the hardware
Explores the ARM Cortex exception model and vector table, which is important for understanding how the processor works when things don't go as intended
Teaches how to set up a development environment on Windows, Linux, or Mac, which allows learners to work on lab exercises and future projects
Requires learners to choose their own ARM Cortex board, which may present a barrier to entry for some learners who do not have access to one
Uses STCubeMX application for generating HAL drivers, which may require learners to download and install this software, adding an extra step to the setup process

Save this course

Save Foundation of Embedded Systems with ARM Cortex and STM32 to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Foundation of Embedded Systems with ARM Cortex and STM32 with these activities:
Review Digital Logic Fundamentals
Reinforce your understanding of digital logic concepts, which are foundational to understanding how microcontrollers operate.
Browse courses on Digital Logic
Show steps
  • Review notes from previous digital logic courses.
  • Work through practice problems on logic gate simplification.
  • Simulate basic digital circuits using online tools.
Read 'Embedded Systems Architecture' by Tammy Noergaard
Gain a deeper understanding of embedded systems architecture to complement the course's focus on ARM Cortex and STM32.
Show steps
  • Read the chapters related to ARM Cortex architecture.
  • Take notes on key concepts and diagrams.
  • Relate the book's content to the course lectures.
Read 'Mastering STM32' by Carmine Noviello
Expand your knowledge of STM32 microcontrollers with this comprehensive guide.
View Melania on Amazon
Show steps
  • Read the chapters relevant to your projects.
  • Experiment with the code examples provided in the book.
  • Use the book as a reference for specific STM32 features.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Implement UART Communication with STM32
Solidify your understanding of UART communication by implementing it on an STM32 microcontroller.
Show steps
  • Configure the UART peripheral on the STM32.
  • Write code to transmit and receive data via UART.
  • Test the communication with a serial terminal.
Develop a Simple Sensor Interface
Apply your knowledge by building a project that interfaces a sensor with an STM32 microcontroller.
Show steps
  • Choose a sensor (e.g., temperature, light).
  • Connect the sensor to the STM32.
  • Write code to read data from the sensor.
  • Display the sensor data on a screen or send it via UART.
Write a Blog Post on ARM Cortex Internals
Deepen your understanding by explaining ARM Cortex internals in a blog post.
Show steps
  • Research a specific aspect of ARM Cortex (e.g., exception handling).
  • Write a clear and concise explanation of the topic.
  • Include diagrams and examples to illustrate the concepts.
  • Publish the blog post on a personal website or platform.
Contribute to an STM32 HAL Library
Enhance your skills by contributing to an open-source STM32 HAL library.
Show steps
  • Find an open-source STM32 HAL library on GitHub.
  • Identify a bug or missing feature.
  • Implement the fix or feature and submit a pull request.
  • Respond to feedback from the maintainers.

Career center

Learners who complete Foundation of Embedded Systems with ARM Cortex and STM32 will develop knowledge and skills that may be useful to these careers:
Embedded Systems Engineer
An Embedded Systems Engineer designs, develops, and tests software and hardware for embedded devices. This course builds a strong foundation in ARM Cortex architecture, a cornerstone of many embedded systems. The course's focus on practical skills, such as setting up a development environment and interfacing with peripherals like UART, I2C, and GPIO, directly translates to the day-to-day tasks of an Embedded Systems Engineer. The hands-on labs, including development environment setup and peripheral driver development, help build the practical skills required for this role, which could include programming microcontrollers for industrial control systems, consumer electronics, or internet of things devices. Understanding the ARM Cortex programmer's model and exception handling is also crucial for the debugging and optimization of embedded systems applications, an important part of the role. This course, with its 14-day program that maximizes learning, provides a focused and efficient way to prepare for a career in embedded systems.
Firmware Engineer
A Firmware Engineer develops the low-level software that controls the hardware in embedded systems. This course’s emphasis on ARM Cortex architecture and the STM32 microcontrollers makes it directly relevant to a Firmware Engineer's role. The course's detailed instruction on the programmer's model, exception handling, and core blocks of the microcontroller is essential for those who wish to work at the hardware interface. The course also covers practical skills needed by a Firmware Engineer, such as setting up development environments, and working with peripherals like UART, I2C, GPIO, DAC, and TIM. A Firmware Engineer will find the hands-on labs in this course, including driver development and project creation particularly useful. They help build practical skills needed for writing effective and efficient firmware, which is used in many different devices across a number of industries. This course offers a detailed look at microcontroller architecture, which is useful for those who want to understand exactly how firmware operates.
Internet of Things Engineer
An Internet of Things Engineer designs and develops connected devices, often involving embedded systems and microcontrollers. This course provides relevant knowledge of the ARM Cortex architecture and STM32 microcontrollers, which are commonly used in Internet of Things applications. The course emphasizes practical skills such as setting up development environments, and working with peripherals like UART, I2C, and GPIO, and these skills apply directly to developing connected devices. An Internet of Things Engineer needs to know how to program microcontrollers to communicate with sensors and other devices. The course material on exception handling is also useful for building robust embedded systems. This course offers a focus on the practical aspects with hands-on labs and challenges, such as those involving I2C and GPIO. This may be useful to engineers who wish to begin working on Internet of Things projects.
Consumer Electronics Embedded Systems Engineer
A Consumer Electronics Embedded Systems Engineer develops embedded software for a variety of consumer electronics devices. This course can be a useful resource for someone looking to enter this field, as it covers the fundamental building blocks needed for this role. The course's focus on ARM Cortex architecture and STM32 microcontrollers provides the basis for developing embedded systems for a variety of consumer electronics. The course offers hands-on labs, such as setting up a development environment and driver development for peripherals such as UART, I2C, and GPIO. The course also covers topics like exception handling and bus interfaces which are helpful for building reliable products. Those looking to make smart consumer devices can use the skills learned in this course.
Automotive Embedded Systems Engineer
An Automotive Embedded Systems Engineer designs and develops the embedded systems used in vehicles. The course aligns with the needs of this career by covering ARM Cortex architecture, commonly used in automotive control units, and giving hands-on experience with STM32 microcontrollers. The course's focus on core concepts like the programmer's model and exception handling is essential for those working with vehicle control systems. An Automotive Embedded Systems Engineer will find the practical sections on setting up development environments, and working with communication protocols like UART and I2C pertinent as they are needed skills for someone in this field. The course's focus on peripherals like GPIO, DAC, and TIM, which are relevant to controlling vehicle components such as sensors and actuators, may be useful. The material on bus interfaces and exception handling are essential for designing safe and reliable embedded systems, as is required in the automotive field. This course may be helpful in understanding these concepts.
Medical Device Embedded Systems Engineer
A Medical Device Embedded Systems Engineer designs and develops embedded software for medical devices. The course provides relevant information on ARM Cortex architecture, which is frequently used in implantable and wearable medical devices. The course focuses on practical skills such as setting up development environments and working with peripherals like UART, I2C, and GPIO. The course material on exception handling helps build an understanding of how to make a safe and reliable device, which is necessary for medical applications. A medical device engineer will find the course's instruction on the programmer's model, exception handling, and peripheral interfaces, like ADC and DAC, very helpful. The course’s hands-on approach, with labs covering peripheral driver development, teaches useful skills. This course will give a medical device engineer skills in microcontroller programming that they will find useful.
Aerospace Embedded Systems Engineer
An Aerospace Embedded Systems Engineer develops the embedded software that runs on aircraft and spacecraft. This role often requires a deep understanding of microcontrollers and embedded systems, and this course can provide a foundation. The course’s emphasis on ARM Cortex architecture, and STM32 microcontrollers can help with the essential skills needed for this kind of work. The course covers the programmer's model, exception handling, and hardware interfaces, which can be extremely useful for aerospace applications. This course’s practical focus on setting up development environments and working with peripherals such as UART, I2C, and GPIO, will help anyone looking to enter this kind of role. The course’s instruction on bus interfaces and exception handling is essential for building safe and reliable aerospace systems. The skills gained from the course can be used for the development of flight control systems, sensor interfaces, and communication modules.
Robotics Engineer
A Robotics Engineer designs, develops, and tests robots, which often involve embedded systems and microcontrollers. This course helps a Robotics Engineer by covering the fundamentals of ARM Cortex microcontrollers and their peripherals, which are frequently used in robotics applications. This course's hands-on approach, which includes setting up development environments and working with communication protocols such as UART and I2C, provides practical experience for a Robotics Engineer who needs to interface sensors and actuators. The course sections on timers, counters, and analog-to-digital converters are also essential for any Robotics Engineer who develops systems for control and data acquisition. The course’s emphasis on understanding processor architecture, including the programmer's model and exception handling, further contributes to the essential skillset of a Robotics Engineer. The knowledge of the ARM Cortex architecture, as presented in this course will allow a robotics engineer to select the correct microcontroller for their robots, an important step in the design process.
Hardware Engineer
A Hardware Engineer designs, develops, and tests hardware components and systems, often working closely with firmware or software. While this role focuses more on hardware itself, the course provides an excellent understanding of how embedded hardware functions, especially ARM Cortex microcontrollers, which is essential for a Hardware Engineer. A deep understanding of the ARM Cortex architecture, the programmer's model, and core blocks, as covered in this course, equips the Hardware Engineer with insights into the hardware's capabilities and limitations. This course's focus on setting up development environments, and working with peripherals such as UART, I2C, and GPIO could help a Hardware Engineer better understand how these peripherals are used, and thus be able to better design or troubleshoot a system. A Hardware Engineer may use these skills to design, test and optimize their system. The knowledge gained regarding exceptions and bus interfaces also gives insight into the hardware's internal processes. This course provides a detailed exploration of these areas.
Control Systems Engineer
A Control Systems Engineer designs and develops systems that control the behavior of dynamic systems, and this often requires microcontrollers and embedded programming. This course's focus on fundamental concepts like ARM Cortex architectures, timers, and analog to digital conversions is relevant to the work of a Control Systems Engineer. The course's exploration of peripherals, including DAC and TIM, helps build the essential skills to develop control algorithms. The course’s hands-on exercises, such as Project 2 on DAC and TIM driver development, will be very valuable to a control systems engineer. The detailed instruction on setting up development environments, and interfacing peripherals such as those covered in this course, will equip a Control Systems Engineer with tools to develop control systems. Understanding exception handling is also necessary for building reliable embedded control circuits. This course may be helpful in understanding the process.
Embedded Software Test Engineer
An Embedded Software Test Engineer is responsible for testing software and hardware in embedded systems. This course may be helpful for a Test Engineer to understand the core functioning of embedded systems, and the test challenges that may be faced. The course’s coverage of ARM Cortex architecture, the programmer's model, and exception handling, will help a Test Engineer understand how the hardware and software interacts. The course sections on setting up a development environment and working with peripherals such as UART, I2C, and GPIO, may be useful as these are what embedded software interacts with. Experience with these systems will give a test engineer an intuitive understanding of what to look for when testing software. The course’s hands-on approach can be useful for any test engineer who also needs to debug or understand low level interfaces. This course may be a good fit.
System on a Chip Design Engineer
A System on a Chip Design Engineer designs and develops complex integrated circuits that combine various hardware and software components. While a System on a Chip Design Engineer may have more of a hardware focus, learning about the architecture of microcontrollers will deepen their knowledge of the systems they're designing. This course’s focus on ARM Cortex architecture and its core components may be helpful for someone looking to enter the field. The programmer's model, exception handling, and core blocks of the ARM Cortex will give a System on a Chip Design Engineer a better understanding of how these different components interact. This course's study of peripherals like UART, I2C, and GPIO could be useful, as these are often integrated into systems created by System on a Chip Design Engineers. This course can be a useful overview of embedded systems for any designer working with these types of embedded systems.
PCB Designer
A PCB Designer creates printed circuit boards, and a basic understanding of embedded systems is important for this work. This course's focus on the ARM Cortex architecture and STM32 microcontrollers may be useful for a PCB Designer to understand the components they place on their boards. The course's content about how various peripherals interact with the microcontroller, such as UART, I2C, and GPIO, helps build an understanding of circuit design. A PCB Designer does not need to program, but understanding the workings of the system is very useful. This course also has a section on setting up a development environment, which could be helpful when diagnosing issues after a board has been manufactured. This course may be useful for a PCB designer who wants a better understanding of the systems they help create.
Technical Support Engineer
A Technical Support Engineer provides technical assistance to customers who use embedded systems, and so a basic understanding of how these systems work may be useful. This course's focus on ARM Cortex architecture and STM32 microcontrollers will give a broad overview of the types of systems that may be supported. Understanding the programmer's model and how a system handles exceptions will allow a technical support engineer to better assist users. The knowledge of peripherals like UART, I2C, and GPIO would be helpful to a technical support engineer who may need to offer solutions that involve the use of these peripherals. This course may be helpful for a technical support engineer who would like a basic understanding of the embedded systems that they are supporting.
Applications Engineer
An Applications Engineer provides technical expertise and support to clients using embedded systems, and this course may provide some skills that are helpful in that role. This course introduces concepts like ARM Cortex architecture and the STM32 microcontroller, which would be relevant knowledge for those supporting customers in embedded systems. Understanding of the programmer's model and exception handling can help troubleshoot customer issues, as well as knowledge of peripherals such as UART, I2C, and GPIO. An Applications Engineer needs to be able to explain technical concepts clearly, and this course's content can give more insight into the kinds of systems they are supporting. While it does not directly teach these skills, this course may be helpful for any Application Engineer who is starting out in this field.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Foundation of Embedded Systems with ARM Cortex and STM32.
Provides a comprehensive overview of embedded systems architecture, covering topics such as processors, memory, and peripherals. It is particularly useful for understanding the hardware aspects of embedded systems and how they interact with software. This book serves as a valuable reference for understanding the underlying principles of embedded system design. It is commonly used in academic settings.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser