Posts with «arduino» label

R2Home Is Ready To Bring Back Your High Altitude Payload

With high-altitude ballooning, you are at the mercy of the winds, which can move your payload hundreds of kilometers and deposit it in some inaccessible spot. To solve this [Yohan Hadji] created R2Home, an autonomous parachute-based recovery system that can fly a payload to any specified landing site within its gliding range.

We first covered R2Home at the start of 2021, when he was still in the early experimental phases, but the project has matured massively since then. It just completed its longest and highest test flight. Descending autonomously from a release altitude of 3500 m, with an additional radiosonde payload, it landed within 5 m of the launch point.

R2Home electronics with it’s insulated enclosure

R2Home can fly using a variety of steerable canopies, even a DIY ram-air parachute, as demonstrated in an earlier version. [Yohan] is currently using a high-performance wing for RC paragliders.

A lot of effort went into developing a reliable parachute deployment system. The main canopy is packed carefully in a custom “Dbag”, which is attached to a drogue chute to stabilize the system during free-fall and deploy the main canopy at a preset altitude. This is done with a servo operated release mechanism, while steering is handled by a pair of modified winch servos intended for RC sailboats.

All the electronics are mounted on a stack of circular 3D printed brackets which fit in a tubular housing, bolted together with threaded rods. With the help of a design student [Yohan] also upgraded the simple tube housing to a lockable, foam-insulated design to help it handle temperatures at high altitudes.

The flight main flight computer is a Teensy 4.1  plugged into a custom PCB to connect all the navigation, communication, and flight systems. The custom Arduino-based autopilot takes inputs from a GPS receiver, and pilots the system to the desired drop zone, which it circles until touchdown.

The entire project is extremely well documented, and all the design files and code are open source and available on Github.

a Customizable Macropad to Make Anyone’s Tail Wag

[Gili Yankovitch] has always wanted some kind of macro keypad for all those boss-slaying combos he keeps up the sleeve of his wizard robe while playing WoW. Seventeen years later, he finally threw down the gauntlet and built one. But really, this is an understatement, because Paws is kind of the customizable macropad to end all customizable macropads.

This thing is completely bespoke, and yet cookie cutter at the same time — but we mean that in the best possible way. Paws can be made in any shape or form, and quite easily. How is this even possible, you ask? Well, every single key has its own microcontroller.

Yep, each key has an ATtiny85 and a cute little ribbon cable, and these form a token ring network that talks to an Arduino, which provides the keyboard interface to the computer. To make things even easier, [Gili] built a simple programming UI that automatically recognizes the configuration and number of keys, and lets the user choose the most important bit of all — the color of the LED.

[Gili] wanted to combine all the skills he’s learned since the worst timeline started in early 2020 — embedded software, CAD, electronics, and PCB design. We’d like to add networking to that list, especially since he figured out a nice workaround for the slowness of I²C and the limitations of communication between the ‘tiny85s and the Arduino. Though [Gili] may have started out with a tall order, he definitely filled it. Want to get your paws on the design files? Just claw your way over to GitHub.

If your customization interests lie more toward what program is in focus, be sure to check out Keybon, which was one of the many awesome winners of our Odd Inputs and Peculiar Peripherals contest.

Impatience is a Virtue When Testing This Old Maritime Teleprinter

[Larry Wall], inventor of Perl, once famously said that programmers have three key virtues: sloth, hubris, and impatience. It’s safe to say that these personality quirks are also present in some measure in most hardware hackers, too, with impatience being perhaps the prime driver of great hacks. Life’s too short to wait for someone else to build it, whatever it may be.

Impatience certainly came into play for [Sebastian (AI5GW)] while hacking a NAVTEX receiver. The NAVTEX system allows ships at sea to receive text broadcast alerts for things like changes in the weather or hazards to navigation. The trouble is, each NAVTEX station only transmits once every four hours, making tests of the teleprinter impractical. So [Sebastian]’s solution was to essentially create his own NAVTEX transmitter.

Job one was to understand the NAVTEX protocol, which is a 100-baud, FSK-modulated signal with characters encoded in CCIR 476. Since this encoding is also used in amateur radio teletype operations, [Sebastian] figured there would surely be an Arduino library for encoding and decoding it. Surprisingly, there wasn’t, but there is now, allowing an Arduino to produce the correct sequence of pulses for a CCIR 476-encoded message. Fed into a function generator, the mini-NAVTEX station’s signal was easily received and recorded by the painfully slow teleprinter. There’s that impatience again.

We thought this was a neat hack, and we especially appreciate that [Sebastian]’s efforts resulted in a library that could be useful to hams and other radio enthusiasts in the future. We’ve talked about some more modern amateur radio digital modes, like WSPR and FT8, but maybe it’s time to look at some other modes, too.

A Handy Tester for a Mountain of PS/2 Keybords

The hacking life is not without its challenges, and chief among these is the tendency to always be in acquisition mode. When we come across a great deal on bulk equipment, or see a chance to rescue some obscure gear from the e-waste stream, we generally pounce on it, regardless of the advisability.

We imagine this is why [Nathan] ended up with a hoard of PS/2 keyboards. Seriously, there are like thousands of the things. And rather than lug a computer to them for testing, [Nathan] put together this handy Arduino-based portable tester to see which keyboards still have some life left in them. The video below goes into detail on the build, but the basics are pretty simple — an Arduino, a 16×2 LCD display, and a few bits and bobs to run it off a LiPo pack and charge it up. Plus, of course, a PS/2 jack to plug in a keyboard and power it up. Interestingly, the 16×2 display is an old Parallax unit, from the days when RadioShack still existed and sold their stuff. That required a little effort to get it working with the Arduino, but in the end it works like a charm — plug in a keyboard and whatever you type shows up on the screen.

Of course, it’s hard to look at something like this, and that mountain of keyboards in the background, and not scheme up ways to really automate the whole test process. Perhaps an old 3D printer with a stylus mounted where the hot end would go could press each key in turn while the tester output is recorded — something like this Wordle-bot, but on a keyboard scale. That kind of goes against [Nathan]’s portability goal, but it’s still fun to think about.

Hack a Day 12 Jul 16:30
2  arduino  arduino hacks  keyboard  ps  serial  test  tool hacks  

Old CNC Brain Swapped With An Arduino

[Sebastian] and [Stefan Shütz] had a ISEL EP1090 CNC machine at home, sitting unused, and they decided to bring it to life. With pretty good mechanical specs, this CNC looked promising – alas, it was severely constrained by its controller. The built-in CPU’s software was severely outdated, had subpar algorithms for motor driving programmed in, and communication with the CNC was limited because the proprietary ISEL communications protocol that isn’t spoken by other devices.The two brothers removed the CPU from its PLCC socket, and went on to wiring a grbl-fueled Arduino into the controller box.

They reverse-engineered the motor driver connections – those go through a 74HC245 buffer between the original CPU and the drivers. Initially, they put an Arduino inside the control box of the CNC and it fit nicely, but it turned out the Arduino’s CPU would restart every time the spindle spun up – apparently, EMC would rear its head. So, they placed the Arduino out of the box, and used two CAT7 cables to wire up the motor and endstop signals to it.

For tapping into these signals, they took the 74HC245 out of its socket, and made an interposer from two small protoboards and some pin headers – letting them connect to the STEP and DIR lines without soldering wires into the original PCB. There’s extensive documentation, GRBL settings, and more pictures in their GitHub repo, too – in case you have a similar CNC and would like to learn about upgrading its controller board!

After this remake, the CNC starts up without hassles. Now, the brothers shall CNC on! Often, making an old CNC machine work is indeed that easy, and old controller retrofits have been a staple of ours. You can indeed use an Arduino, one of the various pre-made controller boards like Gerbil or TinyG, or even a Raspberry Pi – whatever helps you bridge the divide between you and a piece of desktop machinery you ought to start tinkering with.

Pocket Radio Powered By Tiny Microcontroller

Before the days of MP3 players and smartphones, and even before portable CD players, those of us of a certain age remember that our cassette players were about the only way to take music on-the-go. If we were lucky, they also had a built-in radio for when the single tape exhausted both of its sides. Compared to then, it’s much easier to build a portable radio even though cassettes are largely forgotten, as [wagiminator] shows us with this radio design based on an ATtiny.

The build is about as compact as possible, with the aforementioned ATtiny 402/412 as its core, it also makes use of an integrated circuit FM tuner,  an integrated audio amplifier with its own single speaker, and a small OLED display. The unit also boasts its own lithium-polymer battery charger and its user interface consists of only three buttons, plenty for browsing radio stations and controlling volume.

The entire build fits easily in the palm of a hand and is quite capable for a mobile radio, plus all of the schematics and code is available on the project page. While it doesn’t include AM capability, just the fact that FM is this accessible nowadays when a few decades ago it was cutting-edge technology is quite remarkable. If you’re looking for an even smaller FM receiver without some of the bells and whistles of this one, take a look at this project too.

Hack a Day 06 Jul 21:00
arduino  attiny  audio  code  fm  oled  radio  radio hacks  schematics  speaker  

GGWave Sings the Songs of Your Data

We’re suckers for alternative data transmission methods, and [Georgi Gerganov]’s ggwave made us smile. At its core, it’s doing what the phone modems of old used to do – sending data encoded as different audio tones. But GGwave does this with sophistication!

It splits the data into four-bit chunks, and uses 16 different frequency offsets to represent each possible value. But for each chunk, these offsets are added to one of six different base frequencies, which allows the receiving computer to tell which chunk it’s in. It’s like a simple framing concept, and it makes the resulting data sound charmingly like R2-D2. (It also uses begin and end markers to be double-sure of the framing.) The data is also sent with error correction, so small hiccups can get repaired automatically.

What really makes ggwave shine is that it’s ported to every platform you care about: ESP32, Arduino, Linux, Mac, Windows, Android, iOS, and anything that’ll run Python or JavaScript. So it’ll run in a browser. There’s even a GUI for playing around with alternative modulation schemes. Pshwew! This makes it easy for a minimalist microcontroller-based beeper button to control your desktop, or vice-versa. An ESP32 makes for an IoT-style WiFi-to-audio bridge. Write code on your cell phone, and you can broadcast it to any listening microcontroller. Whatever your use case, it’s probably covered.

Now the downside. The data rate is slow, around 64-160 bits per second, and the transmission is necessarily beepy-booopy, unless you pitch it up in to the ultrasound or use the radio-frequency HackRF demo. But maybe you want to hear when your devices are talking to each other? Or maybe you just think it’s cute? We do, but we wouldn’t want to have to transmit megabytes this way. But for a simple notification, a few bytes of data, a URL, or some configuration parameters, we can see this being a great software addition to any device that has a speaker and/or microphone.

Oh my god, check out this link from pre-history: a bootloader for the Arduino that runs on the line-in.

Hack a Day 06 Jul 19:30

UART Can’t? Arduino CANSerial Can!

[Jacob Geigle] had a problem. A GPS unit and a Bluetooth-to-serial were tying up all the hardware UARTs on an AVR Arduino project. “Software serial”, I hear you say. But what if I told you [Jacob] already had the board in question sending out data over CAN bus?

[Jacob]’s sweet hack creates an arbitrary number of CAN “devices” inside the Arduino code, and can treat each one of them as its own serial data channel. The “N” in CAN stands for network, after all. The trick is to create a device ID for each desired CANSerial interface, which is done in his library using the usual Arduino setup step. A buffer takes care of storing all the different channels until they can be pushed out over the hardware CAN peripheral. On the big-computer side of things, some software listens for the different “device” enumeration IDs and assigns each a virtual serial port.

While this was a hack born of necessity, we can see it as a clever opportunity to segregate information coming from the microcontroller into different streams. Maybe a debug channel, a command channel, and a data channel? They’re virtual devices, so go nuts!

While we usually see CANbus in its native habitat – inside your car – it’s also cool to think of the uses we could put it to. For instance, controlling a 3D printer. Need a CAN refresher? We’ve got just the ticket.

[Bus photo: Malta Bus; The terminus, Valletta by John Haslam. Can photo: Paint Cans by Daniel R. Blume. Horrible visual pun: I’m afraid that’s on us. You try finding images for CANbus code!]

Hack a Day 05 Jul 06:00

Arduino Drum Platform Is Fast

Drums are an exciting instrument to learn to play, but often prohibitive if there are housemates or close neighbors involved. For that problem there are still electronic drums which can be played much more quietly, but then the problem becomes one of price. To solve at least part of that one, [Jeremy] turned to using an Arduino to build a drum module on his own, but he still had to solve yet a third problem: how to make the Arduino fast enough for the drums to sound natural.

Playing music in real life requires precise timing, so the choice of C++ as a language poses some problems as it’s not typically as fast as lower-level languages. It is much easier to work with though, and [Jeremy] explains this in great detail over a series of blog posts detailing his drum kit’s design. Some of the solutions to the software timing are made up for with the hardware on the specific Arduino he chose to use, including an even system, a speedy EEPROM, hardware timers, and an ADC that can sample at 150k samples per second.

With that being said, the hardware isn’t the only thing standing out on this build. [Jeremy] has released the source code on his GitHub page for those curious about the build, and is planning on releasing several more blog posts about the drum kit build in the near future as well. This isn’t the only path to electronic drums, though, as we’ve seen with this build which converts an analog drumset into a digital one.

Hack a Day 29 Jun 06:00

Pocket Computer Reminds Us of PDAs

Before smartphones exploded on the scene in the late 00s, there was still a reasonable demand for pocket-sized computers that could do relatively simple computing tasks. Palm Pilots and other PDAs (Personal Digital Assistants) were all the rage in the ’90s and early ’00s, although for cutting-edge tech from that era plenty of these devices had astronomical price tags. This Arduino-based PDA hearkens back to that era, albeit with a much more accessible parts list.

The build is based around an Arudino Nano with an OLED screen and has the five necessary functions for a PDA: calculator, stopwatch, games, phonebook, and a calendar. With all of these components on such a small microcontroller, memory quickly became an issue when using the default libraries. [Danko] uses his own custom libraries in order to make the best use of memory which are all available on the project’s GitHub page. The build also includes a custom PCB to keep the entire pocket computer pocket-sized.

There are some other features packed into this tiny build as well, like the breakout game that can be played with a potentiometer. It’s an impressive build that makes as much use of the microcontroller’s capabilities as is possible, and if you enjoy projects where a microcontroller is used as if it is a PC take a look at this Arduino build with its own command-line interface.

Hack a Day 23 Jun 21:00