Distributed, Open Source Chat with Vector and Matrix

When it comes to chat, you have many choices. Facebook Messenger, Google Talk, Whatsapp, Kik, and Slack are all viable options. However, all of these choices are proprietary, and require you to use servers that you can’t run yourself. They’re highly centralized, closed source tools.

In the open source world, IRC has been the go to solution for chat for many years, and for good reason. Anyone can run a server, there’s many clients, and it’s built on open standards. But IRC comes from a pre-mobile world, and relies on clients to maintain persistent connections to the server. It’s not the best experience on a phone.

Matrix.org and Vector.im aim to be a modern solution to chat. Matrix is a standard for passing messages around, and Vector is a chat solution built on top, with support for iOS, Android, and your browser.

What makes this solution different is the concept of Homeservers. A Homeserver manages messages for users, recording them when they are received and providing them to users when they connect. Homeservers also “federate” to communicate amongst each other. This means anyone can run a Homeserver and connect it to the greater network of Matrix, providing a distributed approach to building a chat network.

Under the hood, Matrix is just HTTP. You send messages into the network with POST requests, and receive new messages by polling with GET requests. This means no persistent connections are required, which is perfect for mobile and low power devices.

On the topic of devices, Matrix is designed for general purpose messaging, not just chat. It should be pretty simple to connect hardware up to Matrix, which would provide a simple way to get data in and out of connected devices. Since it’s all HTTP, a device based on the ESP8266 could hop into your chat room with relative ease.

Matrix and Vector are very much in beta, but are definitely usable and worth a try. To get started, you can create an account on Vector.im and start chatting. We’re awaiting some of the features in the works, including end-to-end encryption, and hope to see some future hacks talking to the Matrix infrastructure.

Ikea Projection Lamp Makeover Adds LED Matrix and Raspberry Pi Zero

If you’re like us, it’s hard to walk through an Ikea without mentally hacking everything there into something else. The salad bowl? Parabolic antenna. Drawer slides? Linear motion rails. Storage containers? Etching tank. We admit that we still haven’t figured out what to do with that 1,000-pack of tea lights.

[Alain Mauer] pulled off an Ikea hack that we’ve always dreamed about. In particular, he took the Sprida projector lamp and wedged an 8×8 LED matrix and Raspberry Pi Zero into it.

The lamp in question is essentially a slide projector for kids. Before [Alain] got to it, it had an LED in the back, a mount for a slide in the middle, and a focusing lens on the front. His mod is simplicity itself: remove the LED and transparency, and place the LED matrix in the focal plane where the slide used to be. Reverse images on the LED in software to compensate for the lens, and you’re done.

The video says “Raspberry Pi Zero with WiFi” and the project title promises “IoT”, but we don’t see the WiFi in the build. We’re guessing that [Alain] will get around to it — it’s easily doable. (Doh! There’s a tiny USB WiFi dongle providing the obligatory wireless connection.) Anyway, the point is the projection, and we love it, and we’d be lying if we said it didn’t make us think about RGB matrices.

Continue reading “Ikea Projection Lamp Makeover Adds LED Matrix and Raspberry Pi Zero”

FPGA Powers Blazingly Fast LED Matrix Audio Visualizer

[Sam Miller], [Sahil Gupta], and [Mashrur Mohiuddin] worked together on a very fast LED matrix display for their final project in ECE 5760 at Cornell University.

Real time!
Real time!

They started, as any good engineering students, by finding a way to make their lives easier. [Sam] had built a 32×32 LED matrix for another class. So, they made three more and ended up with a larger and more impressive 64×64 LED display.

They claim their motivation was the love of music, but we have a suspicion that the true reason was the love all EEs share for unnaturally bright LEDs; just look at any appliance at night and try not be blinded.

The brains of the display is an Altera DE2-115 FPGA board. The code is all pure Verilog. The FFT and LED control are implemented in hardware on the FPGA; none of that Altera core stuff. To generate images and patterns they wrote a series of python scripts. But for us it’s the particle test shown in the video below that really turns our head. This system is capable of tracking and reacting to a lot of different elements on the fly why scanning the display at about 310 FPS. They have tested display scanning at twice that speed but some screen-wrap artifacts need to be worked out before that’s ready for prime time.

The team has promised to upload all the code to GitHub, but it will likely be a while before the success hangover blows over and they can approach the project again. You can view a video interview and samples of the visualizations in the videos after the break.

Thanks to their Professor, [Bruce Land], for submitting the tip! His students are always doing cool things. You can even watch some of his excellent courses online if you like: Here’s one on the AVR micro-controller.

Continue reading “FPGA Powers Blazingly Fast LED Matrix Audio Visualizer”

Paraffin Oil and Water Dot Matrix Display

In preparation for Makerfaire, [hwhardsoft] needed to throw together some demos. So they dug deep and produced this unique display.

The display uses two synchronized peristaltic pumps to push water and red paraffin through a tube that switches back over itself in a predictable fashion. As visible in the video after the break, the pumps go at it for a few minutes producing a seemingly random pattern. The pattern coalesces at the end into a short string of text. The text is unfortunately fairly hard to read, even on a contrasting background. Perhaps an application of UV dye could help?

Once the message has been displayed, the water and paraffin drop back into the holding tank as the next message is queued up. The oil and water separate just like expected and a pump at the level of each fluid feeds it back into the system.

We were deeply puzzled at what appeared to be an Arduino mounted on a DIN rail for use in industrial settings, but then discovered that this product is what [hwhardsoft] built the demo to sell. We can see some pretty cool variations on this technique for art displays.

Continue reading “Paraffin Oil and Water Dot Matrix Display”

Building the Infinite Matrix of Tamagotchis

Tamagotchi is a digital pet, living in and cared for through a key-chain size piece of hardware. The mid-90’s toy lives in pop culture, but now it lives well beyond. A limitless network of Tamagachi has been created using some amazing tricks to feed, socialize, and monitor the beast now known as the Tamagachi Singularity.

Last weekend at the Hackaday SuperConference we were graced with a talk by [Jeroen Domburg], a.k.a. [Sprite_tm]. [Sprite] is a favorite of ours and over the years his hacker cred includes everything from reverse engineering hard drive controller chips to putting video games in his keyboard.

[Sprite] is also something of an Architect, and like all Architects he only wants what is best for the system he created. In this case, it’s a Matrix of Tamagotchis. [Sprite] created a hive of Tamagotchis that are able to interact with each other in their own separate world. The best part about this Matrix? There’s no allusions to violating the laws of thermodynamics in the exposition.


Like all good hacks, a Tamagotchi Matrix wasn’t created in a vacuum. A few years ago at 29C3, [Natalie Silvanovich] dumped the ROM in the current generation of Tamagotchis. This is an incredible feat of reverse engineering, that allows anyone to use the full capabilities of the 6502-based microcontroller that controls these digital pets

After [Sprite] figured out how to read and run the code in the Tamagotchi, the next obvious step towards a world of egg-shaped pods containing an entire population of Tamagotchis is virtual Tamagotchis. [Sprite] used a hard-coded state machine that takes care of pooping, flushing, training, feeding, and turning the lights off at bedtime.

With a single Tamagotchi described as a state machine, it’s a simple matter to build another. This is where things get interesting and Matrix-ey. Tamagotchis don’t live alone; they have an IR LED and receiver that allows them to interact with each other, eat, play, marry, and have kids. Emulating a single Tamagotchi is one thing, but controlling multiples is another thing entirely; some sort of protocol was needed to breed Tamagotchis and keep them happy and well-fed.

Continue reading “Building the Infinite Matrix of Tamagotchis”

LED Matrix Failure and Vindication

If necessity is the mother of invention, what’s failure the mother of? Improvement? Anyway, [prpplague]’s second version of his roll-up 70×30 RGB LED display looks a lot better and more reliable than the first, and that’s precisely due to “failing”.

Sometimes you design the hardware around the software, and sometimes vice-versa. It’s all about the balance of pain. [prpplague] initially wired the strips together in a consistently left-to-right raster arrangement to make the coding easier, but this means long wires on the backside of the fabric returning from the right side back to the start again at the left. These long wires snagged on stuff, and pulled the solder connections apart.

600px-Dotstar-adapter-solder3The fix? Alternate rows of left-to-right with right-to-left to minimize wiring and make nice, robust connectors for the ends, and a much more elegant implementation at the expense of more complicated software to drive the device. (Alternating rows have to be flipped horizontally, so this means custom driver routines.)

The second gremlin was that the interfacing board that [prpplague] was using didn’t have enough current sourcing capability on the SPI lines, and he discovered that he couldn’t communicate reliably with the strings if the first pixel was more than 24″ of wire away from the board. Once the signal got to the first pixel, though, everything was fine. [prpplague] figured out that the RGB LEDs themselves had more drive capability than the SPI source.

The solution? Add a single pixel at the front of the chain to buffer the SPI lines and serve as a bonus status indicator. Cute.

We’d hardly call these “fails”, but rather “learning experiences”. Anyway, here’s two design “mistakes” that we won’t make when making a roll-up flexible pixel display. Thanks [prpplague].

LED Matrix Plus Geiger Counter

A lot of projects get made because someone just has the parts lying around. In this case, [Ed Nisley] got given a nice 8×8 RGB LED matrix, and needed something to display. [Ed] details the transformation of stuff-lying-on-the-desk into a unique matrix display for a Geiger counter (which he also presumably had sitting around somewhere). The result is a lightshow that’s as random as radioactive decay, and that’s pretty darn random.

img_5583-random-led-dots-circuit-layout-rb-smd-resistorsThe first post covers the hardware layout. It’s build on protoboard, but ends up looking a lot nicer than our projects because [Ed] spent some time hiding the shift-register ICs and row-driver transistors underneath the matrix itself, which was nicely socketed above. A sweet touch is the use of SMT resistors soldered upright underneath the board to save space. Cute.

The second post covers the circuit design, and is worth a look if you’re new to driving many LEDs from a minimum number of microcontroller pins. There are eight rows, and three colors each for eight LEDs per row. Without using shift registers, this would require 8*8*8*8 = way too many pins to control. If you want a worked example of how to do this with just four microcontroller pins, have a look. (Spoiler: cascaded shift registers driven by the AVR’s hardware SPI peripheral.)

The third post starts to flesh out the software. [Ed] settled on seven colors (and off) for the display, so the matrix’s total state can be crammed into just 32 bytes, which fits nicely in even a tiny microcontroller, much less the gargantuan ATmega328. Wrapping this all up in an array of structs and providing a couple of helper functions makes quick work of the software side. The addition of a sync pulse to trigger an oscilloscope at the end of a row is a nice touch.

aware-rm-60-geiger-pulseNext up is the Geiger counter interface software post. When a radioactive decay event is detected, the code reads out the time in milliseconds and uses that as the source of randomness. To whiten the noise, the times are run through a simple hash function: the Jenkins hash (link). This hash function was new to us and seems pretty useful for quick-and-dirty microcontroller applications.

The last post details pre-loading the matrix on startup and running a test sequence that blinks each LED to make sure they’re all working. Using a single random value to seed a software pseudo-random number generator ensures that it will (almost) never start off with the same display twice.

Phswew! That’s a lot of well-documented writeup of a well-polished project! Hope it inspires you to dig out something cool from your junk drawer and build.