Courses

Embedded Systems Software Development Basics on the Arduino Platform

Embedded software from first principles, on hardware you can hold — reading sensors, driving servos and motors, timers, interrupts and serial communication, written so the code stays readable as the project grows.

• Installing the IDE and getting your first sketch onto a board
• Digital and analog I/O, and what the microcontroller is actually doing
• Timers, interrupts, and non-blocking code instead of delay()
• Serial communication: UART, I²C and SPI
• Reading a datasheet and driving a sensor from it
• PWM: duty cycle, frequency, and turning a digital pin into a variable output
• Driving actuators: hobby servos, DC motors, relays, and the drivers they need
• Object-oriented basics: classes, objects, and turning a sensor or motor into a reusable class
• State machines, and splitting the code into modules

Hardware Design Basics

From an idea to a board you can actually order. Every topic starts with the theory, then we build it in KiCad — working up to one complete development board with its microcontroller, sensors, actuators and analog and digital I/O. It is the same board the embedded software course runs on.

• Installing KiCad, and finding your way around the tools
• Schematic capture, and what a good schematic makes obvious
• Choosing components: datasheets, footprints and availability
• Power: choosing a regulator, decoupling, and getting a clean supply to the microcontroller
• Connectors and headers: bringing sensors, actuators and analog/digital I/O off the board
• PCB layout basics — stackup, routing and ground
• Design rules that match what your fab can actually build
• Manufacturing outputs: gerbers, drill files, BOM and pick-and-place
• The project: one complete development board, carried from blank sheet to ordered

Control Systems and Simulation Basics in Python

Model a real system, then control it — entirely in Python. Build the plant, close the loop, write a PID from scratch, and pick up the theory along the way — stability, frequency response, filtering — that explains why it behaves the way it does.

Assumes basic algebra and calculus, differential equations, and some signals and systems.

• Installing Python and the scientific stack, and running your first simulation
• What a dynamic system is, and writing one down as equations
• Transfer functions and block diagrams: from a differential equation to G(s), and combining blocks into a loop
• Simulating a plant: time steps, integration, and why the step size matters
• Open loop versus closed loop, and what feedback actually buys you
• Poles, damping and stability — why a system oscillates, and what tuning actually changes
• The frequency domain: Bode plots, gain and phase margin, and what they predict
• System identification: fitting a model to a measured step response
• PID from scratch: proportional, integral and derivative — and anti-windup
• Steady-state error and system type: why P alone leaves an offset and I removes it
• Tuning, and reading a step response: rise time, overshoot and settling
• Feedforward: correcting a disturbance before the error appears
• Making a simulation honest: sensor noise, quantisation and actuator limits
• Filters: low-pass, high-pass, and taming a noisy measurement
• Discrete time: sample rate, PID as a difference equation, and what changes on real hardware
• Comparing P, PI and PID on the same plant, and plotting results that mean something

ROS 2 and Gazebo Basics

Build a mobile robot that finds its own way around, entirely in simulation — nodes and topics, a robot you describe yourself, simulated sensors, a map it builds while driving, and a path planner you can watch think.

• Installing ROS 2 and Gazebo, and running your first node
• Nodes, topics and messages — how the pieces of a ROS system talk to each other
• Workspaces and packages: colcon, and where your code actually lives
• Writing nodes in Python: publishers, subscribers and timers
• Services, actions and parameters, and when to reach for each
• Launch files: starting a whole system instead of six terminals
• Describing a robot: URDF, links, joints, and the TF tree
• Gazebo: worlds, spawning your robot, and simulating its sensors
• Driving it: /cmd_vel, odometry, and closing the loop
• LiDAR and the occupancy grid: what the robot actually knows about the world
• SLAM: building a map while driving through it
• Path planning: A*, Dijkstra, BFS and DFS, and what each costs to find the same path
• RViz and debugging: seeing a system you otherwise cannot

Industrial Robotics Basics in FANUC RoboGuide

Programming six-axis industrial robots entirely in simulation — the teach pendant and TP programs, motion and frames, program logic, machine tending and I/O handshakes, camera vision and safety zones, in a full workcell you build yourself.

• Installing RoboGuide, and setting up your first cell
• Building a workcell: robot, tooling, fixtures and part flow
• The teach pendant: jogging, creating a TP program, and teaching positions
• Joint, linear and circular motion — and when each is the right one
• Speed and termination: FINE, CNT, and how blending changes both the path and the cycle time
• Tool and user frames: setting a TCP with the six-point method, and why a wrong frame breaks everything downstream
• Registers, position registers, and program flow: IF, JMP/LBL, CALL and WAIT
• Digital I/O and handshaking between the robot and a machine
• Machine tending: commanding a CNC — door, chuck, cycle start — and reading its status back
• Pick and place, and palletizing with position registers
• Coordinating two robots in one cell: agreeing who moves next, and staying out of each other
• Camera basics: how machine vision works, and adding a simulated camera in RoboGuide
• Putting vision to work: obstacle detection, and counting what the camera finds
• Safety: interference zones, DCS, fences and E-stop — set up in simulation first
• Collision-free paths and checking the cycle time you actually get

PLC Programming Basics with TIA Portal and Factory I/O

Ladder logic on a Siemens S7-1500, driven against a 3D plant in Factory I/O. Start in the simulator, wire the two together, then spend most of the course building and debugging real processes — no hardware required.

• Installing TIA Portal and Factory I/O, and getting both running
• Factory I/O basics: building a scene, and its sensors, actuators and tags
• TIA Portal basics: setting up a project, an S7-1500 CPU, and PLCSIM
• The scan cycle, and how it shapes the way you write logic
• Connecting TIA Portal to Factory I/O, and getting the I/O mapping right
• Ladder logic: contacts, coils, timers and counters
• Function blocks and reusable code: FB, FC and data blocks, instead of copying rungs
• Analog I/O: reading tank levels, and scaling raw counts to engineering units
• Structuring a process as a state machine — start, stop, reset and emergency stop
• Basic process control: driving valves and pumps, on/off control with hysteresis, and sequencing a batch
• Plenty of practice: complete processes built and debugged end to end in simulation

Advanced Embedded Software Development with ESP-IDF and FreeRTOS

Off Arduino and onto a real toolchain — modern C++ on ESP-IDF, a project structured into components, FreeRTOS and the concurrency bugs it invites, wired and wireless communication, and the version control and testing that keep a growing codebase under control.

• Setting up ESP-IDF, and what a real toolchain gives you over the Arduino IDE
• Components and CMake: structuring a project that is more than one file
• Modern C++ on a microcontroller: classes, RAII, and what to avoid
• Architecture: interfaces, dependency injection, and code you can actually test
• Unit testing firmware, on the host and on the target
• FreeRTOS: tasks, priorities, and how the scheduler decides
• Queues, semaphores and mutexes: moving data between tasks
• Race conditions and priority inversion — the bugs concurrency invents
• Wired protocols: UART, I²C, SPI and RS485
• WiFi: connecting, provisioning, and staying up when the network is not
• Ethernet and TCP/IP: sockets, and talking to something off the board
• Storage and OTA: NVS, flash, and updating firmware after it has shipped
• Debugging with JTAG, and reading a crash dump
• Git in practice: branches, history, and working with other people

Advanced Hardware Design: Mixed-Signal Boards

A board where analog and digital have to share the same copper — floorplanning, power integrity, grounding, analog front-ends, EMC and heat, and the layout decisions that determine whether the quiet signals stay quiet.

• Multilayer stackups, and choosing one for a mixed-signal board
• Floorplanning: separating analog and digital before you route anything
• Power: linear versus switching regulators, and which one belongs where
• Decoupling and the power distribution network: where the return current flows
• Grounding: planes, splits, and the myths worth unlearning
• Op-amps and analog front-ends: gain, offset and filtering
• Driving an ADC properly: sampling, aliasing, and the reference
• Noise and crosstalk: where they come from, and how to find them
• EMC: emissions, immunity, and designing to pass the first time
• High-speed routing: impedance, length matching and differential pairs
• Thermal design: dissipation, copper as a heatsink, and sensing temperature
• Design for manufacture and test: fine pitch, tolerances, test points, and what your fab charges extra for
• Bring-up: testing a board you have never powered before

Advanced Control Systems in Python: Classical, State Space and Fuzzy

Beyond a single PID loop — first the classical analysis the basics course deliberately skipped, then state space with observers and optimal control, and finally fuzzy controllers for the cases where the rules are easier to write than the maths.

• The Laplace transform by hand: where transfer functions actually come from
• Root locus: how the closed-loop poles move as you turn the gain up
• Nyquist: stability and margins read off the open-loop frequency response
• State space: describing a system with matrices instead of one transfer function
• Controllability and observability — what the state-space model tells you before you design
• State feedback and pole placement
• Observers: estimating the states you cannot measure
• LQR: letting a cost function do the tuning for you
• Fuzzy control: membership functions, rule bases and defuzzification
• Building a Mamdani controller, and tuning it by rewriting rules
• Comparing PID, state feedback and fuzzy honestly on the same plant