Beyond Arduino, Pt 3: Interrupt Driven Embedded Applications

Beyond Arduino, Pt 3: Interrupt Driven Embedded Applications, available at $49.99, has an average rating of 4.25, with 81 lectures, based on 89 reviews, and has 1317 subscribers.

You will learn about Create professional grade embedded applications. Think of embedded applications in an Interrupt-Driven fashion. Create responsive embedded applications. This course is ideal for individuals who are Arduino Developers. or Software Developers. or Makers. It is particularly useful for Arduino Developers. or Software Developers. or Makers.

Enroll now: Beyond Arduino, Pt 3: Interrupt Driven Embedded Applications

Summary

Title: Beyond Arduino, Pt 3: Interrupt Driven Embedded Applications

Price: $49.99

Average Rating: 4.25

Number of Lectures: 81

Number of Published Lectures: 81

Number of Curriculum Items: 81

Number of Published Curriculum Objects: 81

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

Create professional grade embedded applications.
Think of embedded applications in an Interrupt-Driven fashion.
Create responsive embedded applications.

Who Should Attend

Arduino Developers.
Software Developers.
Makers.

Target Audiences

Arduino Developers.
Software Developers.
Makers.

In this third part of the Beyond Arduino series, you’ll learn why single-threaded applications are inefficient and perform so bad when handling input/output requests.

You’ll learn about the Interrupt-Driven approach to handling asynchronous events and most of its advantages over the traditional approach to do everything inside a loop, which you aren’t always aware of because of the immense body of elements that conceal the details in many beginner platforms, like the Arduino, for the sake of simplicity.

You’ll learn theoretical, proven facts about the advantages of Interrupts, and you’ll also get to try it with your own microcontroller platform on several optional projects that are presented to you as challenges. So this is not exactly a hands-on course, not if you don’t want it to be. There are no promises on the projects you’ll make because we won’t force you to build something you didn’t choose to. However, we strongly recommend that you code along. Several microcontroller development platforms are showcased, but you should follow the examples with your own microcontroller.

After grasping this knowledge, we expect you to think differently when designing your embedded applications in the future. By adding this technique to your bag of tricks, you’ll get one step closer to making embedded applications like a professional, and hopefully you’ll feel less like a beginner.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course Structure

Lecture 2: Instructor Introduction

Lecture 3: Motivation

Lecture 4: Live Motivation

Chapter 2: Polling vs. Interrupts

Lecture 1: Input Output Handling

Lecture 2: The Options

Lecture 3: More on Polling

Lecture 4: More on Interrupts

Lecture 5: An Everyday Analogy

Lecture 6: Some Modelling Assumptions

Lecture 7: Solution by Polling

Lecture 8: Solution by Interrupts

Lecture 9: How do These Schemes Compare?

Lecture 10: Watch out for Abused Polling

Lecture 11: Comparing the Options

Lecture 12: Best Case Efficiency for Polling

Lecture 13: How the Hotel Analogy Relates to Code Execution

Lecture 14: A Simpler Everyday Analogy

Lecture 15: How the Incoming Call Analogy relates to Code Execution

Lecture 16: Polling and Interrupts in Software

Lecture 17: The Polling Version

Lecture 18: The Interrupt Driven Version

Lecture 19: How it All Looks Over Time

Chapter 3: Elements of Interrupt Handling Hardware

Lecture 1: What Makes it all Work

Lecture 2: The Global Interrupt Mask

Lecture 3: Local Interrupt Enable Bits

Lecture 4: Local Interrupt Flags

Lecture 5: Interrupt Service Routines

Lecture 6: Interrupt Vectors

Lecture 7: The Stack

Chapter 4: Interrupt Handling Process

Lecture 1: Prerequisites for interrupts

Lecture 2: What happens when an interrupt occurs

Lecture 3: Let's recall our example

Lecture 4: Function Content Description

Lecture 5: Runtime Example

Lecture 6: Step 1 – The Running Instruction is Completed or Aborted

Lecture 7: Step 2 – The CPU is pushed into the Stack

Lecture 8: Step 3 – The ISR is Retrieved from the Vector

Lecture 9: Step 4 – The Interrupt Service Routine is Executed

Lecture 10: Step 5 – The CPU is Popped from the Stack

Lecture 11: Step 6 – Execution Resumes where it Left Off

Chapter 5: Why we need Interrupts

Lecture 1: Why we need Interrupts

Lecture 2: Responsiveness

Lecture 3: Efficiency

Lecture 4: Portability

Lecture 5: Scalability

Lecture 6: Priority Awareness

Lecture 7: Efficient Energy Consumption

Chapter 6: Wait, Polling isn't that bad either

Lecture 1: Blocking Functions

Lecture 2: Non-Blocking Functions

Lecture 3: An Everyday Analogy

Lecture 4: Polling Abused

Lecture 5: Interrupts Abused

Chapter 7: Programmer's Mechanism

Lecture 1: Case Study: ARM Cortex Family

Lecture 2: Case Study: Freescale S08 Architecture

Lecture 3: Case Study: The Arduino Uno!

Lecture 4: Optional Project: Make a Proof of Concept

Chapter 8: An Arduino Live Demo

Lecture 1: A Live Demo

Lecture 2: Live Demo code

Chapter 9: More Live Demos

Lecture 1: Going Beyond Arduino

Chapter 10: Live Demo: GD32V RISC-V Microcontroller

Lecture 1: The GD32V Microcontroller

Lecture 2: About the GD32V Microcontroller

Lecture 3: The ECLIC Module

Lecture 4: An Abused Polling Application

Lecture 5: Abused Polling Application Hardware

Lecture 6: The Abused Polling Application Code

Lecture 7: The Abused Polling Application Barely Working

Lecture 8: The Interrupt-Driven Application Code

Lecture 9: The Timer Initialization Function

Lecture 10: The Timer Interrupt Handler

Lecture 11: So Where is the Interrupt Handler Defined?

Lecture 12: The Interrupt-Driven Application Working

Chapter 11: Live Demo: STM32 ARM Microcontroller

Lecture 1: The STM32 Project Hardware

Lecture 2: The STM32 Project

Lecture 3: The STM32 Polling Code

Lecture 4: The STM32 Interrupt-Driven Code

Lecture 5: The STM32 Polling Application Working

Lecture 6: The STM32 Interupt-Driven Application Working

Chapter 12: Beyond Interrupts

Lecture 1: Farewell

Lecture 2: Optional Project: Make an Asynchronous Serial Transmitter of Receiver

Lecture 3: Bonus Lecture: More from Closure Labs!

Instructors

Eduardo Corpeño
Electrical & Computer Engineer
Marissa Siliezar
Telecom Engineer

Rating Distribution

1 stars: 2 votes
2 stars: 5 votes
3 stars: 8 votes
4 stars: 36 votes
5 stars: 38 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu