A Tiny Cloud

Description

Plan is - give a bunch of ATtiny10s (with 1KB flash, 32 bytes RAM) their own network interfaces facing the WWW, and then see how much Web 2.0 I can get to flow through them.

Q: How is an embedded engineer who loves living on bare metal supposed to adapt to a society moving to the clouds?

A: Yank those clouds down to the metal.

Details

The Goal: serve some web content from a load-balanced cloud of networked ATtiny10 microcontrollers.

The Plan:

Make a device that can program and communicate with an array of ATtiny10s via USB
Use the TUN/TAP driver in Linux to create a network interface for each ATtiny10. Behind the scenes data is shuffled over USB and then over serial to and from the microcontrollers.
Set up NGINX to load-balance requests from the WWW across the microcontrollers.
Write a web server and then a blog engine in AVR assembly.
???

Project Logs

Collapse

First Board Assembled
Owen Trueblood • 10/10/2017 at 20:50 • 0 comments

Finally! Boards came in a while ago from OSH Park (thanks to the nice folks there for some extra boards to replace just one broken one from the original batch) but I just got a little time to assemble the first.
The ATmega32U4 happily responds to my programmer so it seems like there's nothing in the way of getting some code on there.
The first order of business after checking basic functionality (LEDs and USB) will be to try flashing one of the ATtiny10s with a program that blinks its LED. With that proof of concept out of the way the more fun work of exposing all of the processors to the host can start.
Tiny Cloud Substrate - PCB
Owen Trueblood • 09/03/2017 at 20:53 • 1 comment

PCBs are on the way from OSH Park. First version is not designed for aesthetic appeal but just to let the software get written. It's a 4 layer board that I allowed the auto-router to savage after placing and routing the important stuff (really just the USB traces and decoupling caps).
While waiting for the boards I'll have a chance to get started on the software.
Tiny Cloud Substrate - Schematic
Owen Trueblood • 09/03/2017 at 05:17 • 2 comments
To start this off I've whipped up a simple schematic for the basic hardware needed to get this idea up and running.
To make our tiny cloud we need two basic things from the hardware:
1. A way to tell the infrastructure how to do a thing
2. A way to give the infrastructure things to do it with
Said another way, we need to be able to:
1. Flash programs to the ATtiny microcontrollers
2. Communicate with those programs once they are running
To gain these abilities I'm planning to use an ATmega32U4, which is a microcontroller that has a USB interface and a good number of pins. But not quite a good enough number of pins, so I've thrown in two shift registers as well.
There are 16 ATtiny10 microcontrollers to a board. During programming the shift registers are used to hold a particular one of them in reset while the same two data and clock pins that are connected to all of the ATtinys are wiggled just so - as dictated by the Tiny Programming Interface specification - in order to flash that particular chip. All those not in reset will ignore the wiggles, so we can walk through the entire array by holding each one in reset in turn. This is kind of slow, but we're not planning on reflashing them all the time so we'll live with it.
Once the ATtinys are flashed we'll start shuffling serial data to and from them via ports B and D on the 32U4 (one half of the array per port so it takes 2 assembly instructions to grab the state). The 32U4 will accept packets over the USB bus that contain the index of an ATtiny and some data to send to it, and in reverse it will export packets distilled from the tortured screams of the ATtinys.
PCB design coming next!