AIoT in Action: From Touch Screen to IoT Platform (MicroPython)

Level

L2 Guided

Estimated time

36 hours · 5 modules · 36 lessons

Hardware

BENTO Emulator (no board needed) · Eva Kit · Dev Kit

For

General public · Students · Developers · Entrepreneurs · Educators

Status

Alpha

Licence

content: CC-BY-NC-4.0 · code: MIT

• Course files on GitHub

Adapted from AIoT in Action — Embedded Systems for AIoT Developer, © 2026 Assoc. Prof. Wiroon Sriborrirux, Embedded Systems Engineering, Department of Electrical Engineering, Faculty of Engineering, Burapha University (BUU), Advance Innovation Centre (AIC) · BENTO & TESAIoT (CC BY 4.0 / MIT)

Thai version: README.md. The lessons, slides and code comments are in Thai (technical terms and code in English).

Learn AIoT hands-on on the PSoC Edge boards — the Eva Kit or the TESAIoT Dev Kit — in MicroPython. You start by playing the apps that ship on the board, so you see where the course ends, then peel it open layer by layer until you can build the whole chain yourself:

touch screen → hardware → sensors → network → MQTT → IoT platform → your own product

The same example files run on both boards: the code asks the board how many LEDs it has, what its button is called and which sensors are present. No compiler, no C toolchain.

Who it is for

• Anyone, including entrepreneurs, who wants to understand how an AIoT system works from the real thing
• Software developers who know some Python and want to work with hardware, sensors and IoT
• Engineering and science learners who want a hands-on start in embedded systems
• Educators who want ready lessons with slides, code, practice files and solutions

You need basic Python (variables, if, loops, functions). No electronics background is required. You can learn alone or in a team of two to four per board.

Outcomes

1. Explain how sensing, on-device decisions, the display and the destination platform share the work in an AIoT system, decide which work should stay on the board and which should leave it, and give at least one industrial example.
2. Write MicroPython programs that drive the board’s hardware (LEDs, button, touch pads, analog input) and build a touch-screen UI whose on-screen state matches the real hardware in every test.
3. Read sensor data (IMU, compass, CapSense, potentiometer), choose and apply a suitable filter, and design a real-time HMI dashboard that stays within its widget budget and update rate and runs for 10 minutes.
4. Connect the board to WiFi, send and receive data over MQTT in both directions, and compare the port 1883 channel with TLS-encrypted MQTTs (serverTLS): what it protects and what it still does not.
5. Assemble everything into an AIoT mini-product that solves one real problem, keeps working when the network drops, sends data in a schema you designed, and present it in 10 minutes.

What you need

• A board: BENTO PSoC Edge Eva Kit (KIT_PSE84_EVAL_EPC2) or TESAIoT Dev Kit (KIT_PSE84_AI SoM on the QWA309 base) with the BENTO MicroPython firmware — or start without a board in the BENTO Emulator inside BENTO IDE (some lessons need the real board; see each lesson’s hardware line)
• BENTO IDE — https://ide.tesaiot.dev/ write code and press Program to Device from the browser; the BENTO Emulator is built in
• WiFi from lesson 1.4 (first connection) and throughout module 4 · networks that need a web login do not work for the board; use a phone hotspot
• TESAIoT Community Edition for lessons 4.5–4.6 — a self-hosted IoT platform (https://github.com/tesaiot/tesaiot-community-edition) · a TESAIoT Platform account for MQTTs in lessons 4.7–4.9 (a self-installed CE cannot take MQTTs from the board; see lesson 4.7) · the other plain-MQTT lessons and the capstone use a public practice broker. When learning in a group, the organiser may prepare a broker and device identities for you
• A notebook or file for your own learning log; the slides say what to record

Course map

Five modules, 36 lessons: about 36 hours as in the source course (twelve 3-hour sets); the lesson estimates add up to about 38 hours, 45–75 minutes per lesson. Lessons come in sets of three: concept → code walk-through → hands-on.

Module	Lessons	Hours (approx.)	Topic
Module 1 — Existing UI-based Application	6	6.8	Meet the board through the apps it ships with, put your first lines on screen with lcd and ui, then send a value out over the network and take a command back.
Module 2 — UI-to-Hardware Interfacing	9	9.4	Drive LEDs and read the button with gpio, build a touch control panel that controls the real LEDs, then read the knob and CapSense and filter the signal.
Module 3 — Sensor Visualization on HMI	9	8.9	Turn acceleration into tilt, sample correctly and draw real-time charts, and assemble a four-card mini-HMI dashboard that keeps running.
Module 4 — IoT Platform Connectivity	9	9.4	Join WiFi and read the network, send telemetry and take commands over MQTT with a self-hosted platform, then move to MQTTs over TLS.
Module 5 — Capstone: AIoT Mini-Product	3	3.3	Start from a real problem, design with a canvas and a schema, assemble Sense → Decide → Show → Send into a mini-product that survives a network drop, and present it in 10 minutes.

All lessons

Module 1 — Existing UI-based Application

• Lesson 1.1 — Board tour: play with the real thing first
• Lesson 1.2 — First lines on screen: the lcd and ui modules
• Lesson 1.3 — Inside the box: two cores, AIoT and your team’s screen
• Lesson 1.4 — Leaving the desk: the first WiFi connection
• Lesson 1.5 — Values out, commands back: MQTT on a public broker
• Lesson 1.6 — Hands-on: a real value leaves the board, module 1 wrap-up

Module 2 — UI-to-Hardware Interfacing

• Lesson 2.1 — The gpio module: LEDs, a button and a board that describes itself
• Lesson 2.2 — Behind LEDs and buttons: active-low, debouncing and the endless loop
• Lesson 2.3 — Hands-on: running lights, a button, and the broker
• Lesson 2.4 — The touch screen and your first widgets
• Lesson 2.5 — The event loop: touch the screen, light the real LED
• Lesson 2.6 — Hands-on: your touch control panel and the next widgets
• Lesson 2.7 — Analog and touch: the ADC, the potentiometer and CapSense
• Lesson 2.8 — Filtering: EMA vs Median, then the gauge code
• Lesson 2.9 — Hands-on: the potentiometer gauge and touch slider

Module 3 — Sensor Visualization on HMI

• Lesson 3.1 — The accelerometer and tilt: roll and pitch
• Lesson 3.2 — Gyro, the complementary filter and the level code
• Lesson 3.3 — Hands-on: the digital level
• Lesson 3.4 — Sampling right: Nyquist, aliasing and the ring buffer
• Lesson 3.5 — ui.Chart: multi-series plots and the real loop period
• Lesson 3.6 — Hands-on: a three-axis acceleration chart
• Lesson 3.7 — HMI design: cards, visual order, colour and the widget budget
• Lesson 3.8 — Building the dashboard: four cards in one loop
• Lesson 3.9 — Hands-on: the mini-HMI dashboard and the 10-minute soak test

Module 4 — IoT Platform Connectivity

• Lesson 4.1 — WiFi and networking: dBm, DHCP, IP and DNS
• Lesson 4.2 — The network status screen: reading the wifi code
• Lesson 4.3 — Hands-on: your team’s network status page
• Lesson 4.4 — MQTT: pub/sub, topics, QoS and the data budget
• Lesson 4.5 — MQTT with a self-hosted platform: telemetry and commands
• Lesson 4.6 — Hands-on: two-way telemetry
• Lesson 4.7 — TLS: certificates, the chain of trust and the handshake
• Lesson 4.8 — The tesaiot module: MQTTs to the platform
• Lesson 4.9 — Hands-on: real readings over an encrypted channel

Module 5 — Capstone: AIoT Mini-Product

• Lesson 5.1 — From a real problem to a design: canvas, schema and designing for failure
• Lesson 5.2 — The starter: Sense, Decide, Show, Send
• Lesson 5.3 — Build and present your AIoT mini-product

Licences

• Content (slides, READMEs, own diagrams and screenshots) — CC BY-NC 4.0
• Code (examples/, practice/, solution/, shared/) — MIT, Copyright (c) 2026 Wiroon Sriborrirux, Advance Innovation Centre (AIC), Burapha University (full licence text in the repository’s LICENSES/MIT.txt)
• Third-party images keep their own licences; authors, sources and licences are listed in credits.yaml. Figures from Infineon’s board guide are used for teaching; rights remain with Infineon Technologies AG.

Source

Adapted from AIoT in Action — Embedded Systems for AIoT Developer by Assoc. Prof. Wiroon Sriborrirux, Embedded Systems Engineering, Department of Electrical Engineering, Faculty of Engineering, Burapha University (BUU), Advance Innovation Centre (AIC) (repository @ a80bbe88 · slides site). The twelve decks were split into lessons, grouped into five modules, and the wording was adapted for a general audience. BENTO & TESAIoT.

How to cite TESA

When you use, adapt or redistribute this course or part of it, credit it as follows (add “(adapted)” after the title if you changed it, and keep the upstream AIC credit):

“AIoT in Action: From Touch Screen to IoT Platform (MicroPython)” from TESA Open Knowledge by the Thai Embedded Systems Association (TESA), https://github.com/tesaiot/tesa-qualification-program, licensed under CC BY-NC 4.0 · Adapted from AIoT in Action — Embedded Systems for AIoT Developer, © 2026 Assoc. Prof. Wiroon Sriborrirux, Embedded Systems Engineering, Department of Electrical Engineering, Faculty of Engineering, Burapha University (BUU), Advance Innovation Centre (AIC) · BENTO & TESAIoT (CC BY 4.0 / MIT)

Attribution does not mean that TESA or Infineon endorse or certify your course or work. “TESA”, “TQP” and “Certified by TESA and Infineon” are marks of the programme.

Companion videos for this course

Watch on YouTube (opens in a new tab)

• Software Development Process - EP01 : Overall Software Development Process Thai Embedded Systems Association (TESA)
• Software Development Process - EP02 : User Needs Thai Embedded Systems Association (TESA)
• Software Development Process - EP03 : System Requirements Thai Embedded Systems Association (TESA)

Videos by Thai Embedded Systems Association (TESA) · The whole series in the playlist AIoT Foundation