Why buy a num pad or a macropad when you can build something new and beautiful, open source that bad boy, and be a hero to the community? We think that should be all the justification you ever need to build instead of buy, even if you think your thing is Just Another Keypad [JAnK] as [Clewsy] claims.
At first glance, JAnK appears to be a standard number pad with four macro keys across the top. But when you roll your own ‘board, all the keys are programmable. [Clewsy] took advantage of this by adding a second layer that’s accessible with (what else?) the Num Lock key. This switches JAnK over to 21-key macro pad mode.
[Clewsy] rolled their own PCB for this and used the venerable ATMega32u4 because of its HID and USB host capabilities. Every key is backlit, and these LEDs are driven by an MP3202 LED driver and PWM from the AVR. [Clewsy] was able to build a prototype by sawing the num pad off of a stainless steel key switch plate from another build, but eventually ordered JAnK its own custom, laser-cut, stainless steel plate. The lovely enclosure is made of spotted gum wood and an acrylic base.
Putting it all together proved to be a bit problematic. [Clewsy] soldered up the minimum viable components for testing and discovered that the ATMega’s VCC and GND pins were both shorted. This killed the AVR programmer, but not the chip itself, and [Clewsy] happened to have a spare. To add insult to injury, the Num Lock light didn’t work, but [Clewsy] was able to simply reverse the LED instead of ordering a new pile of boards. Check out the detailed write-up with code and tons of pictures over on [Clewsy]’s personal site.
One of the awesome things about this build is that [Clewsy] was able to re-use the code from macr0, which began life as a proof of concept for scanning key matrices, and retired to become a music and media controller.
For seven months, [Bernardo Kastrup] at [TheByteAttic] has been realizing his childhood dream of building his own computer. It was this dream that steered him into the field of computer design at the age of 17. After thirty years in the industry, he finally has some time to design the computer he dreamt about as a kid. His requirements are ambitious: fully open design, gate-level details, thru-hole or PLCC for easy hacking, well-established processors with existing tool chains, low-cost development tools for CPLDs, no FPGA, standard ITX case compatible, and so on. He quite reasonably decides to use more modern electronics for video (VGA), keyboard (PS/2), and program storage (flash drive). Along the way, he chooses to put three processors on the board instead of one:
- Zilog Z84C0010 (Z80)
- WDC W65C0256 (6502)
- AVR ATMEGA328 (RISC Controller)
When coming up with the concept and requirements, [Bernardo] had a fictitious alternate history in mind — one where there were follow-ups to the ZX80, PET/CBM, or TRS-80 from the late 1970s that were extensions to the original systems. But he also wanted a clean design, without cost-cutting gimmicks, in order to make it easier for learners to focus on computing itself — a didactic architecture, as he describes it. Turn the crank for seven long months, and we have the Cerberus 2080. [Bernardo] has put the design on GitHub, and made a video series out of the whole process, of which the introduction video is below the break. There’s even an online emulator developed by retro hacker [Andy Toone].
We wrote about the 6502-based ERIC-1 project back in 2014 which shared the bus with an ATMEGA simulating ROM. The Minty Z80 project from 2019 also uses a similar technique. Thanks to [Frédéric] for sending us the tip.
Continue reading “Cerberus 2080 — Three-Headed Retro Computing Project”
As amazing as CircuitPython is, it hasn’t yet been ported to any 8-bit microcontrollers. [Chris Heo] was unsatisfied with his inability to use Python on his 8-bit ATmega4808 AVR, so he worked out a way to zombify it and bend it to his will using Python on his PC.
The trick to making this all work is the UPDI interface: a single-wire UART interface for programming and debugging Microchip’s newer 8-bit AVR microcontrollers. UPDI reaches deep into the microcontroller’s core, allowing you to stop and start execution of microcontroller code and access all of the onboard data and I/O. [Chris] realized this could be used to stop execution of any code running on the AVR and directly control the output pins using the pyupdi library. Since UPDI lets him modify the AVR’s I/O registers, he was also able to blink an LED and use the microcontrollers UART to send a message back to his PC without compiling a single line of code.
This may seem like an entirely unnecessary hack, but for devices too small or basic to have a JTAG interface for debugging this could be the best way to test and debug peripherals in an assembled circuit. We hope this catches on and would love to see how much of the chip can be controlled in this way. Maybe this will make it easy to experiment with the programmable logic that’s on some of the newer AVRs.
Frequenters of arcades back in the golden age of video games will likely recall the mix of sounds coming from a properly full arcade, the kind where you stacked your quarters on a machine to stake your claim on being next in line to play. They were raucous places, filled with the simple but compelling sounds that accompanied the phosphor and silicon magic unfolding all around.
The days of such simple soundtracks may be gone, but they’re certainly not forgotten, with this chiptunes generator built into an RCA plug being both an homage to the genre and a wonderful example of optimization and miniaturization. It’s the work of [girst] and it came to life as an attempt to implement [Rob Miles]’ Bitshift Variations in C Minor algorithmically generated chiptunes composition in hardware. For the first attempt, [girst] chose an ATtiny4 as the microcontroller, put it and the SMD components needed for a low-pass filter on a flex PCB, and wrapped the whole thing around a button cell battery. Stuffed into the shell of an RCA plug, the generator detects when it has been inserted into an audio input jack and starts the 16-minute piece. [girst] built a second version, too, using the Padauk PSM150c “Three-Cent Microcontroller” chip.
This is quite an achievement in chiptunes minimization. We’ve seen chiptunes in 32 bytes, Altoids tin chiptunes, and an EP on a postage-stamp-sized PCB, but this one might beat them all on size alone.
Continue reading “RCA Plug Plays Sixteen-Minute Chiptune Piece, All By Itself”
There are two kinds of programmers: those who don’t use Lisp, and those who need new parenthesis keycaps every six months. Lisp is one of those languages you either really love or really hate. If you love it, you may have checked out ulisp, which runs on Arduino boards of the AVR and ARM variety, as well as ESP chips, RISC-V, and others. A recent update allows the language to insert assembler into AVR programs.
We probably don’t need to convince anyone reading Hackaday why adding assembler is a good thing. It seems to integrate well with the environment, too, so you can write assembler macros in Lisp, which opens up many possibilities.
Continue reading “AVR Bare Metal With Lisp”
Join us on Wednesday, April 21 at noon Pacific for the AVR Reverse Engineering Hack Chat with Uri Shaked!
We’ve all become familiar with the Arduino ecosystem by now, to the point where it’s almost trivially easy to whip up a quick project that implements almost every aspect of its functionality strictly in code. It’s incredibly useful, but we tend to lose sight of the fact that our Arduino sketches represent a virtual world where the IDE and a vast selection of libraries abstract away a lot of the complexity of what’s going on inside the AVR microcontroller.
While it’s certainly handy to have an environment that lets you stand up a system in a matter of minutes, it’s hardly the end of the story. There’s a lot to be gained by tapping into the power of assembly programming on the AVR, and learning how to read the datasheet and really run the thing. That was the focus of Uri Shaked’s recent well-received HackadayU course on AVR internals, and it’ll form the basis of this Hack Chat. Then again, since Uri is also leading a Raspberry Pi Pico and RP2040 course on HackadayU in a couple of weeks, we may end up talking about that too. Or we may end up chatting about something else entirely! It’s really hard to where this Hack Chat will go, given Uri’s breadth of interests and expertise, but we’re pretty sure of one thing: it won’t be boring. Make sure you log in and join the chat — where it goes is largely up to you.
Our Hack Chats are live community events in the Hackaday.io Hack Chat group messaging. This week we’ll be sitting down on Wednesday, April 21 at 12:00 PM Pacific time. If time zones have you tied up, we have a handy time zone converter.
Click that speech bubble to the right, and you’ll be taken directly to the Hack Chat group on Hackaday.io. You don’t have to wait until Wednesday; join whenever you want and you can see what the community is talking about.
Continue reading “AVR Reverse Engineering Hack Chat”
We’ve all got projects kicking around that we haven’t had time to document for our own purposes, let alone expose to the blinding light of the Internet. There are only so many hours in a day, and let’s face it, building the thing is a lot more fun than taking pictures of it. It took [Matthew Millman] the better part of a decade to combine everything he’s learned over the years to finally document the definitive version of his open source intelligent fan controller, but looking at the final result, we’re glad he did.
At the heart of this board is an ATmega328P, but don’t call it an Arduino. [Matthew] makes it very clear that if you want to hack around with the code for this project, you’re going to need to not only have a programmer for said chip, but know your way around AVR-GCC. He’s provided pre-built binaries for those content to run with the default settings, but you’ve still got to get it flashed onto the chip yourself. The project is designed to use the common DS18B20 temperature sensor, and as an added bonus, the firmware can even check if yours is a bootleg (spoilers: there’s an excellent chance it is).
Arguably the most interesting feature of this fan controller is its command line interface. Just plug into the serial port on the board, open your terminal emulator, and you’ll have access to a concise set of functions for querying the sensors as well as setting temperature thresholds and RPM ranges for the fans. There’s even a built-in “help” function should you forget a command or the appropriate syntax.
Originally [Matthew] developed this project as a way to control multiple fans inside of a PC case, but naturally, things have changed quite a bit since those early days. While today there’s no shortage of fancy controllers that can handle throttling an array of fans based on the internal temperature of your rig, there’s still something to be said for rolling your own solution. More importantly, there’s certainly other potential uses for a fully open source programmable fan controller.