There are very many cool Arduino projects and project sites in Internet (make Google search to see). Here are some interesting links to check out:
Arduino Projects at indestructables
Top 40 Arduino Projects of the Web
Arduino Rising: 10 Amazing Projects People Are Doing With The Tiny Microcontroller
Electronics For The Everyman: 25 Kick Ass Arduino-Powered Projects
10 Simple-But-Fun Projects to Make With Arduino
Internet of Thing with Arduino
11 Arduino projects that require major hacking skills—or a bit of insanity
I will be posting more links to more interesting projects as comments to this post, like I did in my Cool uses for the Raspberry Pi posting. Some of the most interesting that spend some more time at can get their entire own postings this blog in Arduino section.
3,010 Comments
Tomi Engdahl says:
TinySewer – Low Power Sewer Faults Detection System
A low power vision-based sewer faults detection device using a tinyML neural network to produce highly accurate sewer faults classification.
https://create.arduino.cc/projecthub/lurst811/tinysewer-low-power-sewer-faults-detection-system-64cd67
Tomi Engdahl says:
https://electronics.stackexchange.com/questions/67092/how-much-current-can-i-draw-from-the-arduinos-pins
Tomi Engdahl says:
A VISUAL
PROGRAMMING LANGUAGE
FOR MICROCONTROLLERS
https://xod.io/
Tomi Engdahl says:
https://www.avdweb.nl/arduino/adc-dac/fast-pwm-dac
Tomi Engdahl says:
https://www.instructables.com/Rotary-Dial-Arduino-Input/
Tomi Engdahl says:
https://store.arduino.cc/products/arduino-nano-every
Tomi Engdahl says:
A team of University of Waterloo researchers developed a small pocketable display that can shine images and text through fabric.
PocketView is an LED display that shows info through clothes and other fabrics
https://blog.arduino.cc/2021/10/16/pocketview-is-an-led-display-that-shows-info-through-clothes-and-other-fabrics/
Tomi Engdahl says:
Test your aim with this laser pointer shooting game!
DIY Arduino Laser Pointer Shooting Game © GPL3+
https://create.arduino.cc/projecthub/mircemk/diy-arduino-laser-pointer-shooting-game-34510f
The object of the game is to shoot the LDR (target) under the active LED with a light beam from a laser pointer.
Tomi Engdahl says:
ARKeytar – Arduino Based MIDI Controller Keytar © CC BY-NC
https://create.arduino.cc/projecthub/andreagregorini/arkeytar-arduino-based-midi-controller-keytar-21d108
Andrea Gregorini’s ARKeytar is an Arduino-based MIDI instrument shaped as a maple wood keytar, with two softpots, a keyboard and CC controls.
Tomi Engdahl says:
Tiller Pilot for Yacht © GPL3+
Project using Arduino to steer a full-size boat on a compass heading.
https://create.arduino.cc/projecthub/autohelm/tiller-pilot-for-yacht-0498bd
Tomi Engdahl says:
This Nano Every-based timer shows how a finite state machine could be employed to make a user-friendly interface with an alphanumeric LCD display and a rotary encoder.
A User-Friendly Interface in a Simple Timer © GPL3+
https://create.arduino.cc/projecthub/frenchy22/a-user-friendly-interface-in-a-simple-timer-4419f0
Make a user-friendly interface with an alphanumeric display, a rotary encoder and a finite state machine.
Tomi Engdahl says:
Arduino Nano Floppy Emulator For When Your Disk Is Not Accessible
https://hackaday.com/2021/10/17/arduino-nano-floppy-emulator-for-when-your-disk-is-not-accessible/
Among the plethora of obsolete removable media there are some which are lamented, but it can be difficult to find those who regret the passing of the floppy disk. These flexible magnetic disks in hard plastic covers were a staple of computing until some time in the early 2000s, and their drives could be found by the crateload in any spares box. But what about today, when there’s a need for a real floppy drive and none is to be found? Enter [Acemi Elektronikci], with an Arduino Nano based floppy emulator, that plugs into the floppy port of a PC old enough to have one, and allows the easy use of virtual floppy disks.
https://github.com/acemielektron/fddEMU
Tomi Engdahl says:
Arduino Brings USB Mouse To Homebrew Computer
https://hackaday.com/2021/10/18/arduino-brings-usb-mouse-to-homebrew-computer/
When building your own homebrew computer, everything is a challenge. Ultimately, that’s kind of the point. If you didn’t want to really get your hands dirty with the nuts and bolts of the thing, you wouldn’t have built it in the first place. For example, take the lengths to which [rehsd] was willing to go in order to support standard USB mice on their 6502 machine.
The idea early on was to leverage existing Arduino libraries to connect with a standard USB mouse, specifically, the hardware would take the form of an Arduino Mega 2560 with a USB Host Shield. There was plenty of code and examples that showed how you could read the mouse position and clicks from the Arduino, but [rehsd] still had to figure out a way to get that information into the 6502.
In the end, [rehsd] connected one of the digital pins from the Arduino to an interrupt pin on the computer’s W65C22 versatile interface adapter (VIA).
Admittedly, [rehsd] says the mouse action is far from perfect. But as you can see in the video after the break, it’s at least functional.
Tomi Engdahl says:
Laser Pointer And Arduino Make A Minimalistic Shooting Game
https://hackaday.com/2021/10/18/laser-pointer-and-arduino-make-a-minimalistic-shooting-game/
Video games are great and all, but sometimes you just want the thrill of manipulating actual objects in addition to watching action on a screen. This must have been the reason why Nintendo’s Duck Hunt became so popular despite the simplicity of its gameplay. Prolific hacker [mircemk] similarly made a computer-plus-physical game called “Laser Shooter“, which somehow reminds us of the good old NES game.
The game is based on an Arduino Nano, to which five LEDs as well as five photoresistors (LDRs) are connected. When the game is started, the LEDs light up at random and the player has a limited time to “shoot” the corresponding LDR with a laser pointer. This time limit is decreased as the game progresses, and the game is over once the player fails to hit the target on time. The “Game Over” message is accompanied by a sad tune, but luckily no giggling dog.
DIY Arduino Laser pointer Shooting Game
https://hackaday.io/project/182210-diy-arduino-laser-pointer-shooting-game
You need to shoot as many targets as possible. You get one point and one more shot for each destroyed Target
Tomi Engdahl says:
Audio Tape Interface Revives Microcassettes As Storage Medium
https://hackaday.com/2021/10/20/audio-tape-interface-revives-microcassettes-as-storage-medium/
In the early 1980s cassette tapes were the standard storage medium for home computer users; readers of a certain age will remember fiddling with audio jacks, tape counters and signal levels, then waiting for several minutes while a program (hopefully) loaded correctly. While most people happily upgraded to much more reliable floppy disks, [Zack Nelson] decided to go back in time and add a suitably classic storage medium to a retrocomputing project, in the form of a cassette interface. The cassette player he had available was a Pearlcorder L400, which uses the smaller microcassette instead of the familiar audio tapes used in your Walkman or boombox.
[Zack] designed the entire thing from the ground up: first he decided to use differential Manchester encoding, which provides immunity against common disturbances like speed variations (which cause wow and flutter). The data is encoded in the frequency range from 1 kHz to 2 kHz, which suits the bandwidth of the cassette player.
Storing data on a cassette using Arduino and Python (Differential Manchester encoding)
https://zeninstruments.blogspot.com/2021/10/manchester-decoder-and-cassette.html
Another limitation is frequency response. Our signal has to stay safely within the range of frequencies a tape can reproduce. This range can be as narrow as 400-4,000Hz for something like a microcassette. We could send a stream of bits at a safe 2kHz, but what if we then have a very long run of all zeros (or ones)? Our signal would dip below 400Hz, and our data would be lost.
One solution is to toggle our output at least once per bit. Two bits would give a full cycle and guarantee a minimum frequency of 1kHz. The presence of an additional toggle can represent a zero, and its absence a one. If every bit had an additional toggle, it would yield the maximum frequency of 2kHz. This is the basis of Differential Manchester encoding.
Besides it fitting nicely in a frequency range, Manchester has other advantages. Cassette recorders rarely concern themselves with the polarity of their signal (since it doesn’t affect the sound) and will sometimes invert their output relative to their input. Manchester encoding only uses the presence of these “toggles” or edges, and is unaffected by being inverted.
Also, each bit spends an equal amount of time high and low. This means we have no DC offset. If the offset were irregular, our signal would drift up and down, making decoding more difficult.
Tomi Engdahl says:
The Quadrivium EnsembleBot Is A Labour Of Love
https://hackaday.com/2021/10/19/the-quadrivium-ensemblebot-is-a-labour-of-love/
The Quadrivium EnsembleBot project is a mashup between old school musical instruments and the modern MIDI controlled world. Built by a small team over several years, these hand crafted instruments look and sound really nice.
The electronics side of things is taken care of with a pile of Arduinos and off-the-shelf modules, but that doesn’t mean the design isn’t well thought through, if a little more complicated than it could be in places. Control is taken care of with a PC sending commands over the USB to an Arduino 2560. This first Arduino is referred to as the Master Controller and has the immediate job of driving the percussive instruments as well as other instruments that are struck with simple solenoids. All these inductive loads are switched via opto-isolators to keep any noise generated by switching away from the microcontroller.
https://ensemblebot.quadrivium.dk/
Tomi Engdahl says:
Make music with your Arduino by hooking it up to one of these DIY MIDI instruments!
(via MUO)
https://www.makeuseof.com/best-arduino-midi-projects-for-beginners/
Tomi Engdahl says:
“Mechanical” VU Meter © GPL3+
https://create.arduino.cc/projecthub/marcocroce/mechanical-vu-meter-546391
A simple VU meter realized with only mechanical typical items, as screws or nuts, but powered by Arduino!
“Mechanical” VU Meter
I have always been attracted by VU Meters, in fact at home I had designed a system to listen to music using my father’s old A/V mixer equipped with 2 VU meters, the first one for the left audio channel and the second one for the right audio channel. One day, suddenly, the mixer stopped working, so I decided to make a VU meter myself using Arduino…
Tomi Engdahl says:
https://makezine.com/2021/10/21/core-memory-why-we-used-60-year-old-tech-in-an-arduino-shield/
Tomi Engdahl says:
Cabletester using ADS1115 and a TDR
https://forum.arduino.cc/t/cabletester-using-ads1115-and-a-tdr/577549
Hi Lads,
Im building a cabeltester for RG58 cable, using a TDR (74AC14) and for making the Threshold im using the ADS1115.
The Idea is to messure the lenght of a cable by messuring the reflection of the square wave.
my issue is the code, and the knowlegde, if the Arduino isn’t powerful enough to detect the reflection.
im putting the upper and lower threshold in the area where the reflected signal is.
Then theoretical i have the fist pulsetime and the second pulsetime, minus second from the first i have “delta” t. lets say 120ns devided by two = 60ns (a cable length) times 0.2 = 12m cable.
if anyone have solved this, please let me know :slight_smile: Attaching my first version of the code.
You need some extra hardware designing and building in order to make a Time Domain Reflectometer, you can’t just connect a 74AC14 to an Arduino and expect to get meaningful results.
The reason for this is that you need to be able to measure time in nanoseconds (=10-9s), whereas an Arduino can only directly measure time in microseconds (=10-6s).
One clock pulse of a 16MHz Arduino is 62.5ns, a pulse travels a long way down a cable in that time. (around 12m, ie 6m there and 6m back, allowing for the velocity factor of the cable), so you can only directly measure cable lengths in multiples of that distance.
m guessing that the time between the pulse and reflection is so short, that its impossible to use a Arduino.
my test shows also that as shorter the cable is, as more difficult it is to messure (it’s logic)
As i understand, i would say your calculation that you are writing is incorrect. The time between the pulse will show 120ns (24m = 60ns forward, 60ns back) so the code for that part will be ((PulseInterval/2)*0.2) = 12m
VP (Velocity Propagation) of RG-58 is 66%.
I think most coax cables are around that mark.
There will ofcourse only be a reflection if the other end is not properly terminated (52ohm).
If you overlay an original and a reflected pulse, they overlap perfectly at zero travel time, and the longer the travel time, the less overlap. That overlap can be determined by a simple logic AND (or OR…) gate and the width of that pulse gives the time to the line break (or short). With a continuous square wave signal you get a PWM (duty cycle) representation of the distance.
I built a TDR 5 using a ACAM GP22 for measuring Triax camera cables and the results (see #87 of thread) were very good.
TDR (Time-domain reflectometer) concept. On the right track?
https://forum.arduino.cc/t/tdr-time-domain-reflectometer-concept-on-the-right-track/179362
I have been thinking about building a [TDR](http://Time-domain 18 reflectometer) using arduino and have the basics of an idea that needs some help in fleshing out the details or (nicely) shooting it down in flames.
The basic principle is somewhat based on this 13 article but instead of using a PIC and it’s CTMU to measure the reflection time I was hoping to improve accuracy using a high speed oscillator connected to a binary/ripple counter.
The principle is to use the arduino to reset the counter and send a pulse down the output. One comparator (IC3) will trigger the counter to start when the voltage gets to about 1/4 range and the other comparator (IC2) will stop the counter at 3/4 range caused by the reflection. The arduino will then read the counter and determine how many clock cycles have happened between the two and work out the length of the cable.
I have knocked up a basic circuit idea (attached) but it is a bit vague on some details like oscillator, resistors & capacitors and the negative VEE voltages.
The ripple counter (SY10E137) will run at 2GHz+ but I have not found a cheap oscillator to work at this speed so currently have just drawn a basic crystal for it’s input. The SY10E137 is an 8 bit counter so it Q7 output frequency will be about 7.8MHz (?) if it’s input is 2GHz and I may need another binary counter to slow this further so an arduino interrupt pin can count it easily.
Obviously the faster I can clock the counter at the more accurate the device would be. At 2GHz I’m hoping to measure a distance to an accuracy of >100mm
The questions are…
Will it/should it/could it work in principle.
Any ideas about a (budget) way to generate a 2GHz clock for the counter.
That’s a nice idea, but generating the 2GHz signal is likely to be difficult. I think the usual approach would be to start with a crystal oscillator at a lower frequency (e.g. 250MHz) and use a VCO and divider configured as a PLL to multiply it up to 2GHz.
At 2GHz, your counter will overflow in 128ns, which means that the maximum length of cable you can handle may be as low as 10m, depending on the type of cable. The 7.8MHz output from the counter is probably too fast to count on the Arduino.
I’ve been looking at making an Arduino-based TDR too, although not with such high resolution. My plan was to get course resolution (50ns) by clocking the mcu at 20MHz and using the Timer 1 input capture facility to record the count when the reflected pulse arrives (so no external counter needed). Then I was going to use a programmable delay line to provide about 0 to 45ns delay to the outgoing pulse in 5ns steps, thereby increasing the resolution to 5ns, which is about 0.5m of cable length. You could do something similar but using higher frequencies, e.g. run the counter at 200MHz to get 5ns course resolution, and use a programmable delay line to get fine resolution.
This one http://uk.farnell.com/on-semiconductor/mc100ep196fag/ic-delay-line-programmable/dp/1703312 18 provides up to 10ns delay in 10ps increments, giving you a theoretical resolution of around 1mm, although in practice the resolution will be limited by jitter.
Two more things to bear in mind:
The sign of the reflected pulse depends on whether the cable has a break or a short. So you may need a third comparator, or extra logic to switch the second comparator between looking for positive or negative reflected pulses.
Unless the cable is designed for high frequencies, the reflected edge is not as sharp as the transmitted edge. So the delay you measure will depend on the comparator threshold. My design uses a variable comparator threshold (by using one of the PWM pins as a cheap DAC) so that the mcu can look for the start of the pulse.
EDIT: I just discovered the Maxim DS1023S-25+ delay line. This can give me up to 63.75ns delay in 0.25ns increments. So I may be able to achieve the sort of resolution you are looking for, without needing a high speed counter.
I’ve got my low-resolution TDR working now. I’m using a single comparator to detect both positive and negative reflections, with the reference input fed from a PWM pin feeding a low-pass filter. The software sets the reference input voltage, allows it to settle, starts timer 1, and sends a pulse into the cable. The comparator output is fed to the ICP1 pin, so that when a reflection is detected, the time of the reflection is captured in ICR1. This is repeated while ramping up the reference voltage, so that the software can look for positive steps in the voltage at the end of the cable. Then it ramps the voltage down, looking for negative steps. From the number and amplitude of the steps found, it can distinguish between no cable connected, short circuit at cable terminals, cable open circuit at (distance), cable short circuit at (distance), and cable correctly terminated (i.e. no reflections).
The biggest problem was stopping the comparator oscillating. It really wanted to oscillate at about 200MHz. The datasheet warns about the importance of good layout, and I was prototyping on a breadboard, so I guess it isn’t too surprising. Eventually, the combination of putting a decoupling capacitor right on the SMD adapter, keeping the output away from the input, grounding unused breadboard rows, and adding a large amount of hysteresis solved the problem. It should be much easier on a PCB.
The resolution is currently only 62.5ns (about 6.4m for cat5 cable) because I am using a 16MHz Arduino for prototyping. Next step is to add an LCD display, and programmable delay line between the mcu and R1 to increase the resolution. I have a DS1023S-25+ on order, which will theoretically provide 0.25ns resolution, although I expect that jitter will reduce that.
Here is the code.
Riva: Maybe a job for a Duo?
I’m not familiar with the Due, however if I read the processor datasheet correctly, then with the processor running at 84MHz, the fastest I can clock the timer/counters is 42MHz. So without the delay line, it would offer a bit more than twice the resolution of a 20MHz atmega328 without the delay line. If I clocked the Due processor at a slower speed direct from the crystal oscillator, then I think I could clock the timers at up to 96MHz and get better resolution. However, the power consumption of the Due is much higher than for the atmega328p, so battery operation would be less practical. I am hoping to run this from a 9V battery.
Riva: What is the shortest cable you can measure?
Since my resolution is currently about 6.4m, this ought to be 6.4m. I connected a piece of 5.5m coax and observed on the oscilloscope that the reflected step is about 60ns later that the transmitted step. Since the reflected step has slower rise time than the transmitted step, the software is reading 5 clocks to the first (transmitted) step and 6 clocks to the second (reflected) step. However, due to quantization, the pattern (5,5,5,5…5,5,6,6,6,…..) could be generated from either a two steps about 62.5ns apart, or a single step of twice the amplitude and slower rise time. So the software records it as a single step, and the shortest distance I can measure an open circuit cable is about 12m. Maybe I should modify the software to assume that the outgoing step always has a fast rise time, then I could detect a second step only 1 clock later. When I have the programmable delay, it should be easier to distinguish between two steps close together.
In fact, with a 5.5m cable, the software tells me I have an open circuit at 12m, because it registers a step due to the second reflection (it is 75 ohm coax and I am driving it from 150 ohms, so some of the incoming reflection is reflected back again).
Short circuit are easier to measure, because the reflected step has opposite polarity, so it can’t be confused with the outgoing step. The software are is correctly diagnosing a 5.5m shorted cable.
PS – I’ve now decided to connect the programmable delay line between the comparator output and the ICP1 microcontroller input, because it saves me having to add a buffer to drive the cable. I’ll probably change to using 2 output pins in parallel to drive the cable, so that I can use a lower drive resistor than 150 ohms.
I use TDR a fair bit when using low voltage and high voltage cable fault location equipment on distribution networks.
I never even considered it as something that could be done based on Arduino/AVR uC.
Watching what you guys are doing with interest to see what you come up with.
Just a quick update on this…
I have abandoned the ideal of using high speed counters due to the complexity of designing/managing 2GHz signals. I have since discovered TDC 4 chips that do all the counting for me and give the results over SPI interface.
The device is an ACAM GP22 TDC 13.
The resolution should also be better as we are talking >90ps and a measurement range up to 2.4us (more than enough for the length of cables I’m interested in) and possibly 4ms. I’m now waiting on PCB’s to knock together a test rig (if I can figure out how to solder a 5mm square QFN32 package). The attached drawing shows an UNO but if I uses a 3.3V arduino instead I should be able to reduce the component count.
I’m just back from holiday. The TDC-GP22 is an interesting chip! Please let us know how you get on.
Riva: How do you expect to generate the graph as the resolution far exceeds arduino ADC sample rates.
I will be relying on the assumption that for every pulse the Arduino generates, the signal appearing on the cable (comprising the transmitted + reflected signal) will be the same. By sending a lot of pulses and changing the comparator reference voltage and/or delay line time between pulses, I can build up a graph of the signal. As I will only be capturing the first transition of the comparator, at most I can construct the signal graph as far as one maximum and one minimum. Even that limitation could be overcome by delaying the start of the timer 1 clock signal from the start of the pulse.
What resolution do you require? You will find several different approaches described earlier in this thread, including:
My very simple TDR using an Arduino and a high-speed comparator. Resolution is limited to 62.5ns (about 15 to 30 feet depending on cable type) using a standard 16MHz Arduino, although by migrating the design to a 20MHz standalone atmega328p, you could improve this to 50ns (about 12.5 to 25 feet).
A modification to my TDR design which adds a variable delay line, improving the resolution to 1ns or better.
Riva’s idea for a TDR using the GP22 chip. This is a very nice looking chip and should provide very high resolution.
My TDR design uses a step function, not a pulse. The advantage is that there is only one edge to be reflected and detected. If you use a pulse, then you need to try to work out whether each of the received steps are reflections of the leading or the trailing edge of the pulse.
Tomi Engdahl says:
Never Lose a Payload Again with the R2Home GPS-Guided Recovery System
By utilizing GPS and active maneuvering, this device ensures a high-altitude payload will land exactly where specified.
https://www.hackster.io/news/never-lose-a-payload-again-with-the-r2home-gps-guided-recovery-system-bd14286b3072
Tomi Engdahl says:
PWM to voltage module 0%-100! %PWM is converted to 0-10V voltage
https://www.aliexpress.com/item/1005002270563907.html
Tomi Engdahl says:
Light Deck is a MIDI Lightroom controller
https://blog.arduino.cc/2021/10/21/light-deck-is-a-midi-lightroom-controller/
Tomi Engdahl says:
The World’s Cheapest Infrared Camera Produces Images Pixel-by-Pixel for Just $11
https://www.hackster.io/news/the-world-s-cheapest-infrared-camera-produces-images-pixel-by-pixel-for-just-11-83b00a12c7ac
This unique system uses a single infrared sensor to take pictures at a blistering rate of 0.0002 fps while remaining very cheap to build.
Tomi Engdahl says:
This Arduino Terminal Does All The Characters
https://hackaday.com/2021/10/23/this-arduino-terminal-does-all-the-characters/
The job of a dumb terminal was originally to be a continuation of that performed by a paper teletype, to send text from its keyboard and display any it receives on its screen. But as the demands of computer systems extended beyond what mere ASCII could offer, their capabilities were extended with extra characters and graphical extensions whose descendants we see in today’s Unicode character sets and thus even in all those emojis on your mobile phone. Thus a fully-featured terminal has a host of semigraphics characters from which surprisingly non-textual output can be created. It’s something [Michael Rule] has done some work on, with his ILI9341TTY, a USB serial terminal monitor using an Arduino Uno and an ILI9341 LCD module that supports as many of the extended characters as possible.
https://github.com/michaelerule/ILI9341TTY
Tomi Engdahl says:
An Arduino With A Floppy Drive
https://hackaday.com/2021/04/30/an-arduino-with-a-floppy-drive/
For many of us the passing of the floppy disk is unlamented, but there remains a corps of experimenters for whom the classic removable storage format still holds some fascination. The interface for a floppy drive might have required some complexity back in the days of 8-bit microcomputers, but even for today’s less accomplished microcontrollers it’s a surprisingly straightforward hardware prospect. [David Hansel] shows us this in style, with a floppy interface, software library, and even a rudimentary DOS, for the humble Arduino Uno.
https://github.com/dhansel/ArduinoFDC
Tomi Engdahl says:
https://techatronic.com/mobile-phone-control-spy-robot-project/
Tomi Engdahl says:
https://hackaday.com/2021/10/23/this-arduino-terminal-does-all-the-characters/
Tomi Engdahl says:
APAN – Arduino Privacy Automatic Navigator © GPL3+
What to confuse your ISP and have some privacy? Install APAN in your private network!
https://create.arduino.cc/projecthub/cstram/apan-arduino-privacy-automatic-navigator-0c7c85
Tomi Engdahl says:
https://hackaday.com/2015/04/24/review-transistor-tester/
Tomi Engdahl says:
Move! makes burning calories a bit more fun
https://blog.arduino.cc/2021/10/25/move-makes-burning-calories-a-bit-more-fun/
Tomi Engdahl says:
https://blog.arduino.cc/2021/10/26/arduino-device-trains-bmw-drivers-to-use-turn-signals/
Tomi Engdahl says:
https://blog.arduino.cc/2021/10/04/the-graffomat-is-a-giant-plotter-that-automates-graffiti-art/
Tomi Engdahl says:
DIY WS2812 Analog Style Arduino Ring Clock © GPL3+
This is an analog-style digital clock with multiple display states, a 24-hour alarm, a countdown alarm, multiple alarm display states…
https://create.arduino.cc/projecthub/mircemk/diy-ws2812-analog-style-arduino-ring-clock-f58ba6
Tomi Engdahl says:
How to build and test Arduino Self Driving car in 5 minutes.
Learn Everything about Self Driving Car in 5 Minutes !
https://m.youtube.com/watch?v=8zi6sID5EQU&t=9s
Tomi Engdahl says:
We have guides, tutorials and examples you can follow that help you get to know the Arduino Pro Portenta H7 range. Everything you need to get started with our most powerful family of devices, over on Arduino Docs: https://docs.arduino.cc/hardware/portenta-h7
Tomi Engdahl says:
Arduino-Based Universal AC Motor Speed Controller © GPL3+
Closed loop universal motor control system using PID algorithm.
https://create.arduino.cc/projecthub/saulius-bandzevicius/arduino-based-universal-ac-motor-speed-controller-a4ceaf
Tomi Engdahl says:
Tired of doing it manually, Jason Reposa decided to create an automated seltzer bottle filling and capping line using Arduino and other off-the-shelf parts. The system can also be adapted for just about any liquid, including beer, wine and kombucha: youtu.be/BcnttLYL4T4 (Part 2) / youtu.be/DvNhkyJ3Bsc (Part 1)
Tomi Engdahl says:
how to make mini oscilloscope, using Arduino nano ,dfrobot
https://www.youtube.com/watch?v=v6sXNLbN14I
kuinka tehdä elektronisten komponenttien testeri Arduino nano, dfrobot -ohjelmalla
https://www.youtube.com/watch?v=zfHch91QRWI
Tomi Engdahl says:
https://blog.arduino.cc/2021/11/03/learn-how-to-build-your-own-massive-3d-printed-cnc-router/
Tomi Engdahl says:
Reproduce the Color of Any Object in Paint with This Novel Color Maker
After making a quick scan of an object’s color, this device can accurately reproduce it by mixing paint in the required quantities.
https://www.hackster.io/news/reproduce-the-color-of-any-object-in-paint-with-this-novel-color-maker-58d94edf2c83
Tomi Engdahl says:
Connect a USB Keyboard with an Arduino © MIT
Ever thought about interfacing a USB keyboard with an Arduino in one of your projects? In fact, it is easier than you might think.
https://create.arduino.cc/projecthub/michalin70/connect-a-usb-keyboard-with-an-arduino-50c077
Tomi Engdahl says:
**DIY Big Arduino VU Meter on 40×2 LCD Dispaly**
A volume unit (VU) meter is a device displaying a representation of the signal level in audio equipment. The advantages of this device are that it is easy to build,and there is fairly accurate representation of sound level.
Detailed video description, schematic and code at:
https://youtu.be/cTdNuC8ql4o
Tomi Engdahl says:
Visualizing Audio With An LCD VU Meter
https://hackaday.com/2021/11/08/visualizing-audio-with-an-lcd-vu-meter/
Most recently, we’ve seen VU meters circle back around to have a bit of a retro vibe in this awesome Arduino-controlled LCD VU meter built by [mircemk]. Based on the KTAudio VU Meter project, it features an ultra-wide LCD, audio input, and volume knob, all tidily wrapped up in a case whose color scheme that can only conjure images of the famed Altair 8800, or an old Tektronix oscilloscope. The LCD itself is fairly responsive — but you can judge for yourself in the video below. The signature fading that so commonly accompanies screen refreshes on LCDs such as this one really adds to the retro effect.
DIY Big Arduino VU Meter on 40×2 LCD Dispaly
The advantages of this device are that it is easy to build, and there is a fairly accurate representation of sound level.
https://hackaday.io/project/182518-diy-big-arduino-vu-meter-on-40×2-lcd-dispaly
Tomi Engdahl says:
Bicycle Journey Tracker With Arduino and GPS Module
https://www.instructables.com/Bicycle-Journey-Tracker-With-Arduino-and-GPS-Modul/
This is a bicycle journey recording device utilizing Arduino and a GPS module.
I’m riding an electrical bicycle from time to time during weekends.
Several good bicycle riding routes which pass by the lakes and parks are located near to my house.
Therefore, bicycle riding become a favorite personal pastime recently.
For planning the next journey, checking previous riding history becomes very useful and important.
When GPS-based detail route information is available, a more customized and well-organized next bicycle riding journey plan can be made.
Usually, I had just passed by must to visit places such as good places to take a picture or nice restaurants where I can enjoy some special eateries.
Tomi Engdahl says:
https://hackaday.com/2021/11/10/arduino-piano-tuner-is-pitch-perfect/
Tomi Engdahl says:
https://hackaday.com/2021/11/02/hedgehog-gesture-sensor-built-with-cheap-time-of-flight-modules/
Tomi Engdahl says:
DIY Arduino Drawing/Writing Machine – 2D Pen Plotter
https://m.youtube.com/watch?v=WgsTyhX311E&feature=youtu.be
Tomi Engdahl says:
https://hackaday.com/2021/11/16/binaural-hearing-modeled-with-an-arduino/
Tomi Engdahl says:
NTP, Rust, And Arduino Make A Phenomenal Frequency Counter
https://hackaday.com/2021/11/17/ntp-rust-and-arduino-make-a-phenomenal-frequency-counter/
Making a microcontroller perform as a frequency counter is a relatively straightforward task involving the measurement of the time period during which a number of pulses are counted. The maximum frequency is however limited to a fraction of the microcontroller’s clock speed and the accuracy of the resulting instrument depends on that of the clock crystal so it will hardly result in the best of frequency counters. It’s something [FrankBuss] has approached with an Arduino-based counter that offloads the timing question to a host PC, and thus claims atomic accuracy due to its clock being tied to a master source via NTP. The Rust code PC-side provides continuous readings whose accuracy increases the longer it is left counting the source. The example shown reaches 20 parts per billion after several hours reading a 1 MHz source.
Arduino Nano frequency counter with atomic clock accuracy
https://github.com/FrankBuss/frequencycounter
With this project you can measure a frequency from less than 1 Hz to about 6.4 MHz, with atomic clock accuracy (fclk_I_O / 2.5 according to the datasheet, which is 16 MHz / 2.5 = 6.4 MHz, but 7.5 MHz still works, but might miss some counts then sometimes). All you need for it is your computer, and an Arduino Nano, which you can get for less than five dollars at eBay.
The idea is that the Arduino counts pulses, and then a program on your computer calculates the frequency. If your computer is synchronized to a NTP time server (this is standard nowadays for most operating systems), it has a very accurate time. The USB connection and operating system introduces some inaccuracies and latencies, but the longer the program runs, the more accurate the measurement gets.