Panopticon: A First Look

Panopticon is a purpose-built life status display that currently hangs on my bedroom wall. It has been my primary project for a little over the past year. (The Github commits start around October 2014, but I’d been laying out the spec for a while before that.) The seed of the idea was planted in my mind when I saw this reddit post and realized that I could make cheap, thin, affordable, high-density displays with the many old laptops I had. I also had a Raspberry Pi, which I was unable to find a use for since I bought the thing at release day.

Anand Sharma’s sources of inspiration. Pic belongs to him, of course

Around this time, Anand Sharma made his quantified-self tracker, April Zero, publicly visible. When designing it, he took deliberate inspiration from the user interfaces of sci-fi movies, namely Iron Man.

I was awestruck, not just by the effective aggregation of data, but also by how nicely it was presented.

I could not get the idea out of my mind. After two weeks, I decided I absolutely had to make my own. I had a fairly good idea of what I wanted — a display that would hang on my wall and show relevant information (such as my upcoming schoolwork, calendar events, the weather, and so on.)

I began gathering inspiration. Like April Zero, I wanted the system to look as sleek and futuristic as possible. Building something to resemble the UIs of sci-fi movies has been a fantasy of mine for a long time, and this was the perfect excuse to design exactly what I wanted.

GMUNK’s work on Oblivion (left) and TRON Legacy (right). He even used the actual proper Linux commands!

I took inspiration from several sources — April Zero itself, Her, Pacific Rim, Person of Interest, and the new Star Trek reboot — but no designer was as big a source of inspiration as GMUNK. His work on TRON Legacy and Oblivion, among others, were some of the first film GUI designs that made me realize that I loved exactly how awesome these creations were, even if they were only on screen for a few dozen frames.


Design and Implementation

I wanted the internals to be modular, so that I could easily add or remove status displays without tearing the whole system apart. To that end, each panel is its own independent system that loads its own structure, styles, and scripts.

After an hour or two, I had a working base system that would load and display modules. At this point, ideas for data sources began coming in:

  • Schooltraq — upcoming homework, quizzes, and tests. I’ve been using Schooltraq as my assignment planner since my friend Brandon Wang built it sometime in 2012, because it works in the same way my mind does in handling upcoming assignments, and there’s nothing else quite like it.
  • Calendar — upcoming events and classes. In addition to Schooltraq, as life got busier in college, I began using Google Calendar as well.
  • Status — the status of the machines on my LAN. This is easily achieved by pinging each machine with a short TTL and seeing if there’s a response.
  • Who’s home — I can do an ARP scan and see if my roommates’ phones are on the network. If they are, they’re home. This is useful when I want to avoid disturbing/waking up the people around me with music or conversation.
  • Social — a simple notification count for Facebook, Twitter, email, and so on.
  • Weather — I absolutely love the way Forecast.io displays weather, and this seemed like the perfect place to put it.
  • Feed— some excerpts from my daily readings, such as reddit, various RSS feeds, and so on. (I ended up pushing this to the backburner; it has now evolved into its own separate project.)
A very early, working-but-not-pretty prototype of Panopticon. The panels were originally grouped into categories, which would take up the entire screen.

When thinking about interface, I shied away from a touchscreen based one, even though that would’ve been easiest to implement. If you’re the only user, the system only needs to make sense to you. The system doesn’t need to be “user-friendly”. The Linux installations on my laptop and development machine are excellent examples of this — custom keyboard shortcuts and command-line settings make it so that I’m very quick and flexible with it. As a consequence, though, people cannot walk up to one of my machines and use it easily. Since Panopticon is a one-off build, and is tailored specifically to me and displaying my personal data, I saw no reason to build incorporate user-friendliness.

To that end, and because the display was just so large, I built most of the system with no intention of any control at all. The panels would simply automatically refresh every so often, updating data as needed. When I neared completion, I added some very simple binding that would allow each number key to refresh an individual panel, but that’s really all there is. As it is now, I don’t see the need to add any sort of control scheme, but in the future, if there are more panels than can comfortably fit on the screen, I’ll come up with something. (After all, this is titled “A First Look”.)

An early version of the weather panel. The animations are the same as the current version. Also note the millisecond clock — even the Pi 2 proved too slow to run that, so I took it out.

I ended up building this in node.js, but only because that’s what I was most familiar with when I began working on it. For reasons that are not worth getting into, if I were to start working on Panopticon today, I don’t think I would have used node.js.


Hardware

I eventually got my hands on an old Dell Inspiron. It was a brick of a machine, used only 2GB of DDR2 RAM, and had a graphics card that was probably impressive when the machine was new but was worthless now. However, that graphics card was driving a wonderful 1980 x 1200 display — which would be perfect for Panopticon. (Since I hate wasting anything, the rest of that laptop is now being used as a jump server for SSH.)

After some brief disassembly, I had the display separated from the laptop. A quick eBay search turned up many sellers for display controller boards, and soon I had one on the way.

I figured the actual software would run on my original Raspberry Pi model B, but that proved to be far too slow. The simple solution to this was to order the much more powerful Raspberry Pi 2, and that’s what I ended up doing.


Putting it all together

That’s more or less it! I originally wanted to design some sort of wood or acrylic enclosure for it, but mounting the exposed circuit boards to the wall ended up looking cooler.

And that’s what it looks like on my wall. The wires and exposed PCBs are pretty much where I plan on keeping them for the time being. Not all the panels are built yet, but after a year in development, I was eager to have a tangible product to show for it.

That’s it for now, since this is just a first look. I’ll be winding down my efforts and moving on to other projects since it’s mostly done, but I’d like to build out the rest of the panels and possibly add some sort of control scheme. There’ll be more to come later, hopefully!