Archive / New Products

RSS feed for this section

New Products: A New Fluxamasynth, the Noisemusick Kit, and some art

newproducts1We have some new products to announce at Modern Device; the most exciting is the new version 3 of the Fluxamasynth Shield, a 64 voice polyphonic synthesizer for Arduino. We updated the synth to the new SAM2695 chip, much better filters, and a new microphone input. Check it out in the shop.


Another new feature is an optional 5-pin DIN thu jack and MIDI-compliant optoisolated connection (see variant above).


The Noisemusick Kit has been around since 2009 or so but recently received some improvements. It is a fun, chaotic square wave generator that is triggered by IR light and your skin’s resistance. It’s a good Learn To Solder project, only $25 in the Music/Sound/Noise section of the shop.

In the Merchandise section we’ve added two pieces of artwork: a bumper sticker from the OTPC project (to complement our theremin merit badge) and a four color silkscreen poster of an Arduino. More posters coming soon, since we have a silkscreen studio right next door!



By Shawn on January 17, 2016.

New Product: BUB III


Future Technology Devices International makes many different TTL Serial to USB chips.
One model, the FT232R, is used in boards like the
The AdaFruit FTDI friend,
SparkFun FTDI Basic,
Modern Device BUB I and
Modern Device BUB II.
It’s not the cheapest, smallest, or most functional FTDI chip– just the most popular.

Presenting the BUB III, designed around the FT231X QFN-20, a 4x4x.075 (mm) chip.

You’ll notice it has a micro-USB jack, instead of a mini-USB one. Micro-USB jacks have a bad reputation for coming off boards, because they have less surface soldered on the board. We spent a fair amount of time finding a micro-USB jack with extra prongs and adding vias to reinforce the smd pads. Our destructive testing of a few of these boards shows that our efforts to toughen up the boards were successful. The jacks take quite a bit of muscle to break, and we think they will stand up to abuse as well as mini-USB jacks.

Moving the header to the bottom makes the board even smaller, and saves us time in production.
Both LEDs are reconfigurable (should you want to reconfigure them) with FTX-prog

It’s the BUB you love, smaller, slicker and reborn with an all-new brain.

Be one of the first 6 customers to use coupon code freebubiii and get a free BUB III with your order! (order total must be over $10)

Go check it out in the shop!

By Nadya on November 10, 2015.

New Product: SMD LCD 117


The original serial LCD117 was one of two boards that utilized a PIC chip running firmware developed by the late electrical engineer Peter Anderson (KZ3K), who taught in Baltimore, Maryland.

Peter made the firmware freely available before he passed away.
Both Brian Riley‘s K107 serial board and our LCD117 kit were based on these LCD117 chips.

We’ve sold several thousand of our through-hole serial LCD117 kits since we designed it in 2008, and received many orders for pre-assembled boards. Looking around the shop, most pre-assembled things are surface mount– it’s easier for everyone that way, as surface mount assembly is much cheaper. With that in mind, we created the SMD LCD117.

It receives TTL serial (optionally RS232) on one side and and drives an HD44780-compatible LCD, just as the older through-hole LCD117 kit did.

Solder on the included 3-pin and 16-pin headers and you’re ready to talk to any of our character displays, 3.3v or 5v.
We’ve also added an inverted logic mode, available via SMD solder jumper, for RS232 support.

Here’s how easy it is to use with Arduino– plug the RX line into your Arduino TX pin, and:

void setup() {
Serial.begin(9600); // 9600 baud is chip comm speed
Serial.print("?G216"); // set display geometry, 2x16 in this case
delay(500); // pause to allow LCD EEPROM to program

void loop() {
//Serial.print(“?y0?x00”); // cursor to beginning of line 0
Serial.print(“?f”); //clear the screen
Serial.print(“hello world”);
delay(1000); // refresh every second

In this configuration, Arduino Serial.<thing> debug statements print straight to the display!

Go check it out in the shop

Oh, one more thing. In honour of the debut of the SMD version, we’re putting the old through-hole LCD117 kits on sale. $8, matching the new SMD boards, while supplies last.

By Nadya on August 28, 2015.

Maxbotix Ultrasonic Rangefinder MB1013 (1mm Resolution) Proveout

A month or so ago we decided to carry the Maxbotix’s line of ultrasonic rangefinders (the MB1010, MB1013, and the MB1200 are the models we have currently stocked).  The MB1013 in particular caught our eye in its claim to have a resolution of 1mm, so we decided to put it to the test. We lashed together a test rig with two panels (of plywood) that are raised and lowered by three drive shafts of 1/32″ threaded rod (pictured below).




The board has two holes in the opposite corners that make mounting to a surface a no-brainer. We quickly proved out the analog output using a 5v power supply and a multimeter, but we wanted the most precise measurement. Opting for the serial (digital) output  reading with an Arduino- both methods are covered in the Maxbotix tutorial. For ease of documentation, we hooked up the Arduino to an LCD driven by our LCD117 board, for an easy three wire interface to the LED. This was just handy way to get feedback without a laptop or desktop. Actually the USB cable in the picture below snakes about 10 ft to the nearest desktop in our shop.


Our threaded rod was 32 threads per inch, which is equivalent to 24.4 mm, so one thread represents 32 threads per inch / 25.4 mm per in. or 1.25984 threads per millimeter. This allowed us to index the jig 1.25 turns per unit and not have a lot of error, with an error of .246 threads per 25 turns. In any case we indexed all the way through one inch,

Our results showed that it does indeed have a 1mm resolution, meaning that 1 1/4 turns did actually correspond with a Maxbotix output of 1mm! Our algorithm kept the readings consistent with the range up until around 620mm – where the sensor’s output started to report smaller values than the measured distance, ending up 8-10mm ahead of where it was supposed to be at 582 mm. Maxbotix cuts off the serial output of the sensor at 300mm (11.8″) so one could speculate that the error in the electronics started to be a factor in the measurement, which lead to Maxbotix to cut off the specification at 300mm.



Check out the raw data here.

The max range and cone shapes vary from the sensors we have available. They could be used for things like a parking sensor (found in most modern cars), self-navigating robots, or a suit that helps you navigate blind. Maxbotix has done a great job  of taking ultrasonic measuring technology and pushing itas far as they can in accuracy, range and sensing properties (sensing cones) in these very low-cost sensors. Here’s a line up of the models we carry at Modern Device.

MB1010 LV-MaxSonar®-EZ1 – Least Expensive, good starter ($27.97)

MB1013 HRLV-MaxSonar®-EZ1 – Highest Resolution (1mm)

MB1200 XL-MaxSonar®-EZ0 – Longest Range (300in)


We got in contact with the good people at Maxbotix and showed them our research. They were pleased to see us exhibiting their equipment, and gave us some feedback on our setup…

First, I reviewed your test setup and thought you did a pretty good job. As such there is a variable that can make a big difference in your testing results. This is the temperature compensation and the location of measurement. Going though a vertical column of air is known to typically have temperature variation from the top vs the bottom. This change in temperature can affect the temperature compensation of the sensor and lead to some inaccuracies. For best accuracy, it is recommended to use a MaxTemp mounted half way between the target and sensor so that you have the most accurate temperature reading. Even one or two degrees c will have an effect on the reported range. 

You can view more on the MaxTemp at this link

By Britton on January 28, 2015.

New Product Bundle: Jeelabs Mini Starter Kit!


We are introducing a starter kit for JeeLab’s JeeLink and JeeNode SMD!

This Jeelabs Mini Starter Kit kit comes with everything you need to start working with wireless communication. We have also included a USB BUB II to interface with the JeeNode SMD. All products are surface mount and require little assembly to attach headers. We can also solder all headers on both the JeeNode SMD and the BUB II for an additional charge.

Save 25% off both the Jeenode SMD and the JeeLink, and 28% off the USB BUB II when you purchase them bundled together!

If you for some reason decide to get to different frequencies please let us know in the customer comments upon checkout. The kit will not work together if you purchase two different frequency modules.

By Britton on December 29, 2014.

Arduino Yún: Connecting a JeeNode to the Internet

Last week Paul handed me one of our new Arduino Yún boards and asked me to get a project going. I know the Uno and the Arduino environment well, but the Yún has an Atheros processor running Linux. I had little idea how I was going to wrap my head around the command-line oriented Linux part of the equation. I figured I’d give it a shot and see if I could have my way with the Yún’s Linux processor. As you’ll see, I had a lot more success than I thought I would.

Setting up the Yún’s wi-fi for the first time is fairly straightforward, so I’m not going to bother explaining how to do that when you can find a great start-up guide at the Ardiuno website. The only thing I’d add is that accessing the setting in my browser was hit or miss when I tried accessing http://[board name].local. Instead, I recommend memorizing the Yún’s IP address from the configuration window because accessing it that way (http://[IP address]) worked every time and the IP address is how you access the Linux processor through SSH. I should also mention that only the absolute latest version of the Arduino IDE, version 1.5.6-r2, actually supports the Yún, so make sure you install that too (you can find it here).

For my first Yún project, I wanted to focus on the Atheros processor because the Atmel processor is identical to that of the Arduino Leonardo and functions essentially the same. But what to do? As it turns out, we have a hot box that we use to keep the radios dry for our JeeLabs products, and when it was first set up we added a humidity sensor connected to a JeeNode USB that output humidity and temperature data to a LCD screen via an LCD plug (for the sake of product placement, I might as well mention that a Jee ProtoBoard was involved as well). The thing is, every now and then the darn thing would freeze and need to be reset, and with everything that goes on here no one really has time to check on the hot box with any kind of regularity. Clearly we needed a way to be able to check the status of the hot box from anywhere. That’s where the Arduino Yún would come in.

To start, let’s see how the data gets from the box to the Yún. Here’s the code for the JeeNode USB on the hot box itself. It’s pretty straightforward; the data points are collected, sent to the LCD for display, and cast to integers after multiplying by 100 to preserve two decimal places before being broadcast by the radio. There’s a one-second delay and then the whole thing repeats. Note the group number 68 from rf12_initialize; we’ll need to make sure the JeeLink on the other end gets configured with the same number.

#include <PortsLCD.h>
#include <Wire.h>
#include <LibHumidity.h>
#include <jeelib.h>

PortI2C myI2C (1);
LiquidCrystalI2C lcd (myI2C);
LibHumidity humidity = LibHumidity(0);

#define screen_width 16
#define screen_height 2
int Fan = 7;

void setup() {
  pinMode(Fan, OUTPUT);
  digitalWrite(Fan, LOW); //LOW is on

  lcd.begin(screen_width, screen_height);

  lcd.print("HUMIDITY STORAGE");
  rf12_initialize(20, RF12_915MHZ, 68);

void loop() {

  int data[3];
  lcd.print("HUMIDIY: ");
  float h = humidity.GetHumidity();
  data[0] = (int)(h*100);
  float t = humidity.GetTemperatureC();
  data[1] = (int)(t*100);
  lcd.print(" F");
  t = humidity.GetTemperatureF();
  data[2] = (int)(t*100);
  while (!rf12_canSend())
  rf12_sendStart(0, data, 6);

The code for the JeeLink that receives the data is even simpler. It just receives, unpacks, and prints the data sent by the JeeNode USB. You should also note the group number, 68, which matches the code on the transmitting JeeNode USB, and the serial baud rate, 57600, which we’ll need later.

#include <jeelib.h>

void setup() {
  rf12_initialize(18, RF12_915MHZ, 68);

  Serial.print("Receiving data...");

void loop() {
  if (rf12_recvDone() &amp;&amp; rf12_crc == 0) {
    int* buf = (int*) rf12_data;
    for (int i=0; i&lt;3; i++) {
      Serial.print(" ");

Now that we’ve got the JeeLink streaming data over Serial, we can use the Yún to put it on the web. To do this, we’ll need to go directly to the Atheros processor, which we can do with a simple SSH in Terminal.

ssh root@[Yún IP address]

The first time you do this it will give you a security warning, so just enter “yes” to connect to the Yún. Once you’ve done that, we’ll need to install the FTDI drivers so the Yún can interpret serial data sent through the USB port. Luckily, the Yún’s Linux distribution Linino uses a package system that makes installing such things incredibly simple from the command line, so we’ll also install a second package we’ll need later.

opkg update
opkg install kmod-usb-serial-ftdi
opkg install pyserial

The first command just updates the package list so you only have to do this once. If you ever have trouble finding a package, try running update again.

With the FTDI drivers installed, the Yún can now interpret serial data sent to it from the JeeLink through the USB port. To put that data on the web, we need a Python script. That script, in all its in-line commented glory, is as follows:

# This program reads off /dev/ttyUSB0 and writes an auto-updating html file with the results
# We have a jeelink on /dev/ttyUSB0 sending us data like "2580 7183 16132", which we divide by 100 to
# get humidity, temperature in celsius, and temperature in fahrenheit

import serial # Load pyserial
ser = serial.Serial('/dev/ttyUSB0', 57600, timeout=3) # Open the serial port at 57600

while True: # Loop forever
        data = ser.readline().split() # Split our data into an array, "2580 7183 16132" becomes [2580, 7183, 1613]
        if len(data) is 3: # The first line usually says something like "reading data..." ignore it.
                data = [float(thing)/100 for thing in data] # Divide each number by 100
                file = open('data.html', 'w') # Open the html file for writing
                file.write("<html><head></head>\n<body>\n \
<title>Yun server</title>\n<p>Humidity: {0:.2f}</p>\n<p>Temperature (C): {1:.2f} \
                </p>\n<p>Temperature (F): {2:.2f}</p>\n</body></html>".format(*data)) # Write the html page with the data-- *data unpacks it
                file.close() # Close the file

To make this available on the web, we have to move it to a special directory for files that we want the Yún’s server to host called “/www/”. We’ll also move our code (we named the file to its own subfolder because it’s going to create a file.

#Starting from the Yún's root directory
cd /www/
mkdir humidity

In a new terminal window, navigate to the folder containing, then use the following command to copy it to our target directory.

scp root@[Yún IP address]:/www/humidity/

Enter the password, then go back to your original Terminal window.

cd ./humidity
chmod +x #make the python script executable
./ #run it!

The last step is to build the webpage around the data to make it look nice. The index.html file, which will need to be moved to the same directory as, is as follows. I didn’t write this part (credit goes to Noah Beford), so I’m just going to call it a magical box. What I can tell you is that the stylesheet isn’t necessary, we just wanted it to look like the rest of our website.

<!-- FONTS -->
<meta charset="UTF-8" />
<link href='' rel='stylesheet' type='text/css'>
<link href=',700' rel='stylesheet' type='text/css'>
<!-- END FONTS -->
<link rel="stylesheet" type="text/css" href="humidity/style.css" media="screen" />
<script src=""></script>
<script type="text/javascript">
function reloadData(){
<b>Here's the data from the Modern Device dry box, where we keep the <a href="">radio chips</a>:</b><br />
<br />
<div id="data"></div>

<p>This is being relayed from a <a href="">Jeenode</a> mounted on the dry box to a <a href="">Jeelink</a> plugged into an <a href="">Arduino Yun.</a></p>


Now that everything’s in place, we can access the data stream by going to http://[Yún IP address].local/humidity. To make it available to the public, we set up a redirect for port 80 of our external IP address to the internal Yún IP address (more on that in a future post; for now, you can just ask a friend who’s a gamer). We also set up a special subdirectory on our website so you can see the final results by going to

GitHub repository for this project
Buy your own Arduino Yún

Stay tuned for more!

By Jeffrey Blum on April 2, 2014.

SI1143-Based Distance Sensors


We have some affection for the SI1143 chip. We used it for our pulse sensor in which it performs admirably.  Plus we successfully puzzled our way through its  78 page datasheet. So we figured that we would spin up some sensors based on what the chip was supposed to do (i.e. what the manufacturers of the chip thought  it might be good for), namely proximity sensors.

Our summer intern Gavin Atkinson took the lead in designing these two versions or an SI1143 based proximity sensor. They are both exactly the same schematic and parts and only the form factor varies. However the geometry of the LED / sensing chip layout affects the sensor so sensing distances and sensing angles vary a bit.

Silicon Labs wrote an app with  code for “swipe-sensing” that demonstrates detection of swiping your hand over the sensor from different directions. We thought it would fun to see how the sensor might work as a 3D mouse. For you math and code heads, the code that we used in the video uses vector addition to add the three vectors whose inputs are the values returned by the various LED readings and whose angles are represented by the angles between the chip and respective LEDs (0, 120, & 240 degrees). This yielded a vector and direction that was a fairly good decoding of the LEDs into a vector direction and strength as you can see in the video. Summing all three LED values yields a good idea of object distance to the chip – so it would be possible to map these coordinates into 3D space, which we did not do in an explicit way in the video.

SI114 Distance Sensor from gavin atkinson on Vimeo.

The pictures above, and in our video are our prototypes and the assembly technique on the sensors lacks something in the neatness department. In particular we need to find the correct adhesive and technique to glue on the chip’s laser cut “shield”, which prevents LED light from “short circuiting” to the sensor. We also used some diffusers over the LEDs in the video. We believe that wider LED angles will work as well as the diffusers. We also revised the layout a bit as found that the large capacitor was blocking the LED in some situations. Yeah for prototypes working the way they are supposed to!

Some possible uses for the sensor we thought about were:

  • interactive controllers or scroll wheels as in the video link below
  • smart distance sensor for robots so that they might be able to tell heading toward a wall or other object
  • short distance replacements for Sharp IR distance sensors with no “close-in deadspot” that sometimes making the Sharp sensors tricky to apply.
  • touchless 2D or 3D mouse, perhaps hot-cold control for a sink mixing valve, meat packing factory, hospital or surgery suite where hands were either dirty or clean and touchless sensing was desirable.
  • interactive art projects

Distance/Proximity Sensors are in the shop here!

By Paul Badger on August 15, 2013.

New Product: Lots Of Pots (LOP) Board For Raspberry Pi

DSC_0118 2


The Lots Of Pots Board is a shield that solves some problems in working with the Raspberry Pi’s physical computing capabilities. It comes with an 8 channel analog to digital converter for reading potentiometers or sensors, and breaks out the GPIO pins and communication pins in a useful configuration. I wanted this board as an interface for making virtual synthesizers on the Raspberry Pi, but it will work well for other analog input sensors as well if you populate the board with headers instead of pots. If you’ve got a project that requires several analog and digital inputs, this board will save you a lot of time stripping wires and fussing with protoboard.

Continue Reading →

By Shawn Wallace on June 27, 2013.

New Product: Serial LED Strips


We bought some Serial LED strips for the shop and I am having a whole lot of fun programing them. Like most 12 volt strips they are wired with three LEDs in series, which are in turn controlled by one high-speed serial chip. So there are 50 control chips on a 5 meter strip. (The strips have 30 LEDs per meter). We looked for strips with 60 LEDs per meter but our supplier could not provide them without a sizable order from the factory.

The somewhat coarse grain of this control might be a show-stopper for some LED projects, but they’re well positioned for lots of general computer-controlled changeable color and display applications. I am having a whole lot of fun programming them. I found an excellent high-speed library here. The author hasn’t returned my email yet, I’ll call him Daniel G. from his email address, and give him more specific credit if I can get in touch, and he wants the attention.

Our LED strips are controlled with the UCS1903 chipset, which has, as one of its great virtues, the ability to control the LEDs with only a ground and data line. All of the Chip Select and Clock functions have been replaced in the chip, by careful timing control, which also requires a microController running at least 16 Mhz, so Lillypad owners are out of the picture, at least for now. The lack of clock signal lines creates a very clean interface. Two wires, Ground and +12 volts, go to the strips from the power supply, and two wires, GND and Data In, connect the microcontroller to the strips. The strip headers thoughtfully have two wires on ground (if you buy a whole 5 meter roll), so it’s a very easy hoookup. More strips can just have data and GND lines daisy chained, and power lines perhaps run in parallel, to avoid huge currents through the strips, although it might be possible to run 10 meters daisy chaining all four wires, especially if all the LEDs are not on at any one time.

Writing 255, 255, 255 to all LEDs yields a strip (5 meter) operating current of 2.3A (@ 12 volts). The total current divided by 150 (50 controller chips x 3 colors) yields about 15mA per LED so the strips should have a long lifetime at that current, since most superbright LEDs are usually rated at 20 mA or greater.

I cooked up five demo sketches to help users get going on using the library. There are some videos below (of uneven quality) showing the effects. There are some nasty flickers in some of them that just represent interference patterns between the video frequency and the update frequency of the LED’s. Needless to say, the LEDs don’t look like this to the human eye. Cyborgs though, will eventually be connoisseurs of visual phenomenon entirely invisible to people.

The Serial LED strips are in stock and in the shop here.

By Shawn Wallace on May 3, 2013.

New Product: Hobby Servos!


Paul picked these servos up for his class, and liked them so much that we are now putting them in stock!


This is a standard analog hobby servo with nylon gears. It also features 2 ball bearings on the main output shaft. Ball bearings are rare on inexpensive “generic” servos, so this is definitely a nice feature to see.

Continue Reading →

By Sebastian on March 20, 2013.