Graphing calculators have evolved from expensive playthings for rich nerds to everyday tools for high schoolers worldwide. Even though teenagers nowadays carry powerful internet-connected computers in their pockets, math teachers often prefer them to use a clunky Z80-powered calculator in class, if only because their limited performance reduces the potential for distraction. The worst thing a lazy student can do is play a simple game like Snake or Tetris.
But what if you’re not a student anymore and you want a graphing calculator that has up-to-date hardware and infinite customizability in software? Look no further than [Angel Cabello]’s Galdeano, a handheld that has all the features of a modern graphing calculator plus a lot more. The heart of the device is an ESP32, which sits on a custom PCB that also holds a 6×7 array of push-buttons and a 320×240 touch-sensitive color display. It can be powered through a lithium-polymer battery or, like a classic calculator, through four AAA cells. The entire thing is housed in a 3D printed enclosure with color-coded buttons indicating various built-in functions.
The ESP32 runs MicroPython along with a symbolic math engine called Eigenmath. This enables the Galdeano to manipulate expressions, perform integration and differentiation, and plot functions. Porting Eigenmath to a memory-constrained platform like the ESP32 was quite a challenge and required a few workarounds, including a memory partition scheme and even a custom compact font with mathematical symbols.
Thanks to the flexibility of MicroPython and the ESP’s WiFi system, the Galdeano is not limited to implementing a calculator: it can also perform various general-purpose tasks ranging from file editing to controlling a set of smart light bulbs. The project page doesn’t mention any games yet, but we’re sure it won’t take long before someone ports Tetris to this system as well.
[Brian Pugh] has shared a cool new project that simultaneously runs on desktop Python and MicroPython – the Belay library. This library lets you control a MicroPython device seamlessly from your Python code – interacting with real-world things like analog/digital trinkets, servos, Neopixels and displays, without having to create your own firmware or APIs.
You need a serial-connected MicroPython board – even an ESP8266 should do. Then, you can intersperse your Python code with MicroPython-written functions, and call them whenever you need your connected device to do something – keeping the entire logic of your project within a single device. [Brian] provides quite a few examples, even for more complex things like displays. No doubt, there are limitations, but this looks to be a powerful tool in a hacker’s arsenal.
If you live in a home with a garage door opener, you may have experienced one or more inevitable moments. You pull up to your home, you press the button on the garage door opener, and… nothing. Or you can’t find the garage door opener. Or you have to mash the button repeatedly to get a response. Or… you get the idea. Thanks to [Core Electronics] however, you now have the basis for using a much better device to control your own garage door: Your phone. You can see the tutorial on the web or in video format below the break.
[Herb Peyerl] is part of a robotics team, and in his robotics endeavours, learned about AprilTags; small QR-code-like printable patterns that are easily recognizable by even primitive machine vision. Later on, when thinking about good ways to let his guests through his property’s front gate, the AprilTags turned out to be a wonderful solution. Now all he needs to do is send his guest a picture of the appropriate AprilTag, which they can present to the camera at his front gate using their smartphone.
He used an OpenMV board for this – thanks to its wide variety of available libraries, the AprilTag recognition is already baked in, and the entire script is merely a hundred lines of MicroPython. An old surveillance camera gave up its dome-shaped housing, and now the OpenMV board is doing guest access duty on a post in front of his property’s front gate. He’s shared the code with us, and says he’s personally running a slightly modified version for security reasons — not that a random burglar is likely to stumble upon this post anyway. Besides it looks like the gate would be easy for a burglar to jump over without any need for security bypass, and the convenience benefits of this hack are undeniable.
Network Time Protocol (NTP) is one of the best ways to keep networked computers synchronized to the same time. It’s simple, lightweight, and not only allows computers to maintain a time standard together, but it also allows some computer manufacturers to save some money on hardware costs. The Raspberry Pi is perhaps the most well-known example of a low-cost computer without the extra expense of a real-time clock (RTC). While the Pi sets up NTP essentially automatically, other microcontrollers like the ESP32 don’t, but it is possible to configure them to use this time standard with some work.
For this project the MicroPython implementation for the ESP32 is required. MicroPython is a way of running Python code on microcontrollers or other embedded systems without all of the overhead that Python would normally require. Luckily enough, the NTP libraries are built right in so once MicroPython is running on the ESP32 it’s nearly as easy as calling the library. Of course you will have to make sure there is an internet connection, and then grab the time, sync it to the machine, and then set the timezone.
A peek inside the enclosure reveals…well, not a whole lot. All that’s hiding inside that heavy-duty plastic box is the Pi Pico and some screw down terminals that let [Alberto] easily wire up the female bulkhead connectors for the pedals themselves. Incidentally, while you could certainly make your own pedals, the ones used for this project appear to be the sort of commercially available units we’ve seen used in similar projects.
With the hardware sorted, [Alberto] just needed to write the software. While he could have taken the easy way out and hard coded everything, we appreciate that his CircuitPython script loads its configuration from a text file. This allows you to easily configure which GPIO pins are hooked up to buttons, and what key codes to associate them with. He didn’t really need to go through this much effort for his own purposes, but it makes the project far easier to adapt for others, so our hats off to him.
Sometimes, it’s really useful to watch a project’s parts come together one piece at a time in order to get a complete understanding and mental picture of the whole, and we found that to be the case with this simple, retro-inspired sample game from [ezContents]. (Video, embedded below.) The code is on GitHub but if you’re at all interested in what goes on behind the scenes in a game like that, don’t miss the video.
These sprite-based games are mostly about moving a small graphical object (a sprite) around a screen in response to user input, and managing what happens when collisions are detected between the player’s sprite and other sprites like enemies, projectiles, and so forth. The development process is wonderfully documented and demonstrated in a video, as each separate part of functionality gets built and explained one piece at a time.
The simple game is made using ArduPy (which is MicroPython combined with Arduino APIs) using Seeed Studios’ Wio Terminal, a small microcontroller development board with integrated screen, sensors, and button inputs including a little directional clicker that [ezContents] uses as a joystick.
The video of the whole process is embedded below; give it a watch and you’ll maybe come away with inspiration, but you’ll definitely have a much better understanding of how these types of games are developed, even if you’re not using the same hardware or development environment.