arduino

2943 Articles

Open Source Electric Vehicle Charging

April 6, 2021 by 26 Comments

Electric vehicles are becoming more and more common on the road, but when they’re parked in the driveway or garage there are still some kinks to work out when getting them charged up. Sure, there are plenty of charging stations on the market, but they all have different features, capabilities, and even ports, so to really make sure that full control is maintained over charging a car’s batteries it might be necessary to reach into the parts bin and pull out a trusty Arduino.

This project comes to us from [Sebastian] who needed this level of control over charging his Leaf, and who also has the skills to implement it from the large high voltage switching contactors to the software running its network connectivity and web app. This charging station has every available feature, too. It can tell the car to charge at different rates, and can restrict it to charging at different times (if energy is cheaper at night, for example). It is able to monitor the car’s charge state and other information over the communications bus to the vehicle, and even has a front-end web app for monitoring and controlling the device.

The project is based around an Arduino Nano 33 IoT with all of the code available on the project’s GitHub page. While we would advise using extreme caution when dealing with mains voltage and when interfacing with a high-ticket item like an EV, at first blush the build looks like it has crossed all its Ts and might even make a good prototype for a production unit in the future. If you don’t need all of the features that this charging station has, though, you can always hack the car itself to add some more advanced charging features.

Continue reading “Open Source Electric Vehicle Charging” →

Honey, I Shrunk The Arduino Core

April 5, 2021 by 69 Comments

High-level programming languages do a great job of making a programmer’s job easier, but these languages often leave a lot of efficiency on the table as a compromise. While a common thought is to move into a lower-level language like assembly to improve on a program’s speed or memory use, there’s often a lot that can be done at the high level before resorting to such extremes. This, of course, is true of the Arduino platform as well, as [NerdRalph] demonstrates by shrinking the size of the Arduino core itself.

[NerdRalph] had noticed that the “blink” example program actually includes over 1 kB of extraneous code, and that more complicated programs include even more cruft. To combat this issue, he created ArduinoShrink, which seeks to make included libraries more modular and self-contained. It modifies some of the default registers and counters to use less memory and improve speed, and is also designed to improve interrupt latency as well by changing when the Arduino would otherwise disable interrupts.

While there are some limits to ArduinoShrink, such as needing to know specifics about the pins at compile time, for anyone writing programs for Arduinos that are memory-intensive or need improvements in timing, this could be a powerful new tool. If you’d prefer to go in the opposite direction to avoid ever having to learn C or assembly, though, you can always stick with running Python on your embedded devices.

Ultrasonic Sonar Detects Hidden Objects

April 2, 2021 by 14 Comments

While early scientists and inventors famously underestimated the value of radar, through the lens of history we can see how useful it became. Even though radar uses electromagnetic waves to detect objects, the same principle has been used with other propagating waves, most often sound waves. While a well-known use of this is sonar, ultrasonic sensors can also be put to use to make a radar-like system.

This ultrasonic radar project is from [mircemk] who uses a small ultrasonic distance sensor attached to a rotating platform. A motor rotates it around a 180-degree field-of-view and an Arduino takes and records measurements during its trip. It interfaces with an application running on a computer which shows the data in real-time and maps out the location of all of the objects around the sensor. With some upgrades to the code, [mircemk] is also able to extrapolate objects hidden behind other objects as well.

While the ultrasonic sensor used in this project has a range of about a meter, there’s no reason that this principle couldn’t be used for other range-finding devices to extend its working distance. The project is similar to others we’ve seen occasionally before, but the upgrade to the software to allow it to “see” around solid objects is an equally solid upgrade.

Nixie Shot Timer Adds Useful Elegance To Espresso Machine

March 26, 2021 by 11 Comments

Once you’ve ground the beans and tamped the grounds just so, pulling the perfect shot of espresso comes down to timing. Ideally, the extraction should last 20-30 seconds, from the first dark drips to the tan and tiger-striped crema on top that gives the espresso a full aftertaste.

[Marco] has a beautiful espresso machine that was only missing one thing: an equally beautiful shot timer with a Nixie tube display. Instead of messing with the wiring, [Marco] took the non-invasive approach and is using a DIY coil to detect the magnetic field of the espresso machine’s pump and start a shot timer.

An LM358-based op-amp magnifies the current induced by the machine and feeds it to an Arduino Nano, which does FFT calculations. [Marco] found a high-voltage interface driver to switch 170 V to the Nixies instead of using two handfuls of transistors. Grab yourself a flat white and check it out after the break.

The last Nixies may have been mass-produced in the 1980s, but never fear — Dalibor Farny is out there keeping the dream alive and making new Nixies.

Continue reading “Nixie Shot Timer Adds Useful Elegance To Espresso Machine” →

Arduino CLI For I/O Pin Testing

March 21, 2021 by 12 Comments

Need to quickly toggle or read some logic signals without the hassle of writing a quick program? [Thor_x86], aka [Eric], built an Arduino sketch that does just that — and he threw in the ability to send (or receive) serial messages, too. This is a neat idea — kind of a simplified Bus Pirate.

We should warn you that this is an early release, and there are a few minor issues which we are sure [Eric] will iron out soon. We discovered the function strtol() was misspelled in cmd_send.cpp, and there are some configuration #defines which need to be sorted out in file parsePin.cpp, depending on which Arduino module you are running. We got it running on an Arduino Leonardo the quickest, because it has support for Serial1().

Don’t be discouraged by these glitches in this rev 0 deployment — [Eric] has really made quite a nice tool here. Check his GitHub repository for updates (or submit corrections yourself). All in all, it’s a good addition to your digital tool box. On a completely unrelated note, we really like [Eric]’s USB cable with the right-angle micro connector, grungy though it may be.

Besides the standard tools like Bus Pirate, GreatFET, FTDI modules, etc., are there any similar tools you like to use for bit banging and serial testing? Let us know in the comments below.

Arduino And FPGA Done Differently

March 21, 2021 by 37 Comments

FPGA guru [Max Maxfield] recently took a look at the XLR8 (pronounced accelerate) board from a company called Alorium. On the surface, it looks like another Arduino UNO clone. But instead of a CPU, it contains an Intel MAX10 FPGA that runs a softcore AVR processor. Of course, that’s only part of the story. If the board was just a mock Arduino using an FPGA, that’s not very interesting for practical purposes. However, by incorporating accelerator blocks or XBs, you can add FPGA modules to the soft CPU. [Max] shows an example that you can see in the video below where an FPGA block controls servos more easily than a standard Arduino. There’s also a version that looks like an Arduino Nano, but can clock much faster as well as use the XBs.

In addition to prebuilt XBs, there is a workflow to build your own if you are familiar with working with FPGAs. The products aren’t exactly new, but we enjoyed [Max’s] take on the product. We also appreciated the simple code examples showing exactly how you would convert a program to use the accelerated functions. Continue reading “Arduino And FPGA Done Differently” →

Negative Reinforcement: Drill Bits Edition

March 20, 2021 by 21 Comments

In theory, it’s fun to have a lot of toys tools around, but the sad reality is that it’s only as fun as the organization level applied. Take it from someone who finds organization itself thrilling: it really doesn’t matter how many bits and bobs you have, as long as there’s a place for everything and you put away your toys at the end of the day.

[Cranktown City] is always leaving drill bits lying around instead of putting them back in their bit set boxes. Since he responds well to yelling, he decided to build an intelligent drill bit storage system that berates him if he takes one out and doesn’t put it back within ten minutes.

But [Cranktown City] did much more than that. The system is housed in a really nice DIY stand that supports his new milling and drilling machine and has space to hold a certain type of ubiquitous red tool box beneath the drill bits drawer.

All the bits now sit in a 3D-printed index that fits the width of the drawer. [Cranktown City] tried to use daisy-chained pairs of screws as contacts behind each bit that could tell whether the bit was home or not, but too much resistance interfered with the signal. He ended up using a tiny limit switch behind each bit instead. If any bit is removed, the input signal from the index goes low, and this triggers the Arduino Nano to do two things: it lights up a strip of red LEDs behind the beautiful cut out letters on the drawer’s lip, and it starts counting upward. Every ten minutes that one or more bits are missing, the drawer complains and issues ad hominem attacks. Check out the demo and build video after the break, but not until you put your tools away. (Have you learned nothing?)

Okay, so how do you deal with thousands of jumbled drill bits? Calipers and a Python script oughta do it.

Continue reading “Negative Reinforcement: Drill Bits Edition” →