New Top

All Products By Category

Archive | New Products

New Product: SMD LCD 117

SMDLCD117

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.

pha1
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
//delay(10);
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.

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).

mb1013_mounting

mb1013_rig

mb1013_closeup

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.

mb1013_rig_closeup

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.

mb1013_chart

 

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)

UPDATE: 2/2

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 http://www.maxbotix.com/Ultrasonic_Sensors/MB7955.htm.

New Product Bundle: Jeelabs Mini Starter Kit!

jeelabs_bundle

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.

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.

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.

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.

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.

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:

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 upload.py) to its own subfolder because it’s going to create a file.

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

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

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 upload.py, 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.

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 humidity.moderndevice.com.

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

Stay tuned for more!