This course is designed to provide a hands-on learning experience in IoT, edge computing, and embedded systems using a variety of platforms such as microcontrollers (nRF, STM32, ESP32), FPGAs (Xilinx), and SoCs (Raspberry Pi, Zynq). Each module contains a project that reinforces the theory covered, allowing students to design, build, and deploy real-world IoT solutions.
- Foundations of IoT, Edge Computing, and Embedded Systems
- Microcontroller Programming for IoT
- Basic Hardware Design for IoT Systems
- Real-Time Operating Systems (RTOS)
- Introduction to FPGAs for Edge Computing
- SoCs for IoT and Edge Computing
- IoT Communication Protocols
- Power Management and Real-Time Processing
- Security and Privacy for IoT
- Introduction to Industrial IoT (IIoT)
- Capstone Project
This introductory module covers the basics of IoT, edge computing, and embedded systems, including key hardware platforms like microcontrollers, FPGAs, and SoCs.
- What is IoT?
- Edge computing overview
- Introduction to microcontrollers, FPGAs, and SoCs
- Low-power design basics
Design a Simple IoT System Architecture
Map out a system showing how a microcontroller (e.g., ESP32) interacts with sensors and communicates with the cloud.
Learn how to program microcontrollers for IoT applications, focusing on platforms like nRF, STM32, and ESP32.
- Basics of microcontrollers (nRF, STM32, ESP32)
- Programming in C/C++ (blinking LEDs, sensor data)
- Bluetooth (BLE) and Wi-Fi communication
- Low-power modes
Build a Simple IoT Sensor System
Program an ESP32 or nRF52 to read sensor data and send it over Bluetooth or Wi-Fi.
This module focuses on designing circuits and connecting sensors to microcontrollers.
- Circuit design basics
- Power supply for IoT devices
- Breadboarding and PCB design (optional)
- Debugging hardware connections
Design a Basic IoT Circuit
Build a circuit that connects a sensor to an LED and control it using a microcontroller.
Understand the basics of Real-Time Operating Systems (RTOS) for handling multitasking applications in IoT systems.
- Introduction to FreeRTOS and Zephyr
- Task scheduling and interrupts
- Low-power management with RTOS
Develop an RTOS-Based IoT System
Use FreeRTOS or Zephyr on an STM32 or ESP32 to manage tasks like sensor data collection and communication.
Learn the basics of FPGA programming and how to use them for accelerating edge computing tasks in IoT.
- What are FPGAs?
- Simple Verilog/VHDL programming
- Xilinx FPGA toolchain (Vivado)
- Basic FPGA applications
Create a Simple FPGA-Based Project
Program a Xilinx FPGA to control LEDs and read sensor data using Verilog or VHDL.
Introduction to System-on-Chip (SoC) platforms like Raspberry Pi and Xilinx Zynq, combining CPU and FPGA capabilities for IoT and edge computing.
- What is an SoC? Raspberry Pi and Zynq overview
- Running Linux on SoCs
- Interfacing sensors and devices with SoCs
- Edge computing with SoCs
Develop a Linux-Based Edge Computing System
Use a Raspberry Pi or Xilinx Zynq SoC to perform local data processing before sending results to the cloud.
Learn about the most common IoT communication protocols used for device-to-device and device-to-cloud communication.
- MQTT, CoAP, HTTP protocols
- Bluetooth, Wi-Fi, and LoRa communication
- Secure communication (SSL/TLS)
- Low-power communication techniques
Implement Wireless Communication for IoT
Use an ESP32 to send sensor data via MQTT to a cloud platform, securing the communication with SSL/TLS.
This module focuses on power optimization techniques and real-time data processing for IoT devices.
- Sleep modes and low-power components
- Real-time clocks (RTC) for scheduling tasks
- Balancing power and performance in edge computing
Develop a Low-Power IoT Sensor System
Build a low-power sensor system that logs data periodically using a microcontroller like STM32 or nRF52.
Understand the key security principles for IoT systems, including protecting data and firmware.
- Common IoT security vulnerabilities
- Secure communication (SSL/TLS)
- Secure boot and encryption
- Firmware protection and OTA updates
Build a Secure IoT System
Implement secure communication and secure boot on an ESP32, ensuring data integrity and encryption.
This module introduces the Industrial IoT (IIoT) and explains how IoT technology is applied in industrial environments.
- What is IIoT? Applications and differences from consumer IoT
- Real-time monitoring and data collection for industrial systems
- Rugged hardware design for harsh environments
Develop an IIoT Monitoring System
Use a Raspberry Pi or STM32 to monitor industrial equipment and send alerts based on pre-set conditions.
The capstone project brings together everything you’ve learned throughout the course to create a complete IoT system.
Capstone Project: Design a Complete IoT System
Design, build, and deploy a complete IoT system using microcontrollers (e.g., nRF, STM32, ESP32), FPGAs (Xilinx), or SoCs (Raspberry Pi, Zynq). This system should include secure communication, power optimization, real-time processing, and cloud integration.
- Each module has its own directory with the course material, code samples, and project instructions.
- Follow along with the README files in each module's folder to complete the projects.
- Share your progress and completed projects via GitHub issues or discussions.
- Basic understanding of C/C++ programming
- Access to development boards (e.g., ESP32, STM32, nRF52, Raspberry Pi, Xilinx FPGA)
- Familiarity with basic electronics and hardware (optional for beginners)
This course material is licensed under the MIT License.