Hosting a Website on an 8-bit Microcontroller: A Technical Deep Dive

Hosting a website on an 8-bit microcontroller represents an interesting exercise in minimal computing. The project demonstrates how to create a functional web server using an AVR64DD32 microcontroller, a successor to the well-known Atmega328 found in Arduino boards. This chip offers modest specifications: a single 8-bit AVR core running at 24 MHz, 8 kB of RAM, 64 kB of flash memory, and 256 bytes of EEPROM, all while operating at voltages between 1.8-5.5V and costing approximately $1.

The primary challenge in this project is establishing an internet connection for the microcontroller. While Ethernet might seem like the obvious choice, it's not feasible for this hardware. Even the slowest Ethernet standard (10BASE-T) operates at 10 megabits per second, which is too fast for the AVR to handle directly. Ethernet uses Manchester encoding, where each bit is represented by two signal levels, effectively doubling the data rate at the physical layer. Additionally, all peripherals and I/O pins on the AVR are limited to a 12 MHz clock, further constraining its ability to manage Ethernet traffic.

The solution chosen is Serial Line Internet Protocol (SLIP), defined in RFC 1055. SLIP is a simple, lightweight protocol designed for running network traffic over serial connections. It works by wrapping packets in 0xC0 bytes, with special escape sequences for any 0xC0 or 0xDB bytes within the payload. This approach was commonly used in the early days of internet connectivity, where dial-up modems created serial links over phone lines.

Modern Linux systems still support SLIP, allowing easy integration with a USB-to-serial adapter. The process involves setting the serial parameters and attaching the interface using the slattach command, effectively converting a serial connection into a network interface. The hardware implementation on the microcontroller side is minimal, requiring only the basic circuit with some added LEDs for visual feedback and a protection diode against reverse power connections.

The software implementation presents several challenges. The microcontroller must handle IP packet headers, which are 40 bytes long and contain source and destination addresses along with other control information. Modern systems have simplified IP handling by disabling packet fragmentation, which reduces complexity significantly. The implementation simply swaps source and destination addresses in received packets to generate responses.

TCP implementation is considerably more complex, requiring the microcontroller to track connection states, handle retransmissions, and manage numerous edge cases. The author notes that developing a functional TCP stack took several days of work and still contains some bugs. HTTP is implemented in the simplest possible manner—returning a hardcoded response to all requests, which is sufficient for a single-page site.

The most significant practical challenge is obtaining a publicly routable IP address for the microcontroller. Public IPv4 addresses are expensive and difficult to obtain, particularly with residential internet connections. The author's solution involves using a VPS in Helsinki with a public IP address and establishing a WireGuard connection to create a virtual network link. This approach works even when one of the machines is behind CGNAT or other network address translation systems.

To prevent conflicts with the author's normal website, requests are proxied under the /mcu path to the microcontroller using a local address block. While this means visitors aren't directly connecting to the microcontroller's TCP/IP stack, it's a proven approach similar to that used by the Vape Server project.

This project highlights several important technical considerations:

1. Performance limitations: The microcontroller's processing power and memory constraints necessitate significant simplifications in network protocols.

2. Protocol trade-offs: While SLIP is simple to implement, it's less efficient than modern alternatives.

3. Network topology challenges: Obtaining public IP addresses remains a significant hurdle for small-scale projects.

4. Security implications: The setup is vulnerable to DDoS attacks given its limited resources and reliance on what's essentially dial-up speed connectivity.

The author points out that this entire problem would be unnecessary if IPv6 adoption were more widespread. Despite existing for three decades, IPv6 remains inaccessible to most users, forcing workarounds like the one implemented here.

For those interested in exploring similar projects, the author provides several resources:

• The microcontroller-hosted page
• Information about the Vape Server, a website hosted on a 32-bit MCU
• lcamtuf's article on the AVR Dx line microcontrollers

This project serves as both a technical demonstration and a commentary on the continued relevance of minimal computing in an era of increasingly complex systems. It showcases how creative problem-solving can overcome hardware limitations while highlighting the ongoing challenges in network infrastructure development.