Posts | Comments

Planet Arduino

Archive for the ‘arduino’ Category

[Adam Welch] has built macro pads in the past out of pre-fab key matrices and handfuls of Cherry MX clones. But all the stickers and custom keycaps in the world wouldn’t make those macro pads as versatile as a stream deck — those visual shortcut panels with tiny touchscreens for each button that some streamers use to change A/V settings or switch between applications.

Let’s face it, stream decks are expensive. But 0.96″ OLED displays are not, and neither are SMD tactile buttons. Why not imitate a screen deck on the cheap by making it so the screens actuate buttons behind them? [Adam] based this baby on the clever design of [Kilian Gosewisch]’s FreeDeck, and they ended up working together to improve it with a dedicated PCB.

The brains of the operation is an Arduino Pro Micro, which addresses each screen individually via two 74HC4051 mux ICs. Thanks to an SD card module, there’s no need to flash the ‘duino every time you want to change a shortcut or its picture. Even if this deck doesn’t hold up forever, it won’t break the bank to build another one. Poke past the break for the build video, which has all the links you’d need to make your own, including a handy configurator.

There’s more than one way to do a visual macro pad. Here’s one that uses a single screen and splits it Brady Bunch style to match the matrix.

Thanks for the tip, [arturo182]!

Deep freezers are a great thing to have, especially when the world gets apocalyptic. Of course, freezers are only good when they’re operating properly. And since they’re usually chillin’ out of sight and full of precious goods, keeping an eye on them is important.

When [Adam] started looking at commercial freezer alarms, he found that most of them are a joke. A bunch are battery-powered, and many people complain that they’re too quiet to do any good. And you’d best hope that the freezer fails while you’re home and awake, because they just stop sounding the alarm after a certain amount of time, probably to save battery.

If you want something done right, you have to do it yourself. [Adam]’s homemade freezer failure alarm is a cheap and open solution that ticks all the boxen. It runs on mains power and uses a 100dB piezo buzzer for ear-splitting effectiveness to alert [Adam] whenever the freezer is at 32°F/0°C or above.

If the Arduino loses sight of the DHT22 temperature sensor inside the freezer, then the alarm sounds continuously. And if [Adam] is ever curious about the temperature in the freezer, it’s right there on the 7-segment. Pretty elegant if you ask us. We’ve got the demo video thawing after the break, but you might wanna turn your sound down a lot.

You could assume that the freezer is freezing as long as it has power. In that case, just use a 555.

Irene Wolf is the owner a Passap E6000, a computerized knitting machine which features pair of needle beds, and decided it was time to give it an upgrade. In particular, she wanted the ability to control its rear needle bed automatically in a similar manner to the way the front is normally operated for extra functionality.

To accomplish this non-trivial task, she’s using a Raspberry Pi 3 as the new controller, along with two Arduino M0 boards to directly handle the machine’s actions via interrupts.

She’s also driving the device’s motor with a frequency converter and an Uno, as the original control board was broken. Plenty of details are available in Wolf’s write-up and on GitHub, and you can even see it in action (plus a resulting knitted sock) in the video below.

If you want strangers to give you well wishes on your birthday out in the real world, you have call attention to the occasion by wearing a pointy hat or a button that says ‘today is my birthday, gimme presents’. But on your reddit cakeday, aka the day you joined, you’re automatically singled out with the addition of a slice of 8-bit cake next to your username. The great thing about your cakeday is that you’re almost guaranteed to get some karma for once, especially if you make something cakeday related like [ScottyD]’s cakeday countdown clock. But plenty of people forget what their cakeday is and miss out on the fun.

This countdown clock works like you might expect — every day that isn’t your cakeday, a message scrolls by with the number of days remaining until your next one. When the big day comes, the message becomes TODAY IS YOUR CAKE DAY. Both messages are bookended by cute little pixelated cake slices that we would apply liberally to the day-of message if we made one of these.

This simple but fun project shouldn’t put too big of a dent in your parts box, since it’s essentially an Arduino, a real-time clock module, and a 32×8 LED matrix to display the text. We love the uni-body design of the enclosure because it creates a shelf for the Arduino and gives easy access for gluing in the display from the rear. If for some reason you don’t reddit, then make one anyway and use it to count down to your IRL birthday or something. We’ve got the build video cut and plated for you to consume after the break.

We would understand if 2020 is supplying you with enough existential crises, but if not, consider building a clock that counts down the rest of your life expectancy.

Via r/duino

What if you were to use the hands of a clock not as an individual display, but as part of an array combines together to form digits? That’s the idea behind Clockception by creator “Made by Morgan,” which utilizes 48 servo motors to drive 24 clock-like faces for an 8×3 display.

The build uses an Arduino Nano and three servo driver boards to control movement, along with a DS1302 RTC module to track time. The overall clock is constructed out of stained poplar, while the dial assemblies are 3D-printed.

Clockception was actually inspired by the ClockClock project by Humans Since 1982, but by using his own design and DIY methods, he was able to get the cost down to around $200.

Overall computer volume control is important, but what if you want to get more granular, adjusting sound from various applications individually? Rather than going through a series of menus and on-screen sliders, Ruben Henares’ Maxmix lets you do this on the fly.

Based on an Arduino Nano, the simple yet stylish knob takes input from an encoder and button to select a program and rotating it turns the volume up and down.

There’s also a desktop application that needs to be installed, while a small OLED screen on the Maxmix that shows which application is running. There’s even an optional LED ring for extra lighting effects.

All the electronics are housed inside a nicely designed 3D-printed enclosure. You can find files for the case along with build instructions on Henares’ site.

If you’ve ever left an online comment that you later regretted, this anti-troll bot will keep that from happening again by letting you know when you’re being a bit too harsh.

The device — which was created by Andy of element14 Presents — intercepts raw keyboard inputs using a MKR Zero board and analyzes them using a TensorFlow Lite machine learning algorithm.

As an output, the Arduino controls the mouth of a rather hilarious human cutout via a servo motor, which as seen in the video below, also features a wisp of black hair and oversized googly eyes. If you’re typing happy thoughts, its mouth turns up into a smile, while mean words produce a frowny face.

The project is a great example of running ML code on limited hardware, and more info on the sentiment-analyzing keyboard adapter can be found here.

We’ve all been there. You’re manning the battle station, deep in the sim-racing or some other n00b-pwning zone and suddenly some loudmouth blows out your eardrums over Discord. It’s insulting to have to stop what you’re doing to find the right Windows volume slider. So why do that? Build [T3knomanzer]’s simple yet elegant multi-volume knob and stay zen in the zone.

It’s easy, just turn the knob to cycle through your programs until Discord comes up on the little screen, and then push down to change it into a volume knob. If you need to change another volume, just click it again. Since there’s no Alt+Tabbing out to the desktop, no checkered flags should ever slip through your fingers.

Inside the well-designed case you’ll find the usual suspects — Arduino Nano, rotary encoder, an OLED display, and an LED ring, each with their own place carved out.

This completely open-source knob looks great, and we love that it’s been made incredibly easy to replicate by standing up a site with foolproof, well-depicted, step-by-step instructions. Watch them take it for a spin after the break.

Want more than volume at your fingertips? Here’s a DIY USB knob that does shortcuts, too.

DIY camera sliders are a great way to get professional-looking video shots on an amateur budget, but few can compare to the quality of this project by “isaac879.”

His device features a pan/tilt mechanism outlined in a previous video, but in the clip below he’s attaching it to a piece of aluminum extrusion to enable it to slide as well.

The build is controlled by an Arduino Nano, which actuates three stepper motors using A4988 drivers. The carriage is pulled along by a belt drive, via a stepper mounted to the carriage itself. This allows for easy disassembly when needed.

It’s a clever and extremely clean design, and the video shows some great examples of the shots it can take (even when upside down).

The Arduino CLI is an open source command line application written in Golang that can be used from a terminal to compile, verify and upload sketches to Arduino boards, and that’s capable of managing all the software and tools needed in the process. But don’t get fooled by its name: the Arduino CLI can do much more than the average console application, as shown by the Pro IDE and Arduino Create, which rely on it for similar purposes but each one in a completely different way from the other.

In this article, we introduce the three pillars of the Arduino CLI, explaining how we designed the software so that it can be effectively leveraged under different scenarios.

The first pillar: command line interface

Console applications for humans

As you might expect, the first way to use the Arduino CLI is from a terminal and by a human, and user experience plays a key role here. The UX is under a continuous improvement process as we want the tool to be powerful without being too complicated. We heavily rely on sub-commands to provide a rich set of different operations logically grouped together, so that users can easily explore the interface while getting very specific contextual help.

Console applications for robots

Humans are not the only type of customers we want to support and the Arduino CLI was also designed to be used programmatically — think about automation pipelines or a CI/CD system. 

There are some niceties to observe when you write software that’s supposed to be easy to run when unattended and one in particular is the ability to run without a configuration file. This is possible because every configuration option you find in the arduino-cli.yaml configuration file can be provided either through a command line flag or by setting an environment variable. To give an example, the following commands are all equivalent and will proceed fetching the unstable package index that can be used to work with experimental versions of cores: 

See the documentation for details about Arduino CLI’s configuration system.

Consistent with the previous paragraph, when it comes to providing output the Arduino CLI aims to be user friendly but also slightly verbose, something that doesn’t play well with robots. This is why we added an option to provide output that’s easy to parse. For example, the following figure shows what getting the software version in JSON format looks like.

Even if not related to software design, one last feature that’s worth mentioning is the availability of a one-line installation script that can be used to make the latest version of the Arduino CLI available on most systems with an HTTP client like curl or wget and a shell like bash.

The second pillar: gRPC interface

gRPC is a high-performance RPC framework that can efficiently connect client and server applications. The Arduino CLI can act as a gRPC server (we call it daemon mode), exposing a set of procedures that implement the very same set of features of the command line interface and waiting for clients to connect and use them. To give an idea, the following is some Golang code capable of retrieving the version number of a remote running Arduino CLI server instance:

gRPC is language-agnostic: even if the example is written in Golang, the programming language used for the client can be Python, JavaScript or any of the many supported ones, leading to a variety of possible scenarios. The new Arduino Pro IDE is a good example of how to leverage the daemon mode of the Arduino CLI with a clean separation of concerns: the Pro IDE knows nothing about how to download a core, compile a sketch or talk to an Arduino board and it demands all these features of an Arduino CLI instance. Conversely, the Arduino CLI doesn’t even know that the client that’s connected is the Pro IDE, and neither does it care.

The third pillar: embedding

The Arduino CLI is written in Golang and the code is organized in a way that makes it easy to use it as a library by including the modules you need in another Golang application at compile time. Both the first and second pillars rely on a common Golang API, a set of functions that abstract all the functionalities offered by the Arduino CLI, so that when we provide a fix or a new feature, they are automatically available to both the command line and gRPC interfaces. 

The source modules implementing this API can be imported in other Golang programs to embed a full-fledged Arduino CLI. For example, this is how some backend services powering Arduino Create can compile sketches and manage libraries. Just to give you a taste of what it means to embed the Arduino CLI, here is how to search for a core using the API:

Embedding the Arduino CLI is limited to Golang applications and requires a deep knowledge of its internals. For the average use case, the gRPC interface might be a better alternative; nevertheless this remains a valid option that we use and provide support for.

Conclusion

You can start playing with the Arduino CLI right away. The code is open source and we provide extensive documentation. The repo contains example code showing how to implement a gRPC client, and if you’re curious about how we designed the low-level API, have a look at the commands package and don’t hesitate to leave feedback on the issue tracker if you’ve got a use case that doesn’t fit one of the three pillars.



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook