If you’re a regular GitHub user you’ll be familiar with the website’s graphical calendar display of activity as a grid. For some of you it will show a hive of activity, while for others it will be a bit spotty. If you’re proud of your graph though, you’ll want to show it off to the world, and that’s where [HarryHighPants]’ Git Contributions E-Ink Display comes in. It’s a small desktop appliance with a persistent display, that shows the current version of your GitHub graph.
At its heart is an all-in-one board with the display and an ESP32 on the back, with a small Li-Po cell. It’s all put in a smart 3D printed case. The software is the real trick, with a handy web interface from which you can configure your GitHub details.
It’s a simple enough project, but it joins a growing collection which use an ESP32 as a static information display. The chip is capable of more though, as shown by this much more configurable device.
This project began simply enough but got very complicated in short order. Initially the goal was to get the GameCube keyboard controller integrated with the game Animal Crossing. The GameCube keyboard controller is a genuine part manufactured and sold by Nintendo but the game Animal Crossing isn’t compatible with this controller. Rather, Animal Crossing has an on-screen keyboard which players can use with a standard controller. [Hunter] found this frustrating to use so he created an adapter which would intercept the keyboard controller protocol and replace it with equivalent “keypresses” from an emulated standard controller.
Here’s a great hack sent in to us from [Simon]. He uses an e-paper photo frame as a weather map!
By now you are probably aware of e-paper technology, which is very low power tech for displaying images. E-paper only uses energy when it changes its display, it doesn’t draw power to maintain a picture it has already rendered. The particular e-paper used in this example is fairly large (as e-paper goes) and supports color (not just black and white) which is why it’s expensive. For about US$100 you can get a 5.7″ 7-color EPD display with 600 x 448 pixels.
USB audio is great, but what if you needed to use it and had no budget? Well, depending on the contents of your parts bin, you might be able to use [Veyniac]’s Pico-Audio-Interface as a free (and libre! It’s GPL3.0) sound capture device.
In the project’s Reddit thread, [Veyniac] describes needing audio input for his homemade synth, but having no budget. Necessity being the mother of invention, rather than beg borrow or steal a device with a working sound card, he hacked together this lovely device. It shows up as a USB Audio Class 2.0 device so should work with just about anything, and offers 12-bit resolution and 4x oversampling to try and deal with USB noise with its 2-channel, 44.1 kHz sample rate.
Aside from the Pico, all you need is an LM324 op-amp IC and a handful of resistors and capacitors — [Veyniac] estimates about $10 to purchase the whole BOM. He claims that the captured audio sounds okay in his use, but can’t guarantee it will be for anyone else, noise being the fickle beast that it is. We figure that sounding “Okay” has got to be pretty good, given that you usually get what you pay for — and again, [Veyniac] did build this in a cave with a box of scraps. Well, except for the cave part. Probably.
While the goal here was not to rival a commercial USB sound card, we have seen projects to do that. We’re quite grateful to [Omadeira] for the tip, because this really is a hack. If you, too, want a share of our undying gratitude (which is still worth its weight in gold, despite fluctuations in the spot price of precious metals), send in a tip of your own.
[Ben] uses the timer in the W65C22 Versatile Interface Adapter to generate the square waves which generate a tone. He then adds support for a new BEEP command into his MS BASIC interpreter. We covered [Ben Eater]’s MS BASIC here at Hackaday back in April, so definitely check that out if you missed it.
We’ve seen a lot of projects based on the Pi Pico, but a nuclear reactor simulation is a new one. This project was created by [Andrew Shim], [Tyler Wisniewski] and another group member for Cornell’s ECE 4760 class on embedded design (which should silence naysayers who think the Pi Pico can’t be a “serious” microcontroller), and simulates the infamous soviet RMBK reactor of Chernobyl fame.
The simulation uses a 4-bit color VGA model. The fission model includes uranium fuel, water, graphite moderator, control rods and neutrons. To simplify the math, all decayed materials are treated identically as non-fissile, so no xenon poisoning is going to show up, for example. You can, however, take manual control to both scram the reactor and set it up to melt down with the hardware controller.
The RP2040’s dual-core nature comes in handy here: one core runs the main simulation loop, and the main graphic on the top of the VGA output; the other core generates the plots on the bottom half of the screen, and the Geiger-counter sound effect, and polls the buttons and encoders for user input. This is an interesting spread compared to the more usual GPU/CPU split we see on projects that use the RP2040 with VGA output.
An interesting wrinkle that has been declared a feature, not a bug, by the students behind this project, is that the framebuffer cannot keep up with all the neutrons in a meltdown simulation. Apparently the flickering and stuttering of frame-rate issues is “befitting of the meltdown scenario”. The idea that ones microcontroller melts down along with the simulated reactor is rather fitting, we agree. Check it out in a full walkthrough in the video below, or enjoy the student’s full writeup at the link above.
This project comes to us via Cornell University’s ECE 4760 course, which we’ve mentioned before. Thanks to [Hunter Adams] for the tipoff. You may see more student projects in the coming weeks.
The original ESP32 may be a little long in the tooth by now, but it remains a potent tool for connected devices. We were drawn to [Max Pflaum]’s ESP32 Dashboard as a great example, it’s an ESP32 hooked up to an e-paper display. The hardware is simple enough, but the software is what makes it interesting.
This is deigned as a configurable notification tool, so to make it bend to the user’s will a series of widgets can be loaded onto it. The device runs MicroPython, making it easy enough to write more than the ones already on place. The screen is divided into four zones, allowing for a range of widgets to be used at once. All the details can be found in a GitHub repository.
We like it for its configurability and ease of programming, and because it delivers well on the promise of a useful device. An ESP32 and e-ink combination with MicroPython apps is something we’ve seen before in the world of badges.
