A graph visualising approximation errors - the specific principle pictured is described well by the linked article

Time And Accuracy In Las ATMegas

January 31, 2022 by Arya Voronova 4 Comments

Do you ever have to ensure that an exact amount of time passes between two tasks in your microcontroller code? Do you know what’s the difference between precision and accuracy? Today, [Jim Mack] tells us about pushing timers and interrupts to their limits when it comes to managing time, while keeping it applicable to an ever-popular ATMega328P target! Every now and then, someone decides to push the frontiers of what’s possible on a given platform, and today’s rules is coding within constraints of an Arduino environment. However, you should check [Jim]’s post out even if you use Arduino as a swearword – purely for all of the theoretical insights laid out, accompanied by hardware-accurate examples!

This will be useful to any hacker looking to implement, say, motor encoder readings, signal frequency calculations, or build a gadget processing or modifying audio in real time. To give you a sample of this article, [Jim] starts by introducing us to distinctions between precision and accuracy, and then presents us with a seemingly simple task – creating exactly 2400 interrupts a second. As much as it might look straightforward, problems quickly arise when clock crystal frequency doesn’t cleanly divide by the sampling frequency that you have to pick for your application! This is just a taste of all the examples of hidden complexity presented, and they’re accompanied with solutions you can use when you eventually encounter one of these examples in your hacker pursuits. In the end, [Jim] concludes with links to other sources you can study if you ever need to dig deeper into this topic.

Keeping our projects true to the passage of time can be an issue, and we’ve been at it for ages – calibrating your RC oscillator is a rite of passage for any ATTiny project. If you ever decide to have an interrupt peripheral help you with timing issues, we’ve gone in-depth on that topic in the past, with a three-part series describing the benefits, the drawbacks and the edgecases of interrupts. Going for a more modern target? Our piece on using interrupts with STM32 is a great path for trying out tools of the modern age.

ESP32 And Raspberry Pi Take Over Game Boy LCD

January 30, 2022 by Tom Nardi No comments

The Nintendo Game Boy and its many permutations represent one of the most well-known and successful gaming platforms ever produced. There was a decades-long stretch of time where the most popular kid in the lunch room was the one who brought in their Game Boy so the rest of the class could huddle around and check out the latest Pokemon title.

But those days are long gone, and now these once-coveted handhelds can be had for a song on the second-hand market. Which makes it the perfect time to check out this project [kgsws] released recently that allows you to interface the Game Boy LCD with the ESP32 or the Raspberry Pi. In the most basic of applications, it lets you push video from your Linux computer out to the Game Boy LCD over WiFi. But as the video below illustrates, that’s just the tip of the iceberg.

With the ESP32 wired between the handheld’s LCD and main PCB, the microcontroller can also act as a capture device using I2S camera mode. Compared to what ends up showing on the handheld’s LCD, the recorded gameplay [kgsws] shows off looks fantastic. Visuals are crisp and fluid, and naturally devoid of the Game Boy’s iconic (if slightly nauseating) greenish tint.

The project also includes the capability to control an array of Game Boy LCDs, which allows for some interesting possibilities. The image can be stretched to cover multiple displays, which [kgsws] demonstrates by playing a game on 3 x 3 grid of salvaged panels, but each LCD also can be controlled individually as is the case with the large digital clock seen above.

Whether you’re looking for a way to capture gameplay on the real hardware, or want to run RetroPie on a real Game Boy screen, we’re excited to see what folks come up with using this project.

Continue reading “ESP32 And Raspberry Pi Take Over Game Boy LCD” →

Custom Piano Tickles The Ivories

January 28, 2022 by Bryan Cockfield 6 Comments

The core ethos of “hacking” is usually interpreted as modifying something for a use that it wasn’t originally built for. Plenty of builds are modifications or improvements on existing technology, but sometimes that just isn’t enough. Sometimes we have to go all the way down and build something completely from scratch, and [Balthasar]’s recent piano-like musical instrument fits squarely into this category.

This electronic keyboard is completely designed and built from scratch, including the structure of the instrument and the keys themselves. [Balthasar] made each one by hand out of wood and then built an action mechanism for them to register presses. While they don’t detect velocity or pressure, the instrument is capable of defining the waveform and envelope for any note, is able to play multiple notes per key, and is able to change individual octaves. This is thanks to a custom 6×12 matrix connected to a STM32 microcontroller. Part of the reason [Balthasar] chose this microcontroller is that it can do some of the calculations needed to produce music in a single clock cycle, which is an impressive and under-reported feature for the platform.

With everything built and wired together, the keyboard is shockingly versatile. With the custom matrix it is easy to switch individual octaves on the piano to any range programmable, making the 61-key piano capable of sounding like a full 88-key piano. Any sound can be programmed in as well, further increasing its versatility, which is all the more impressive for being built from the ground up. While this build focuses more on the electronics of a keyboard, we have seen other builds which replicate the physical action of a traditional acoustic piano as well.

Continue reading “Custom Piano Tickles The Ivories” →

Hacking A Proper Dash Into The Tesla Model 3

January 28, 2022 by Lewin Day 60 Comments

The Tesla Model 3 and Model Y are popular electric vehicles that dispense with some of the usual provisions you’d expect in a typical car. Namely, there’s no dash cluster in front of the driver; instead, all information is solely displayed on the center console screen. [Nick Nguyen] wasn’t a fan of this setup, and decided to hack together a dash cluster of his own.

The CANdash works in a simple fashion, snooping the Tesla’s CAN bus for all the information relevant to the vehicle’s operation. It’s capable of displaying everything from speed to the remaining range in the battery, while also allowing the user to keep an eye on things like coolant temperatures and whether the Tesla Autopilot system is currently available.

The build relies on a CANserver, an ESP32-based device specifically built for hooking up to the CAN bus on Tesla vehicles and sharing the data externally. The data can then be piped wirelessly to an Android phone running CANdash to display all the desired information. With the help of an aftermarket dash clip or a 3D printed custom mount, the phone can then be placed behind the steering wheel to display data in the usual location.

It’s a simple, straightforward hack that gives Tesla owners a useful feature that they’re otherwise missing from the factory. The US automakers cars are proving to be fertile ground for hackers and DIYers, with one man recently saving thousands on a battery swap with a simple mod. Video after the break.

Continue reading “Hacking A Proper Dash Into The Tesla Model 3” →

Remoticon 2021 // Voja Antonic Makes You A Digital Designer

January 27, 2022 by Dave Rowntree 10 Comments

[Voja Antonic] has been building digital computers since before many of us were born. He designed with the Z80 when it was new, and has decades of freelance embedded experience, so when he takes the time to present a talk for us, it’s worth paying attention.

For his Remoticon 2022 presentation, he will attempt to teach us how to become a hardware expert in under forty minutes. Well, mostly the digital stuff, but that’s enough for one session if you ask us. [Voja] takes us from the very basics of logic gates, through combinatorial circuits, sequential circuits, finally culminating in the description of a general-purpose microprocessor.

A 4-bit ripple-carry adder with additional CPU flag outputs

As he demonstrates, complex digital electronics systems really are just built up in a series of steps of increasing complexity. starting with individual active elements (transistors operating as switches) forming logic elements capable of performing simple operations.

From there, higher level functions such as adders can be formed, and from those an ALU and so on. Conceptually, memory elements can be formed from logic gates, but it’s not the most efficient way to do it, and those tend to be made with a smaller and faster circuit. But anyway, that model is fine for descriptive purposes.

Once you have combinatorial logic circuits and memory elements, you have all you need to make the necessary decoders, sequencers and memory circuits to build processors and other kinds of higher complexity circuits.

Obviously forty minutes isn’t anywhere nearly enough time time to learn all of the intricacies of building a real microprocessor like the pesky details of interfacing with it and programming it, but for getting up the learning curve from just a knowledge of binary numbers to an understanding of how a CPU is built, it’s a pretty good starting point.

Now, If you can only tear your eyes away from his slick game-of-life wall mounted LED display, you might pick up a thing or two.

Continue reading “Remoticon 2021 // Voja Antonic Makes You A Digital Designer” →

DIY “Solid State Drive” Puts Four Bytes In Your Pocket

January 23, 2022 by Tom Nardi 71 Comments

In a relatively short amount of time, the average capacity of USB flash drives has skyrocketed. It wasn’t so long ago that two and four gigabyte drives were considered to be on the high end, but today you can grab a 512 GB drive for less than $50 USD. In fact they’ve gotten so large that it can feel wasteful using them for some tasks, and we occasionally find ourselves wishing we could find some modern USB drives that didn’t rival the storage capacity of our whole computer.

That said, this USB-C tetrabyte drive created by [Glen Akins] might be slightly too small for our tastes. No, that’s not a typo. As in the Greek tetra, this drive can hold a massive four bytes at a time. Even better, you don’t need a computer to write to it: the 32 DIP switches let you key in the content on the fly, bit-by-bit.

Reading out the first byte from the DIP switches.

As explained in a Twitter thread, [Glen] was inspired to create this gadget after another user posted a picture of a 32 position DIP switch with a caption that said it was a “One Tetrabyte SSD” back in December. He apparently couldn’t track down the same switch, but the four red Grayhill 76 Series switches arguably make it a bit clearer when entering in your bytes.

Each of the individual DIP switches are connected to one of the GPIO pins of the 8-bit EFM8UB2 microcontroller, and the code simply reads the state of each pin in order and saves the binary results in a variable to put together the “file” it presents to the OS when plugged in.

We’ve seen our fair share of unusual USB flash drives in the past, but this one is truly in a league of its own. Can’t say we can think of any four bytes of data important enough to hold on a dedicated piece of hardware, but we certainly appreciate the effort to store it in the most robust way possible.

Thanks to [J. Peterson] for the tip.

Web-Centric Gabuino Has Compiler, Will Travel

January 23, 2022 by Tom Nardi 16 Comments

Arguably the biggest advantage of the Arduino platform is its ease of use, especially when compared to what microcontroller development looked like before the introduction of the open source board and its associated software development environment. All you need to do is download the IDE for your platform, plug in your Arduino, and you can have code running on the hardware with just a few clicks.

But can it get even easier? [Gabriel Valky] certainly thinks so, which is why he’s developed the cloud-based Gabuino platform. As of right now it only supports the DS213 pocket oscilloscope and LA104 logic analyzer, but he says the code is lightweight enough that it should work with any STM32 board that has the appropriate bootloader. Using Gabuino requires no software to be installed on the computer, just plug in the board, and you’re already half way there.

Gabuino processing data from digital calipers.

The trick is that the code editor and compiler have been moved into the cloud, and are accessed through the host computer’s web browser. The web interface also integrates an impressive “Console”, which [Gabriel] likens to the Serial Monitor and Plotter functions of the Arduino IDE, but is actually far more capable. The Gabuino Console is not only bi-directional, but through the use of libraries such as Three.js and WebGL, it’s able to render video output from code running on the microcontroller.

[Gabriel] takes us through some of the capabilities of Gabuino in the video below, and we have to say, it looks pretty impressive. We especially liked the built-in debugging capabilities that let you set breakpoints and examine variables. This plug-and-play approach certainly holds promise for students or beginners, though we think the hardware compatibility will need some work before the project really takes off.

Incidentally, this isn’t the first time [Gabriel] has written some code for the LA104. Last year we covered his very impressive custom firmware for the ~$100 USD gadget, which should sweeten the deal considerably if you end up getting one to experiment with Gabuino on.

Continue reading “Web-Centric Gabuino Has Compiler, Will Travel” →