Beatboxer on an Embedded System

• C
• Multithreading
• UDP networking
• Bit-twiddling
• ALSA audio
• Web sockets
• NodeJS, Jquery

Beatboxer lets a user playback some pre-made beats, or create their own! Beatboxer runs on physical hardware and connects your local network allowing for control by hand or by web. Here’s what the whole system looks like:

This project touched on a huge range of abstractions - from reading individual bytes in registers to showing content on the frontend.

Getting the MMA8452Q accelerometer working was a little challenging. The first 8-bit register you read in C is always 0xFF. To read something you care about (like x-y-z coordinates), you need to read multiple registers in one go with an 8-bit offset, to get an array of bytes. Each coordinate is stored as a 16-bit value across two registers - the LSB and MSB bits. By default, reading multiple bytes will skip the LSB, so you also need to write to other registers so this is turned off!

The audio was done using the ALSA C API. Pushing the joystick will queue new PCM samples for playback. A thread will load the samples into memory, and another thread will play them back. A third (heartbeat) thread will send/receive the current beat over UDP to the node web server so it can be displayed and controlled from the frontend!

S-Talk (My own Netcat)

• C
• Multithreading
• UDP networking
• Dynamic memory allocation
• Critical sections, mutexes and semaphores

S-talk lets two people instant message each other over the local area network. The beauty of this is the same single binary can be run by two different people on their own computers. I had a bit of multithreading going on:

• Thread for grabbing keyboard input
• Thread for displaying text on the screen
1. This text comes from either typing a message, or receiving one from the other person
• Thread for sending UDP packets
• Thread for receiving UDP packets

There were some edge cases:

• If you decide to send the whole Bee Movie script as a string, it’s way too long to fit in a single UDP packet, so
  1. chop it into several partitions
  2. add those partitions into a free list
  3. send each paritition as an individual packet until the free list is empty
• When two users try to send at once, or receive at once, we need a mutex and signaler/waiter to handle it. This is a classic critical section problem.

I learned about dynamic memory allocation with a free list which proved to be extremely handy. Unlike malloc, I had tight control over where in memory my bytes were stored. I also implemented a UDP networking solution in C that ran on two threads. The whole thing worked with one socket - all you had to do was run the compiled binary on two different computers.