IP-Over-Semaphore

Create a network using semaphore flags

Comment

Inspiration

Yet another silly little Internet protocol. Based on RFC 4824 https://datatracker.ietf.org/doc/html/rfc4824

What it does

Transfers data packets between computers using physical flags and cameras at a smoldering 0.8 Bytes / Second.

How we built it

Hardware

The semaphore flags are attached to stepper motors in order to control their direction. The motors are controlled by an Arduino, which receives position instructions via serial.

Vision

OpenCV is used to detect the semaphore flags. No AI/machine learning is used here, just deterministic computer vision.

Networking

We create a TUN interface to give the computer a real network to send packets over. We initially thought a kernel driver would be necessary, but our kernel driver would have effectively been a jankier implementation of TUN. While the vision part of the software is written in Python, the networking is done in Rust because it was much easier to interact with TUN in Rust.

Challenges we ran into

  • Rust kernel drivers - initially, we were planning on writing a kernel driver in Rust, but we weren't able to do this because there's practically no documentation on actually making Rust kernel drivers. Even on a distro that already ships with a kernel with Rust support enabled (Asahi Linux), we weren't able to get the singular out-of-tree template compiling, and found no other examples anywhere.
  • Stepper motors - many hours were spent trying to get the stepper motors actually rotating the right amount.
  • Terrible webcams - During the day/night, lighting changes kept breaking semaphore flags due to the webcams constantly over/underexposing the video.
  • Packet loss - We found that interruptions such as people with red t-shirts standing near the semaphores could introduce packet loss.

Accomplishments that we're proud of

It worked! We were able to transfer a data packet in 48 minutes.

What we learned

What's next for IP-Over-Semaphore

Share this project:

Updates