Posts with «esp32» label

Tiny TV Tells the Temperature Tale

Once upon a time, we would run home from the bus stop to watch Gargoyles and Brady Bunch reruns on the family TV, a late-1970s console Magnavox number that sat on the floor and was about 50% more cabinet than CRT. The old TV, a streamlined white Zenith at least ten years older, had been relegated to the man cave in the basement. It looked so mod compared to the “new” TV, but that’s not the aesthetic my folks were after. They wanted their electronics to double as furniture.

This little TV is a happy medium between the two styles, and for us, it’s all about those feet. But instead of cartoons, it switches between showing the current weather and the top news headlines. Inside that classy oak cabinet is an LCD, an ESP32, and an SD card module. The TV uses OpenWeatherMap and pulls the corresponding weather image from the SD card based on time of day — light images for day, and dark images for night.

We love that it shows the SMPTE color bars, aka the standard American TV test pattern as it switches between weather and news. After showing the top headlines, it automatically switches back to the weather channel. Be sure to check out the short demo video after the break.

Do you like your tiny televisions in strange places? Here’s one you can use to trim your tree this year.

Sparkpad Sparks Joy for Streamers

The best streamers keep their audience constantly engaged. They might be making quips and doing the funny voices that everyone expects them to do, but they’re also busy reading chat messages aloud and responding, managing different scenes and transitions, and so on. Many streamers use a type of macro keyboard called a stream deck to greatly improve the experience of juggling all those broadcasting balls.

Sure, there are dedicated commercial versions, but they’re kind of expensive. And what’s the fun in that, anyway? A stream deck is a great candidate for DIY because you can highly personalize the one you make yourself. Give it clicky switches, if that’s what your ears and fingers want. Or don’t. It’s your macro keyboard, after all.

[Patrick Thomas] and [James Wood] teamed up to build the perfect stream deck for [James]’ Twitch channel. We like the way they went about it, which was to start by assessing a macro pad kit and use what they learned from building and testing it to design their ideal stream deck. The current version supports both the Arduino Pro Micro and the ESP32. It has twelve key switches, a rotary encoder, an LED bar graph, and an OLED screen for choosing between the eight different color schemes.

If you’d rather have dynamic screens instead of cool keycaps, you can do it cheaper by making non-touch screens actuate momentaries.

The HackadayPrize2021 is Sponsored by:

Why Make Coffee When You’re Tired? Let a Robot Do It for You

Like us, [Alberto] doesn’t compromise when it comes to a good cup of coffee. We figure that if he went to an office in the Before Times, he was the type of coworker to bring in their own coffee equipment so as not to suffer the office brew. Or perhaps he volunteered to order the office supplies and therefore got to decide for everyone else. Yep, that’s definitely one way to do it.

But like many of us, he is now operating out of a home office. Even so, he’s got better things to do than stand around pouring the perfect cup of coffee every morning. See, that’s where we differ, [Alberto]. But we do love Cafeino, your automated pour-over machine. It’s so sleek and lovely, and we’re sure it does a much better job than we do by hand — although we enjoy doing the pouring ourselves.

Cafeino is designed to mimic the movements of a trained barista’s hand, because evidently you’re supposed to pour the water in slow, deliberate swirls to evenly cover the grounds. (Our kettle has a chunky spout, so we just sort of wing it.) Cafeino does this by pumping water from an electric kettle and pouring a thin stream of it in circles with the help of two servos.

The three buttons each represent a different recipe setting, which specifies the amount of water, the hand pouring pattern, and the resting times between blooming the grounds and actually pouring the bulk of the water. These recipes are set using the accompanying web app via an ESP32, although the main brain barista is an Arduino Nano. Grab a cup and check out the demo after the break.

Got an old but modern coffee robot lying around? You could turn it into a planter with automated watering.

The HackadayPrize2021 is Sponsored by:

Automated Watering Machine Has What Plants Crave: Fertilizer

We’ve seen countless automated plant care systems over the years, but for some reason they almost never involve the secret sauce of gardening — fertilizer. But [xythobuz] knows what’s up. When they moved into their new flat by themselves, it was time to spread out and start growing some plants on the balcony. Before long, the garden was big enough to warrant an automated system for watering and fertilizing.

This clever DIY system is based around a 5L gravity-fed water tank with solenoid control and three [jugs] of liquid fertilizer that is added to the water via peristaltic pump. Don’t worry, the water tank has float switches, and [xythobuz] is there to switch it off manually every time so it doesn’t flood the flat.

On the UI side, an Arduino Nano clone is running the show, providing the LCD output and handling the keypad input. The machine itself is controlled with an ESP32 and a pair of four-channel relay boards that control the inlet valve, the four outlet valves, and the three peristaltic pumps that squirt out the fertilizer. The ESP also serves up a web interface that mimics the control panel and adds in the debug logs. These two boards communicate using I²C over DB-9, because that’s probably what [xythobuz] had lying around. Check out the demo video after the break, and then go check on your own plants. They miss you!

Don’t want to buy just any old peristaltic pumps? Maybe you could print your own.

Remote Controlled Car Gets Active Suspension

Active suspensions are almost a holy grail for cars, adding so much performance gain that certain types have even been banned from Formula 1 racing. That doesn’t stop them from being used on a wide variety of luxury and performance cars, though, as they can easily be tuned on the fly for comfort or improved handling. They also can be fitted to remote controlled cars as [Indeterminate Design] shows with this electronic servo-operated active suspension system for his RC truck.

Each of the four servos used in this build is linked to the mounting point of the existing coilover suspension on the truck. This allows the servo to change the angle that the suspension is positioned while the truck is moving. As a result, the truck has a dramatic performance enhancement including a tighter turning radius, more stability, and the capability of doing donuts. The control system runs on an Arduino with an ESP32 to enable live streaming of data, and also includes an MPU6050 to monitor the position of the truck’s frame while it is in motion.

There’s a lot going on in this build especially with regard to the control system that handles all of the servos. Right now it’s only programmed to try to keep the truck’s body relatively level, but [Indeterminate Design] plans to program several additional control modes in the future. There’s a lot of considerations to make with a system like this, and even more if you want to accommodate for Rocket League-like jumps.

Hack a Day 15 Apr 00:00

On-Air Sign Helps Keep Your Broadcasts G-Rated

Like many of us, [Michael] needed a way to let the family know whether pants are required to enter the room — in other words, whenever a videoconference is in progress. Sure he could hang a do not disturb sign, but those are easy to forget. There’s no need to worry about forgetting to change status because this beautiful wall-mounted sign can be controlled with Alexa.

Inside the gorgeous box made from walnut, curly maple, and oak is an ESP32, some RGB LEDs, and three MOSFETs. [Michael] is using the fauxmoESP library to interface the ESP32 with Alexa, which emulates a Phillips Hue bulb for the sake of using a protocol she already knows. [Michael] can change the color and brightness percentage with voice commands.

The sign is set up as four different devices — one default, and one for each color. Since talking to Alexa isn’t always appropriate, [Michael] can also change the color of the LEDs using sliders on a website that’s served up by the ESP. Check out the full build video after the break.

Need something quick and dirty that works just as well? Our own [Bob Baddeley] made a status indicator that’s simple and effective.

A Tiny LED Matrix is Better With Friends

When we last heard from [lixielabs] he was building Nixie tube replacements out of etched acrylic and LEDs. Well he’s moved forward a few decades to bring us the Pixie, a chainable, addressable backpack for tiny LED matrix displays.

Each Pixie module is designed to host two gorgeous little Lite-On LTP-305G/HR 5×7 LED dot matrix displays, which we suspect have been impulse purchases in many a shopping cart. Along with the displays there is a small matrix controller and an ATTINY45 to expose a friendly electrical interface. Each module is designed to be mounted edge to edge and daisy chained out to 12 or more (with two displays each) for a flexible display any size you need. But to address the entire array only two control pins are required (data and clock).

[lixielabs] has done the legwork to make using those pins as easy as possible. He is careful to point out the importance of a good SDK and provides handy Arduino libraries for common microcontrollers and a reference implementation for the Raspberry Pi that should be easy to crib from to support new platforms. To go with that library support is superb documentation in the form of a datasheet (complete with dimensions and schematic!) and well stocked GitHub repo with examples and more.

To get a sense of their graphical capabilities, check out a video of 6 Pixie’s acting as a VU meter after the break. The Pixie looks like what you get when a hacker gets frustrated at reinventing LED dot matrix control for every project and decided to solve it once and for all. The design is clean, well documented, and extremely functional. We’re excited to see what comes next!

ESP32 with an I2S mic running FFT with 1024 cells, with each octave overlaid to make a 12-note chromagram, being rendered live by Pixies!https://t.co/0nWQfX0W6W pic.twitter.com/UZgh5ymWAw

— Lixie Labs (@lixielabs) September 22, 2020

Hackaday Links: September 8, 2019

We start this week with very sad news indeed. You may have heard about the horrific fire on the dive boat Conception off Santa Cruz Island last week, which claimed 33 lives. Sadly, we lost one of our own in the tragedy: Dan Garcia, author of the wildly popular FastLED library. Dan, 46, was an Apple engineer who lived in Berkley; his partner Yulia Krashennaya died with him. Our community owes Dan a lot for the work he put into FastLED over the last seven years, as many an addressable LED is being driven by his code today. Maybe this would be a good chance to build a project that uses FastLED and add a little light to the world, courtesy of Dan.

In happier news, the biggest party of the hardware hacking year is rapidly approaching. That’s right, the 2019 Hackaday Superconference will be upon us before you know it. Rumor has it that there aren’t that many tickets left, and we haven’t even announced the slate of talks yet. That’s likely to clean out the remaining stock pretty darn quickly. Are you seriously prepared to miss this? It seems like a big mistake to us, so why don’t you hop over and secure your spot before you’re crying into your Club-Mate and wondering what all the cool kids will be doing in November.

Of course one of the highlights of Superconference is the announcement of the Hackaday Prize winner. And while we naturally think our Prize is the best contest, that doesn’t mean there aren’t others worth entering. MyMiniFactory, the online 3D-printing community, is currently running a “Design with Arduino” competition that should be right up the alley of Hackaday readers. The goal is simple: submit a 3D-printed design that incorporates Arduino or other electronics. That’s it! Entries are accepted through September 16, so you’ve still got plenty of time.

Sometimes you see something that just floors you. Check out this tiny ESP32 board. It doesn’t just plug into a USB port – it fits completely inside a standard USB Type A jack. The four-layer board sports an ESP32, FTDI chip, voltage regulator, an LED and a ceramic antenna for WiFi and Bluetooth. Why would you want such a thing? Why wouldn’t you! The board is coming soon on CrowdSupply, so we hope to see projects using this start showing up in the tipline soon.

Here’s a “why didn’t I think of that?” bench tip that just struck us as brilliant. Ever had to probe a board to trace signal paths? It’s a common enough task for reverse engineering and repairs, but with increasingly dense boards, probing a massive number of traces is just too much of a chore. Hackaday superfriend Mike Harrison from “mikeselectricstuff” makes the chore easier with a brush made from fine stainless wires crimped into a ring terminal. Attached to one probe of a multimeter, the brush covers much more of the board at a time, finding the general area where your trace of interest ends up. Once you’re in the neighborhood you can drop back to probing one pad at a time. Genius! We’d imagine a decent brush could also be made from a bit of coax braid too.

Another shop tip to wrap up this week, this one for woodworkers and metalworkers alike. Raw materials are expensive, and getting the most bang for your buck is often a matter of carefully laying out parts on sheet goods to minimize waste. Doing this manually can be a real test of your spatial relations skills, so why not automate it with this cut list optimizer? The app will overlay parts onto user-defined rectangles and snuggle them together to minimize waste. The program takes any units, can account for material lost to kerfs, and will even respect grain direction if needed. It’s built for wood, but it should prove useful for sheet metal on a plasma cutter, acrylic on a laser, or even PCBs on a panel.

Library Makes ESP Over the Air Updates Easy

Potentially, one of the great things about having a device connected to the network is that you can update it remotely. However, how do you make that happen? If you use the Arduino setup for the ESP8266 or ESP32, you might try [scottchiefbaker’s] library which promises to make the process easy.

Adding it looks to be simple. You’ll need an include, of course. If you don’t mind using port 8080 and the path /webota, you only need to call handle_webota() from your main loop. If you want to change the defaults, you’ll need to add an extra call in your setup. You also need to set up a few global variables to specify your network parameters.

The only caveat is that long delay statements in your loop can block things from working and aren’t a great idea anyway. If you have them, you can replace all your delay calls with webota_delay which will stop the system from ignoring update requests.

The code started from a different online tutorial but packaged the code up nicely for reuse. To do an update, simply navigate to the device with a web browser and use the correct port number and path. From there you can upload a new binary image taken from the Arduino IDE with the export compiled binary command.

The only concern we saw was the code didn’t appear to authenticate you at all. That means anyone could load code into your ESP. That might be ok on a private network, but on the public Internet it is surely asking for trouble. The original tutorial code did have a hardcoded user and password, but it didn’t look very useful as the password was in the clear and didn’t stop you from uploading if you knew the right URL. Dropping it from the library probably makes sense, but we would want to build some kind of meaningful security into anything we deployed.

If you have a network connection, we’ve seen the same trick done with a normal Arduino with a wireless chip. You can even do it over WiFi but using an ESP8266 which you’ll then want to be able to update, too.

Hack a Day 21 Mar 09:00

Arduino Just Introduced an FPGA Board, Announces Debugging and Better Software

Today ahead of the Bay Area Maker Faire, Arduino has announced a bevy of new boards that bring modern features and modern chips to the Arduino ecosystem.

Most ambitious of these new offerings is a board that combines a fast ARM microcontroller, WiFi, Bluetooth, and an FPGA. All this is wrapped in a package that provides Mini HDMI out and pins for a PCIe-Express slot. They’re calling it the Arduino MKR Vidor 4000.

Bringing an FPGA to the Arduino ecosystem is on the list of the most interesting advances in DIY electronics in recent memory, and there’s a lot to unpack here. FPGA development boards aren’t new. You can find crates of them hidden in the storage closet of any University’s electronics lab. If you want to buy an FPGA dev board, the Terasic DE10 is a good starter bundle, the iCEstick has an Open Source toolchain, and this one has pink soldermask. With the release of the MKR Vidor, the goal for Arduino isn’t just to release a board with an FPGA; the goal is to release a tool that allows anyone to use an FPGA.

The key to democratizing FPGA development is Arduino’s work with the Arduino Create ecosystem. Arduino Create is the company’s online IDE that gives everyone the ability to share projects and upload code with Over-the-Air updates. The MKR Vidor will launch with integration to the Arduino Create ecosystem that includes a visual editor to work with the pre-compiled IP for the FPGA. That’s not to say you can’t just plug your own VHDL into this board and get it working; that’s still possible. But Arduino would like to create a system where anyone can move blocks of IP around with a tool that’s easy for beginners.

A Facelift for the Uno WiFi

First up is the brand new Arduino Uno WiFi. While there have been other boards bearing the name ‘Arduino Uno WiFi’ over the years, a lot has changed in the world of tiny radio modules and 8-bit microcontrollers over the past few years. The new Arduino Uno WiFi is powered by a new 8-bit AVR, the ATMega4809. The ATMega4809 is a new part announced just a few months ago, and is just about what you would expect from the next-generation 8-bit Arduino; it runs at 20MHz, has 48 kB of Flash, 6 kB of SRAM, and it comes in a 48-pin package. The ATMega4809 is taking a few lattices of silicon out of Microchip’s playbook and adds Custom Configurable Logic. The CCL in the new ATMega is a peripheral that is kinda, sorta like a CPLD on chip. If you’ve ever had something that could be more easily done with logic gates than software, the CCL is the tool for the job.

But a new 8-bit microcontroller doesn’t make a WiFi-enabled Arduino. The wireless power behind the new Arduino comes from a custom ESP-32 based module from u-blox. There’s also a tiny crypto chip (Microchip’s ATECC508A) so the Uno WiFi will work with AWS. The Arduino Uno WiFi will be available this June.

But this isn’t the only announcement from the Arduino org today. They’ve been hard at work on some killer features for a while now, and now they’re finally ready for release. What’s the big news? Debuggers. Real debuggers for the Arduino that are easy to use. There are also new boards aimed at Arduino’s IoT strategy.

The Future of Arduino

As you would expect in the world of embedded development, the future is IoT. Last week, Arduino announced the release of two new boards, the MKR WiFi 1010 and the MKR NB 1500. The MKR WiFi 1010 features a SAMD21 Cortex-M0+ microcontroller and a u-blox module (again featuring an ESP-32) giving the board WiFi. The MKR NB 1500 is designed for cellular networks and features the same SAMD21 Cortex-M0+ microcontroller found in the MKR WiFi 1010, but also adds a u-blox cellular module that will connect to LTE networks using Narrowband IoT, but the module does also support Cat M1 networks.

But IoT isn’t the only thing Arduino has been working on. On the leadup to the World Maker Faire this weekend, I had the opportunity to speak with Fabio Violante, CEO of Arduino, and Massimo Banzi, Co-founder of Arduino, and what I heard was remarkable. There’s going to be an update to the Arduino IDE soon, and real debugging is coming to the Arduino ecosystem. This is a significant development in Arduino’s software efforts, and when Fabio was appointed CEO last July, this was the first thing he wanted to do.

Also on deck for upcoming bits of hardware is a slow upgrade from ARM Cortex-M0 parts to Cortex-M4 parts. While this change isn’t exactly overdue, it is a direct result of the ever-increasing power of available microcontrollers. The reason for this change is the growing need for more compute power on embedded platforms, and simply the fact that more powerful chips are cheaper now.

Massimo, Fabio, and the rest of the Arduino team will be showing off their latest wares at Maker Faire Bay Area this weekend, and we will be posting updates. The FPGA Arduino — the MKR Vidor 4000 — will be on display running a computer vision demo, and there will, of course, be fancy new boards on hand. We’ll be posting updates so keep your eye on Hackaday!

Hack a Day 18 May 16:03