Embedded Systems State Machines & Data Structures

Explore finite state machines, their state and input–output relationships, and how state transition diagrams guide parsing tasks like detecting double slashes, with practical steps from diagram to code.

build a three-state finite state machine for embedded systems, using a state table of function pointers, clocks to drive transitions, and per-state execution with simple print outputs.

Continue building a finite state machine by enabling the timer and implementing a one-second clock to drive states A, B, and C, while printing their execution times and deltas.

Implement a fixed scheduler with a finite state machine by repeating state A, using a state table and clock modulo logic to cycle through states.

Explore how pointers represent memory locations and addresses, enabling access to variables, arrays, and dynamic memory in embedded C. Learn about lvalues and rvalues, dereference, and void and pointer-to-pointer concepts.

Explore arrays and pointers in embedded c by creating a 5-element data array, inspecting memory, and verifying multiple ways to access elements via index and pointer arithmetic.

Learn to find the first and second largest values in an array and implement basic array operations, building the array as an abstract data type with a prototype.

Develop an array adt by wrapping a fixed-size array in a struct, tracking capacity and length, and enabling insertion, merging, and other operations.

Explore array insertion by appending elements and inserting at a given index, including length checks, capacity, and shifting elements to create space in an array data type.

Apply array ADT operations by deleting an element at a given index and reversing the entire array in C, with length checks and dynamic memory management.

Implement functions to check if an array is ascending or descending, then sort the array in the desired order using prototypes, pointers, and array data indices.

Compute the statistical characteristics of an array, including the minimum value, maximum element, total sum, and the mean of the elements, by implementing iterative functions.

Learn to merge two arrays using a custom merge function, create a destination array, and handle pointers, indices, and dynamic storage to combine signal 1 and signal 2.

Explore structures and unions as user-defined types that store related data, and learn that a structure defines a memory layout while typedef creates a new type alias without extra memory.

Understand unions as a memory-efficient alternative to structures, storing only one field at a time. The size equals the largest member, and you declare with the keyword union or typedef.

Explore working with structures in C by creating, initializing, and manipulating shape structures using dot and arrow operators, plus dynamic allocation with malloc and heap memory.

Explore how unions differ from structures by initializing two coordinate types and observing that a union stores only the last assigned value, while a structure retains both.

Define a shape struct with type and x, y coordinates, create an array of shapes, initialize five items, and iterate to print their coordinates.

Explore nested structures by embedding a shape inside a screen structure and use type 2 initialization to assign shape members and screen dimensions.

Compare Moore and Mealy finite state machines: Moore outputs depend only on the current state, while Mealy outputs depend on state and inputs; illustrated with traffic lights and state graphs.

Design a traffic light system for two one-way streets using a Moore FSM, where six outputs drive the lights and car sensors determine which road has priority.

Implement a traffic light Moore finite state machine for an embedded system, initializing port a and port c, enabling clocks, and driving LED outputs with north and east lights.

Implement a Moore finite state machine for a traffic light, starting from go north, processing outputs, delays, and input-driven next states with north central and east central sensors.

Implement a Moore FSM using pointers, with a state pointer and address-based states, accessing outputs and time via the arrow operator, and reading inputs to transition to the next state.

Implement function-based state actions in a state machine by replacing the output with a function pointer and wiring go north, go east, and wait functions that print status via uart.

Develop a Mealy finite state machine for an engine control system, where brake and gas outputs depend on input and current state, detailing stop and go transitions.

Implement a mealy finite state machine for an engine control system. Define symbolic brake and gas ports, and build state and output tables to drive signals.

Understand how linked lists store data non-contiguously with next pointers and a null terminator, enabling insertions and deletions in constant time.

Explains the singly linked list, where each node has a next pointer and the list ends with null, and how to insert at head, tail, or a middle position P.

Learn how to implement a simple linked list in C by defining a node struct, using malloc for dynamic allocation, and traversing to print data.

Create a linked list from an array with a function that uses the array and length to return the head, populating nodes with task priorities for an operating system.

insert nodes into a linked list at the beginning, middle, or end, and compute length to guide traversal; implement insert with a head pointer.

Implement deletion in a linked list using a delete function that validates the index, removes the target node (including head), frees memory, and returns the deleted value.

Find the minimum and maximum values in a linked list by traversing nodes, comparing each data field, and updating the min and max as you go.

Learn to reverse a linked list by copying data into a dynamic array, traversing nodes, and re-linking from tail to head, with memory allocation checks and a reverse function.

Develop a digital input driver to collect data and store it in data structures, using pc13 as input, configuring the mode register, and reading the input data register.

Develop an ADC driver to collect analog data by configuring P1 as analog, enabling ADC clock, selecting software trigger, starting conversion, polling completion, and returning the analog value.

Develop a temperature sensor driver that uses the ADC to sample the MCU's internal temperature every second, configuring timer two and converting results to Celsius.

Insert real-time temperature readings into a linked list using the provided drivers, demonstrating insertion at the head and indexed positions, and verify by traversing and printing the list.

Delve into doubly linked lists, and contrast them with singly linked lists. Learn insertion at the beginning and pointer updates for implementation.

Implement a doubly linked list in C by inserting at the start, end, and middle, using a node with data, prev and next pointers, plus print and length utilities.

Learn deletion functions for a doubly linked list, including delete last, delete from front, and delete at a position, with head, current, and temp pointers.

Explore circular linked lists, their lack of a null terminator, and safe traversal using the head and a current pointer. See their use in resource sharing in operating systems.

Develop a circular linked list by implementing insertion at the end, traversing the list, computing length, and printing node data, using a typedef node structure and head pointer.

Implement circular linked list deletion functions for end and start, using dummy pointers, traversal, and memory management, with tests printing list length.