The Linux Foundation is a non-profit organization that sponsors the work of Linus Torvalds. Supporting companies include HP, IBM, Intel, and a host of other large corporations. The foundation hosts several Linux-related projects. This month they announced Zephyr, an RTOS aimed at the Internet of Things.
The project stresses modularity, security, and the smallest possible footprint. Initial support includes:
Arduino 101
Arduino Due
Intel Galileo Gen 2
NXP FRDM-K64F Freedom
The project (hosted on its own Website) has downloads for the kernel and documentation. Unlike a “normal” Linux kernel, Zephyr builds the kernel with your code to create a monolithic image that runs in a single shared address space. The build system allows you to select what features you want and exclude those you don’t. You can also customize resource utilization of what you do include, and you define resources at compile time.
By default, there is minimal run-time error checking to keep the executable lean. However, there is an optional error-checking infrastructure you can include for debugging.
The API contains the things you expect from an RTOS like fibers (lightweight non-preemptive threads), tasks (preemptively scheduled), semaphores, mutexes, and plenty of messaging primitives. Also, there are common I/O calls for PWM, UARTs, general I/O, and more. The API is consistent across all platforms.
You can find out more about Zephyr in the video below. We’ve seen RTOS systems before, of course. There’s even some for robots. However, having a Linux-heritage RTOS that can target small boards like an Arduino Due and a Freedom board could be a real game changer for sophisticated projects that need an RTOS.
Hackaday reader [Jan Ostman] has been making microcontroller-based DIY synthesizers for quite a while now. Recently, he’s opened up the source for a lot of them so that you can play along at home. All of these virtual-analog synths and soundmakers can be realized on an Arduino or AVR ATmega328 if you happen to have one lying around.
Extra parts like a keyboard, some pushbuttons, or some potentiometer knobs to twiddle won’t hurt if you’d like to make something more permanent or more obviously playable, like [Jan] does. On the other hand, if you’d just like to get your feet wet, I’ve tweaked his code to be more immediately plug-and-play. The code is straightforward enough that it’s a good learning platform. So let’s take a quick tour through three drum machines and a string synth, each of which you can build on a breadboard in just a few minutes.
To install on an Arduino UNO, fetch the zip file from this GitHub repository, and move each subfolder to your Arduino sketch directory. You’re ready to play along.
Simple Drum Machines
[Jan] has two sample-playback~based drum machines that he’s published the code for: the dsp-D8 with straight-ahead drum samples and the dsp-L8 loaded with Latin percussion. They’re essentially the same code base, but with different samples, so we’ll treat them together.
Working through [Jan]’s code inspired me to write up a longer article on DDS playback, so if you want to brush up on the fundamentals, you can head over there. The short version is that you can change the pitch of playback of a sample by using a counter that’s much larger than the number of data points you’re going to play.
[Jan]’s drum machines all use the AVR’s hardware pulse-width modulation (PWM) peripherals to play the samples back out. You could use something fancier, but this gets the job done with just an optional resistor and capacitor filter on the output, bringing the total parts count to three: Arduino, 1 KOhm resistor, and a decent-sized (0.1 uF?) capacitor. An interrupt service routine (ISR) periodically loads a new sample value into the PWM register, and the AVR’s peripheral hardware takes care of the rest.
One nice touch is the use of a circular buffer that holds the playback sample values until the ISR is ready for them. In the case of the drum machines, there’s not much math for the CPU to do — it just combines the samples from all of the different simultaneous voices — but in his more complicated modules this buffer allows the CPU to occasionally take more time to calculate a sample value than it would otherwise have between updates. It buys [Jan]’s code some breathing room and still allows it to make the sample-playback schedule without glitching.
[Jan] adds individual pitch control for each sample, which is great for live playing or tweaking, and you can watch him use them in his two videos: one for the dsp-D8 and another for the dsp-L8. Wiring up so many knobs is a breadboard-salad, though, so I’ve gone through the code for you with a fine-toothed chainsaw, and hacked off [Jan]’s button-and-knob interface and replaced it with the Arduino’s built-in serial I/O.
To play my version of [Jan]’s drum machines, each sample is mapped to a key in the home row: “asdfjkl;”. If you’ve got a proper serial terminal program that transmits each keystroke in real-time, you’ll be tapping out rhythms at 9600 baud in no time. Note that the Arduino IDE’s built-in terminal only sends the keystroke after you hit “enter” — this makes playing in tempo very difficult. (I use screen /dev/ttyACM0 9600 or the terminal that’s built-in with Python’s pyserial library myself. What do Windows folks use for a real-time terminal?)
If you haven’t already, download this zip file, move each sub-folder to your Arduino sketch directory, and connect an amplified speaker either directly to your Arduino’s pin 11 and ground, or include an RC filter. It’ll only take a second before you’re playing. When you want the full version with all the knobs, head on over to [Jan]’s site.
O2 Minipops
[Jan]’s O2 Minipops machine mimics an old-school rhythm box: the Korg mini pops 7. Whether this primitive drum machine is horribly cheesy or divinely kitschy is in the ear of the beholder, but it’s a classic that has been used all over. [Jan]’s named his after an epic album Oxygene by Jean-Michel Jarre. You’ll hear them starting around 1:40 into the clip. Jarre famously used to press multiple buttons on the Minipops, making more complex drum patterns by playing more than one at a time.
The nice thing about having your own Minipops in firmware is that you can add the features you want to it. Instead of having to mash down multiple plastic buttons live on stage like poor Mr. Jarre, you can just tweak the firmware to suit. Need longer patterns? You’ve got the RAM. Emphasis? Swing? Tap tempo? It’s all just a matter of a few lines of code.
The sound playback code is just like the simpler drum machines above, so we won’t have to cover that again. The only real addition is the sequencer, but that’s where the real magic lies. After all, what’s a drum machine without some beats? Because there are eight possible drum sounds, each beat is a byte and so four bars of 4/4 time is just sixteen bytes stored in memory. I broke the data out into its own header file O2_data.h, so have a look there for the pre-programmed rhythms, and feel free to modify them to suit your own needs.
In order to make the O2 Minipops immediately playable, I stripped out the potentiometer code again (sorry [Jan]!) and passed off control over the serial port. The “user interface” has five controls. Press j and k to switch between patterns and f and d to speed up or slow down. (They’re under your first two fingers in the home row.) The space bar starts and stops the drum machine.
Try switching between the patterns on the fly with j and k — it’s a surprisingly fun way to create your own, slightly less cheesy, patterns. You need to download this code and give it a try. Trust me.
[Jan]’s Solina is a “virtual analog” in the sense that it builds up sawtooth waveforms in the microcontroller’s RAM and then outputs the corresponding voltage through PWM. And that’s a good start for a string synthesizer, because a filtered sawtooth waveform is a good first stab at the sound put out by a violin, for example.
Solina — the clone
The secret to the sound of the string section of an orchestra (and to string synthesizers that mimic it) is that it’s a combination of many different bowed instruments all playing at once. No matter how precise the players, they’re each slightly differently tuned, and none of the strings are resonating exactly in phase. The Solina mimics this by detuning each oscillator, naturally, and by moving them in and out of phase with each other. If you want to dig into the details of how exactly [Jan]’s Solina works, he explains it well in this blog post.
Again, I’ve converted it for direct-serial control, and you can control the envelope, detune, LFO speed, and modulation depth over the serial port. Press the spacebar once to simulate a keypress, and again to let go. Try the Solina with detune and pitch modulation around twenty, and play with the LFO rate and other parameters. That’s a lot of useful noise for just some sawtooth waves.
Keyboards and What’s Next
[Jan]’s builds are much more than what we’re demonstrating here, of course. His blog kicks off (in 2009!) with a project that essentially shoe-horns a PC into a keyboard enclosure, and the Solina and others get their own keys too. We’ve just presented the kernel of any such project — there’s a lot of labor-of-love left in wiring up all of the diodes necessary to do detection on a keyboard matrix, to say nothing of building enclosures, wiring up potentiometers, and making nice-looking front panels. But if you want to start down that path, you’ve at least got a good start.
[Jan]’s current project is the Minimo miniature monophonic synth that takes the Solina a step further and adds a lowpass filter with (digital) resonance to it. The resulting sounds are great, so we’re excited to see where [Jan] takes this one in the future.
Thanks again, [Jan], for opening the code up. And if any of you build something with this, be sure to post in the comments and let us all know. Since I started playing around with these, I’ve got the hankering to modularize the code up a bit and make it into something that’s even easier to adapt and modify. Maybe we’ll have to start up a Hackaday.io project — these little simple synths are just too much fun!
Snow skiing looks easy, right? You just stay standing, and gravity does the work. The reality is that skiing is difficult for beginners to learn. [19mkarpawich] loves to ski, but he was frustrated seeing crying kids on skis along with screaming parents trying to coach them. Inspired by wearable electronics, he took an Arduino, an old jacket, some LEDs, and created Ski Buddy.
The brains in the jacket consist of an Adafruit Flora, accelerometer, and a battery pack. Conductive thread connects to LED sequins. The jacket can help teach linking turns, parallel skiing, hockey stops, and gradual pizza stopping. In addition to the build details and some notes on where not to place sensors (doubtlessly learned the hard way), [19mkarpawich] also does a detailed explanation of the software and how to use the jacket.
You can see a very short video demonstration of Ski Buddy below. We’ve seen more wearables lately, some of them pretty creative. Maybe it is time to learn how to sew if you can’t already.
Want to really understand how something works? Make one yourself. That’s the approach that Reddit user [Oskarbjo] took with this neat electric motor build. He made the whole thing from scratch, using an Arduino, 3D printing, and ample quantities of wire to create a solenoid motor. This transforms the linear force of a solenoid, where a magnet is moved by a magnetic field, into rotary force. It’s rather like an internal combustion engine, but driven by electricity instead of explosions. Hopefully.
[Oskarbjo]’s engine seems to work, including a rather neat mechanism to detect the rotation of the shaft and relay that back to the controller. He hasn’t posted much detail in the build process, unfortunately, but did say that “If you’d want to build something similar I can probably help you out a bit, but half the fun is coming up with your own solutions.” Amen to that. We’ve seen a few neatsolenoidmotor builds, but this one wins points for starting from scratch. There is an Instagram video of the motor running after the break.
Take three NRF24L0+ radios, two Arduino Nanos, and a Raspberry Pi. Add a bored student and a dorm room at Rice University. What you get is the RRAD: Rice Ridiculously Automated Dorm. [Jordan Poles] built a modular system inspired by BRAD (the Berkeley Ridiculously Automated Dorm).
RRAD has three types of nodes:
Actuation nodes – Allows external actuators like relays or solenoids
Sensory nodes – Reports data from sensors (light, temperature, motion)
Hub nodes – Hosts control panel, records data, provides external data interfaces
The hub also allows [Jordan] to control things with his Android phone with Tasker. He has the Arduino and Raspberry Pi code on GitHub if you want to ridiculously automate something of your own. You’d probably want to adapt it to your dorm room, house, or RV, though.
[Jordan] continues to work on the project and promises to have voice recognition and other features, soon. We cover a lot of home automation projects including some others described as ridiculous. The video below shows BRAD, the inspiration for RRAD.
[Mike]’s hacks aren’t breathtaking in their complexity, but they got a good chuckle out of us. [Mike], the CEO of The Useless Duck Company, lives in a hub of innovation somewhere in Canada, where he comes up with useful gadgets such as a Fedora that tips itself, or a door that locks when you’re shopping for gifts for your wife and you’re in incognito mode.
It all started when he was trying to learn the Arduino, and he put quite a few hours into making a device that could wirelessly squeak a rubber bath duck from the bathroom. The whole project reminded us of our first clumsy forays into the world of electronics, with entirely too many parts to complete a simple function. The Arduino being the gateway drug it is, it wasn’t long before he was building a bartending robot.
We hope he continues to construct more entertaining gadgets.
In the dark ages, you had to use a key to lock and unlock your car doors. Just about every car now has a remote control on the key that lets you unlock or lock with the push of a button. But many modern cars don’t even need that. They sense the key on your person and usually use a button to do the lock or unlock function. That button does nothing if the key isn’t nearby.
[Pierre Charlier] wanted that easy locking and unlocking, so he refitted his car with a Keyduino to allow entry with an NFC ring. What results is a very cool fistbump which convinces your car to unlock the door.
Keyduinio is [Pierre’s] NFC-enabled project, but you can also use a more conventional Arduino with an NFC and relay shield. The demo also works with a smartphone if you’re not one for wearing an NFC ring. Going this round, he even shows how to make it work with Bluetooth Low Energy (BLE).
In the video below, you can see how he removed the car’s internal lock switch and modified the wire harness to take the connection to the Arduino. He’s also included all the code. About the only tricky part is doing the actual wiring in your car and finding a suitable source of power. That varies from car to car, so it isn’t easy to give specific instructions.
Opening doors of one kind or another is a popular project theme. While [Pierre’s] project might open the door on a coupe, we’ve seen another project that works on a coop.
It was Stardate 2267. A mysterious life form known as Redjac possessed the computer system of the USS Enterprise. Being well versed in both computer operations and mathematics, [Spock] instructed the computer to compute pi to the last digit. “…the value of pi is a transcendental figure without resolution” he would say. The task of computing pi presents to the computer an infinite process. The computer would have to work on the task forever, eventually forcing the Redjac out.
Calculus relies on infinite processes. And the Arduino is a (single thread) computer. So the idea of running a calculus function on an Arduino presents a seemingly impossible scenario. In this article, we’re going to explore the idea of using derivative like techniques with a microcontroller. Let us be reminded that the derivative provides an instantaneous rate of change. Getting an instantaneous rate of change when the function is known is easy. However, when you’re working with a microcontroller and varying analog data without a known function, it’s not so easy. Our goal will be to get an average rate of change of the data. And since a microcontroller is many orders of magnitude faster than the rate of change of the incoming data, we can calculate the average rate of change over very small time intervals. Our work will be based on the fact that the average rate of change and instantaneous rate of change are the same over short time intervals.
Houston, We Have a Problem
In the second article of this series, there was a section at the end called “Extra Credit” that presented a problem and challenged the reader to solve it. Today, we are going to solve that problem. It goes something like this:
We have a machine that adds a liquid into a closed container. The machine calculates the amount of liquid being added by measuring the pressure change inside the container. Boyle’s Law, a very old basic gas law, says that the pressure in a closed container is inversely proportional to the container’s volume. If we make the container smaller, the pressure inside it will go up. Because liquid cannot be compressed, introducing liquid into the container effectively makes the container smaller, resulting in an increase in pressure. We then correlate the increase in pressure to the volume of liquid added to get a calibration curve.
The problem is sometimes the liquid runs out, and gas gets injected into the container instead. When this happens, the machine becomes non-functional. We need a way to tell when gas gets into the container so we can stop the machine and alert the user that there is no more liquid.
One way of doing this is to use the fact that the pressure in the container will increase at a much greater rate when gas is being added as opposed to liquid. If we can measure the rate of change of the pressure in the container during an add, we can differentiate between a gas and a liquid.
Quick Review of the Derivative
Before we get started, let’s do a quick review on how the derivative works. We go into great detail about the derivative here, but we’ll summarize the idea in the following paragraphs.
Full liquid add
An average rate of change is a change in position over a change in time. Speed is an example of a rate of change. For example, a car traveling at 50 miles per hour is changing its position at 50 mile intervals every hour. The derivative gives us an instantaneous rate of change. It does this by getting the average rate of change while making the time intervals between measurements increasingly smaller.
Let us imagine a car is at mile marker one at time zero. An hour later, it is at mile marker 50. We deduce that the average speed of the car was 50 miles per hour. What is the speed at mile marker one? How do we calculate that? [Issac Newton] would advise us to start getting the average speeds in smaller time intervals. We just calculated the average speed between mile marker 1 and 50. Let’s calculate the average speed between mile marker’s 1 and 2. And then mile marker’s 1 and 1.1. And then 1 and 1.01, then, 1.001…etc. As we make the interval between measurements smaller and smaller, we begin to converge on the instantaneous speed at mile marker one. This is the basic principle behind the derivative.
Average Rate of Change
Gas enters between time T4 and T5
We can use a similar process with our pressure measurements to distinguish between a gas and a liquid. The rate of change units for this process is PSI per second. We need to calculate this rate as the liquid is being added. If it gets too high, we know gas has entered the container. First, we need some data to work with. Let us make two controls. One will give us the pressure data for a normal liquid add, as seen in the graph above and to the left. The other is the pressure data when the liquid runs out, shown in the graph on the right. Visually, it’s easy to see when gas gets in the system. We see a surge between time’s T4 and T5. If we calculate the average rate of change between 1 second time intervals, we see that all but one of them are less that 2 psi/sec. Between time’s 4 and 5 on the gas graph, the average rate of change is 2.2 psi/sec. The next highest change is 1.6 psi/sec between times T2 and T3.
So now we know what we need to do. Monitor the rates of change and error out when it gets above 2 psi/sec.
Our psuedo code would look something like:
pressure = x;
delay(1000);
pressure = y
rateOfChange = (y - x);
if (rateOfChange > 2)
digitalWrite(13, HIGH); //stop machine and sound alarm
Instantaneous Rate of Change
It appears that looking at the average rate of change over a 1 second time interval is all we need to solve our problem. If we wanted to get an instantaneous rate of change at a specific time, we need to make that 1 second time interval smaller. Let us remember that our microcontroller is much faster than the changing pressure data. This gives us the ability to calculate an average rate of change over very small time intervals. If we make them small enough, the average rate of change and instantaneous rate of change are essentially the same.
Therefore, all we need to do to get our derivative is make the delay smaller, say 50ms. You can’t make it too small, or your rate of change will be zero. The delay value would need to be tailored to the specific machine by some old fashioned trial and error.
Taking the Limit in a Microcontroller?
One thing we have not touched on is the idea of the limit within a microcontroller. Mainly, because we don’t need it. Going back to our car example, if we can calculate the average speed of the car between mile marker one and mile marker 0.0001, why do we need to go though a limiting process? We already have our instantaneous rate of change with the single calculation.
One can argue that the idea behind the derivative is to converge on a single number while going though a limiting process. Is it possible to do this with incoming data of no known function? Let’s try, shall we? We can take advantage of the large gap between the incoming data’s rate of change and the processor’s speed to formulate a plan.
Let’s revisit our original problem and set up an array. We’ll fill the array with pressure data every 10ms. We wait 2 seconds and obtain 200 data points. Our goal is to get the instantaneous rate of change of the middle data point by taking a limit and converging on a single number.
We start by calculating the average rate of change between data points 200 and 150. We save the value to a variable. We then get the rate of change between points 150 and 125. We then compare our result to our previous rate by taking the difference. We continue this process of getting the rate of change between increasingly smaller amounts of time and comparing them by taking the difference. When the difference is a very small number, we know we have converged on a single value.
We then repeat the process in the opposite direction. We calculate the average rate of change between data points 0 and 50. Then 50 and 75. We continue the process just as before until we converge on a single number.
If our idea works, we’ll come up with two values that would look something like 1.3999 and 1.4001 We say our instantaneous rate of change at T1 is 1.4 psi per second. Then we just keep repeating this process.
Now it’s your turn. Think you have the chops to code this limiting process?
Turning the classic toy Etch-A-Sketch into a CNC drawing tablet intrigues a large number of hackers. This version by [GeekMom] certainly takes the award for precision and utility. Once you build something like this, you can hardly stop writing firmware for it; [GeekMom] produced an entire Arduino library of code to allow joystick doodling, drawing web images, and a self-erasing spirograph mode. The topper is the version that runs as a clock!
The major hassle with making a CNC version of this toy is the slop in the drawing mechanism. There is a large amount of backlash when you reverse the drawing direction. If that isn’t bad enough, the backlash is different in the vertical or horizontal directions. Part of [GeekMom’s] presentation is on how to measure and correct for this backlash.
The EtchABot uses three small stepper motors. Two drive the drawing controls and the third flips the device forward to erase the previous drawing. The motors are each controlled by a ULN2003 stepper motor drivers. An Arduino Uno provides the intelligence. Optional components are a DS3231 Real Time Clock and a dual axis X-Y joystick for the clock and doodling capability. Laser cut wood creates a base for holding the Etch-A-Sketch and the electronics.
The write up and details for this project are impressive. Be sure to check out the other entries in [GeekMom’s] blog. Watch the complete spirograph video after the break.
Strong is the Force, with this Padawan. To coincide with the latest installment of the continuing saga from a galaxy far, far away, [Rohit Gupta] built a Star-Wars themed interactive doormat. The doormat detects a footstep using capacitive sensing and plays a random Star Wars audio clip like the opening theme or the Imperial March or a famous phrase from the movie. Check out the video below the break.
The current setup is temporarily breadboarded, but we are sure it will be popular enough with his visitors to make him tidy it up. The hardware consists of an Arduino with an audio shield connected to a pair of speakers. A capacitive wire loop under the mat and a capacitive sensor tuned to the mat size wire take care of the sensing.
When Earth people step on the mat, the sensor triggers the Arduino to play a random audio clip from the SD card. The capacitive sensing is taken care by the TP223 1-key touch pad detector chip (PDF), which he mounted on a home etched board with SMD parts. The whole bundle is powered by a small “power bank” battery pack like the ones used to charge mobile phones.
running a calculus function on an Arduino presents a seemingly impossible scenario. In this article, we’re going to explore the idea of using derivative like techniques with a microcontroller. Let us be reminded that the derivative provides an instantaneous rate of change. Getting an instantaneous rate of change when the function is known is easy. However, when you’re working with a microcontroller and varying analog data without a known function, it’s not so easy. Our goal will be to get an average rate of change of the data. And since a microcontroller is many orders of magnitude faster than the rate of change of the incoming data, we can calculate the average rate of change over very small time intervals. Our work will be based on the fact that the average rate of change and instantaneous rate of change are the same over short time intervals.
