Embedded Wifi Bare-Metal Development From Ground Up™

Explore the protocol stack and its physical, data link, and network layers, including tcp/ip and udp. Identify terms such as packets, gateway, router, and access point used in wifi development.

Explore how IEEE 802.11 Wi‑Fi enables wireless LANs, including basic service sets, infrastructure and ad hoc modes, access points, distribution systems, and the physical and MAC layers.

Explore the history of the Wi-Fi protocol, tracing variants such as 802.11b, 802.11a, 802.11n, 802.11ac, and 802.11ax, along with their frequencies, speeds, and ranges.

Understand the wifi protocol's frequencies, 2.4 ghz with 14 channels and 20–22 mhz, and 5 ghz with 13 channels and 20 mhz, plus signal strength and interference from wireless protocols.

Scaffold a bare-metal ESP32 driver project, rename and copy templates, configure includes, select the SDM32 board, and set up USART2 as the debug interface with clock and alternate-function pins.

Enable the peripheral clock, set the uart gpio pins to alternate function mode, and configure the alternate function registers to af7 for the uart signals.

Configure uart parameters by enabling clock access on the APB1 bus, computing baud rate from the 16 megahertz system frequency, and enabling transmitter and receiver in the control register.

Implement a UART write function that waits for the transmit data register empty (TXI) bit in the status register and then writes the byte to the transmit data register.

Test the debug uart driver by initializing the board, building the project, and verifying character transmission via a real-time terminal at 115200 baud.

Develop the ESP UART driver to enable communication between the Wi-Fi chip and the microcontroller. Copy the project, configure module one pins and alternate function, and enable clocks and interrupts.

Develop a system tick timer to provide a millisecond time base using the internal clock. Configure SysTick with reload, current value, and control registers to enable delays.

Explore the first in, first out data structure, linking producers to consumers through a Pfeifle. Learn how Pfeifle puts and Pfeifle get manage data packets with a keyboard example.

Implement the transmitter fifo put function using the Pfeifle data structure to manage data between the microcontroller and the wifi chip, defining fifo size and iterators.

Implement the transmitter fifo get function to fetch data when not empty by advancing the get iterator and returning success; return false if empty.

Learn to implement the receiver (rx) fifos by cloning Pfeifle code, replacing TX with RX, creating a new source file, and adding function prototypes to expose RX functionality.

Test the fifo by initializing buffers, pushing 100 values, retrieving them with get, and debugging to verify put and get; overflow with char data is resolved by a larger type.

Explore how a circular buffer uses head and tail pointers, wraparound via modulo, and a data array to insert and read data efficiently.

Implement the initialization function for a circular buffer in a bare-metal wifi project, setting up buffers, head, tail, and enabling irex interrupts for esp uart.

Implement a function to store a character in a circular buffer using a pointer to the buffer and the character, perform overflow checks, and update head and tail pointers.

Develop a substring search function using two character pointers and nested loops, returning 1 when found and -1 when not. The lesson prepares for integrating a wifi chip API.

Implement buffer management by adding functions to clear and peek the buffer tail, using memset and port-specific handling for buffers with interrupt mode.

Implement the buffer read and buffer right functions by reading characters, advancing the current position, and returning the read value or an error, following the buffer peak logic.

Implement the buffer write function to transmit data on the USB port, updating head and location, checking for full buffer, and using transmit and receive interrupts to manage flow.

Write a function to check for data in the buffer and return its status. Cast the data to an appropriate size and apply the check to other buffers.

Implement a function to get the position of the first character of a string in the buffer, using data checks, a peek function, and modulo indexing to advance until match.

Learn to implement a function that finds a specific response in a receive data packet by comparing buffer peaks to the target string, with length checks and streaming reads.

Implement a get next strings function to copy the next 10 characters after a target string in a data buffer, and provide a send_string utility to transmit buffers.

Learn to implement a function that copies text up to a given substring into a destination buffer, using an index and a static position for precise ESP processing.

Develop a callback for the ESP UART to handle receive and transmit interrupts. Read the data register, store characters in the buffer, and update head and tail indices accordingly.

Develop and integrate a callback function for the debug uart in module two, adjust buffers and flags, expose circular buffer functions, and prepare a library for the next architecture layer.

Test the circular buffer implementation with the ESP UART port by sending reset commands, waiting for an OK response, and preparing to connect the ESP Wi-Fi module to the Internet.

Enable station mode on the ESP-based module, validate startup with 80 series commands, and prepare to connect to a Wi-Fi access point in the next lesson.

Write a function that takes the wifi name (ssid) and password, builds and sends a wifi connect command to an access point, and waits for an ok response.

Learn to obtain the device's local IP address on a bare-metal wifi system by sending a command to the ESP, awaiting the station IP response, and printing the result.

Develop an ESP-based function to enable multiple connections by sending the cipmux command, clearing the buffer, and validating the ok response for multi-connection operation.

Create a tcp server on the embedded wifi device, configure the port, send commands and wait for an ok, then connect to the local ip to access the hosted webpage.

Learn how to send data to the server by building a TCAP command with link id and data length, formatting the payload with sprintf, and handling responses.

Test and debug the circular buffer data structure by sending a string to the display, building the project, fixing typos, and validating interrupt-driven transmission via the port.

Host a simple webpage on the ESP web server, verify by loading it in a browser via the device IP, and adjust html/css to test button styles.

Configure and initialize the ESP8266 reset pin as a GPIO output, enabling clock access and setting the pin high to stabilize boot, then integrate and test the ESP initialization sequence.

Clean up the project by building a new Pfeifle-based library, deleting old library files, and enabling receive interrupts with printf debugging to prepare for implementing the library.

Develop a Pfeifle library using its data structure, build string processing helpers, and outline ESP command functions, including string search in data streams and data transfer to Pfeifle.

Implement the string search initialization for server response and data stream searches, set up buffers and volatile flags, and prepare the IPD substring buffer for initial search.

Develop the string search by adding a lowercase helper, implementing substring checks, and building a server response search with a 1024-byte buffer and a multi-state state machine.

Move data between the software fifo and the uart hardware by copying the text Pfeifle into the uart data register and echoing commands to the debugger.

Implement the ESP UART callback and its interrupt to process incoming data, echo it, print to the computer, and handle responses via a static callback from the interrupt request handler.

Create and expose a driver function to send a command to the ESP8266 by writing characters from the MCU, looping through the command until complete.

Develop a non-blocking ESP8266 reset and Wi-Fi flow, including reset commands, Wi-Fi mode, network listing and joining, and local IP retrieval, with a ten-try retry mechanism.

Develop a wifi mode setting function for a bare-metal ESP8266 device, using CW mode with station and AP options, including retries, response handling, and testing.

Develop a function to list all detectable wifi access points on an esp32 using cw lsp. Verify ok responses and ensure the results show nearby networks.

Develop a function to join a wifi access point by supplying the ssid and password, building a command buffer, and validating the OK response on an ESP32 bare-metal project.

Develop a static get_local_ip function to query the device for its local ip address, validate the response, and prepare the station ip for a forthcoming tcp connection.

Create a tcp connection by building a function that takes an ip address and port, opens the connection, constructs the tcp command, and handles retries and response.

Write a function to send a TCP packet to a remote server by building a command in a buffer, calculating length, and awaiting server response in single or multi-connection modes.

Implement a function to close the TCP connection, send the 80 80 command with carriage return and newline, wait for a response, delay briefly, and retry on failure.

Develop a function to obtain the ip address of a website by resolving a domain name through a dns get ip command, with retries and real time verification using google.com.

Test real-time weather retrieval via a tcp connection using the OpenWeather api, including an api key setup, crafting a get request, and parsing city weather data.