Robotics

.NET Micro Framework – Using alphanumeric LCDs

Szymon Kobalczyk — Sun, 05 Sep 2010 16:27:22 GMT

.NET Micro Framework includes reach graphics capabilities with WPF-like libraries, and quite a few high end development boards (Tahoe II, ChipworkX, or FEZ Cobra to name a few) include fancy graphic TFT screens, often with touch input thrown in as well. But this comes at a significantly higher costs, and requires a speedy CPU. Thus it might seem that if you are using a much cheaper board such as Netduino or one of FEZ family, you are doomed to rely on blinking LEDs only. Not quite so. In most scenarios an alphanumeric LCD might be a cheap alternative (or if you have higher budget you might consider using an OLED screen that also works with Netduino).

For a larger project I’m working on I plan to use an alphanumeric LCD to display all sorts of status information. Practically all popular LCDs are controlled by a HD44780 compatible parallel interface chipset. There is wide range of these screens available in various combinations of backlight and text color. The common size is 16x2 characters (16 columns in 2 rows). Take a look at the wide selection of LCDs available from SparkFun. I got mine from local electronics store that has very cool looking combination white text on blue background.

When you buy the LCD take notice if you get the 5V or 3V3 version. I’m sure both work fine with Netduino (which uses 3V3 logic) but make sure to wire them to correct power source pin.

These LCDs are quite easy to wire and program. If you look at the above picture notice the 16pin header on top of the display. The HD44780 chipset uses parallel interface for data communication and supports 8bit and 4bit modes. In the former case it will use at least 10 digital output pins from the microcontroller, in the later at least 6. The R/W pin (read write) bit can be permanently wired to ground. You can find the wiring instructions in the examples for the Arduino Liquid Crystal library – it will work the same way on the Netduino. To avoid soldering you can also try to use the DFRobot LCD Keypad Shield for Arduino, and I learned via twitter that Mr. Kogoro Kotobuki (@kotobuki), is designing a similar LCD shield that appears to work great with Netduino. I was told it’s a prototype and not yet sold, but it looks very nice (see one more photo and the schematics).

However if we take the direct approach, the LCD will use at least six of available digital pins. If you use a microcontroller that exposes a massive number of IO ports (like FEZ Rhino or upcoming FEZ Panda) this might be okay, but in case of Netduino or similar board that has only a handful of digital pins this might be not suitable. In this case you might want to multiplex the output over fewer lines. In my previous post I already talked about using shift registers to work around such situation and in this case we can reduce the number of outputs to only three.

Another alternative could be to buy a Serial Enabled LCD. Usually they include as special daughter board on the back (hence called a “backpack”) that has a MCU responsible for translating the UART communication to the interface of the LCD. So if you can sacrifice one of the UART ports on the Netduino this might be a good option, but they usually cost about $10 more than regular LCDs. You can also buy the serial backpack alone, for example the one from Sparkfun or the LCD117 Serial LCD Kit from Modern Devices.

For my project I will be using the same 74HC595 shift register that I used in my earlier demo. Pavel Bánský already demonstrated how to do this on .NET Micro Framework devices. In his first post he shows how to interface LCD with 3 wires using the 4094 shift register, and then in the second post he added support for an I²C 8-bit port extender. I have modified and extended his library to include functionality available in the Arduino LiquidCrystal library.

Pavel introduced a nice abstraction in his implementation to separate the LCD high level functions from underlying transport interface into separate classes. Thus the constructor of top level class LiquidCrystal requires you to provide an instance of a class implementing the ILiquidCrystalTransferProvider interface. This enables to use this library with all the methods of communication described above. In the source code you will already find an GpioLiquidCrystalTransferProvider and Shifter74Hc595LiquidCrystalTransferProvider for the 74HC595 shift register. Later I’m going to add support for the I²C port expander. I got a nice LCD backpack from JeeLabs shop that uses the MCP23008 chip but I don’t know yet how much different it is from Pavel’s PCF8574P. In preparation for this some common bit handling code is already abstracted in the BaseShifterLiquidCrystalTransferProvicer class.

Here you can see the wiring I used:

Notice that because this time I’m going to use SPI interface the serial data is connected to pin 11 (MOSI) and pin clock is connected to pin 13 (SPCK). Pin 10 is connected to the latch pin, and in the code it is passed as Slave Select pin to the SPIConfiguration object. Since we are going to use seven outputs from the shift register the one remaining output is connected via 2N2222A transistor to control the LCD backlight. This allows us to turn the backlight on or off from code. Finally the 10K potentiometer is used to control the display contrast.

Photo on the right shows the backpack I created for my LCD (I’ll cut the board later along the marked lines). Notice that because the board will be mounted “upside down” the outputs from the shift register to LCD are reversed, but it’s easy to correct it in the code (Shifter74Hc595LiquidCrystalTransferProvider constructor has the optional BitOrder option).

Below you can find a list of methods exposed by the LiquidCrystal class:

Begin(columns, lines) - Use this method to initialize the LCD. Specifies the dimensions (width and height) of the display.
Clear() - Clears the LCD screen and positions the cursor in the upper-left corner.
Home() - Positions the cursor in the upper-left of the LCD.
SetCursorPosition(column, row) - Position the LCD cursor; that is, set the location at which subsequent text written to the LCD will be displayed.
ScrollDisplayLeft() - Scrolls the contents of the display (text and cursor) one space to the left.
ScrollDisplayRight() - Scrolls the contents of the display (text and cursor) one space to the right.
Write(text) - Writes a text to the LCD.
Write(buffer, offset, count) - Writes a specified number of bytes to the display using data from a buffer.
WriteByte(data) - Sends one data byte to the display.
CreateChar(location, charmap)

And its properties:

Backlight - Turns the LCD backlight on or off.
BlinkCursor - Display or hide the blinking block cursor at the position to which the next character will be written.
ShowCursor - Display or hide the LCD cursor: an underscore (line) at the position to which the next character will be written.
Visible - Turns the LCD display on or off. This will restore the text (and cursor) that was on the display.
Encoding - Get or set the encoding used to map the string into bytes codes that are sent LCD. UTF8 is used by default.

Finally let’s look at the sample code. Here is a simple “hello world” demo:

public static void Main()
{
    // create the transfer provider
    var lcdProvider = new Shifter74Hc595LiquidCrystalTransferProvider(SPI_Devices.SPI1, 
        SecretLabs.NETMF.Hardware.Netduino.Pins.GPIO_PIN_D10);

    // create the LCD interface
    var lcd = new LiquidCrystal(lcdProvider);

    // set up the LCD's number of columns and rows: 
    lcd.Begin(16, 2);

    // Print a message to the LCD.
    lcd.Write("hello, world!");

    while (true)
    {
        // set the cursor to column 0, line 1
        lcd.SetCursorPosition(0, 1);

        // print the number of seconds since reset:
        lcd.Write((Utility.GetMachineTime().Ticks / 10000).ToString());

        Thread.Sleep(100);
    }
}

~~You can download the source code for this project below. Please keep in mind that not all functions are implemented yet, and some other are not tested.~~

Update 2010-09-06: Eric D. Burdo figured out how to use this library with LCD from Seedstudio Electronic Brick Starter Kit. The connections were a little tricky but he shows the proper pin assignment for the GpioLiquidCrystalTransferProvider in his blog post. Thanks for sharing!

Update 2010-09-22: The library is now available on CodePlex at http://microliquidcrystal.codeplex.com/

.NET Micro Framework – Netduino Controlled Servo Robot

Szymon Kobalczyk — Tue, 31 Aug 2010 17:24:23 GMT

For my next project I decided to try to upgrade my SERB robot that I showed here last year to use Netduino. This robot was designed by great inventors from oomlout and you can buy it as a nicely packaged kit from them. However because the design is open source you can also download the project files and if you have access to a laser cutter order all the acrylic pieces there. It is also very easy to build following the instructable (you can find few more photos from my build here).

The original SERB robot uses Arduino as its brain, so it was quick upgrade to Netduino thanks to the same form factor and pin layout. On the above photo you can see the Netduino is mounted on the back below the prototyping shield. Oomlout’s instructable suggests to use separate 9V battery for the board, but I found that it works just fine using only 4xAA batteries to power whole setup (Netduino, Servos and Xbee).

Robot drive system

The robot is driven by pair of continuous rotation servos. You can buy such servos from various hobby electronics and robotics shops, but most ordinary servos can be modified this way. Some require to remove potentiometer and replace it with resistor divider, while with others you can leave potentiometer in place but release it from rotating and hold it in centered position. You can do it even with tiny servos. Either way you get a very cheap high torque reversible DC gearmotor. And the best part is that you can control it just as any other servo using PWM, with no need for additional motor driver circuits. Thus I could use the Netduino Servo class that was already written by Chris Seto (I only adjusted the pulse range so it matches default values from Arduino Servo library).

But with all good said above, the one drawback with using a servo is that we don’t have a much control over it’s speed. For most values it will jump right to the max speed. I made few test measuring how far my robot would drive at various power levels (by setting servo from 0 to 90 degrees). As you can see on the graph below for values above 20 it will always drive at maximum speed. However for values from 0 to 16 the speed increase is almost linear thus in my code I’m scaling the speed values to this range. I’m also using a timer to ramp up the speed in smaller increments so the robot doesn’t accelerate or stop to fast. Please keep in mind that this works well with the particular model of servos I’m using (Futaba S3001) but you might need to adjust it for your robot.

I encapsulated the code used to drive the robot in the Serb class located in the NetduinoSerbDemo project. It controls both motors and provides helper classes for various commands. The class RandomTest implements a simple random movement pattern using these commands.

Joystick

Now that we know that the basic drive operations work we can build some applications on top of it. Before we make the robot go around in full autonomous mode (which requires adding few more sensors so robot can navigate in its small world) lets drive it manually with remote control. It would be nice to have some kind of joystick for it, wouldn’t it? Sure you could use the Sparkfun’s joystick shield (which you need to modify a little bit). But since I don’t have one at hand for this project I’m going to use a Nintentdo Wii Nunchuck (besides oomlout uses the same in another instructable).

You see, smart people found out that Nintendo accessories are communicating with Wiimotes using the I2C bus, so it’s quite easy to interface with them from the microcontroller once you know the protocol. There is also available a handy adapter called WiiChuck that plugs directly to Arduino. In the end it’s a cheap way to get a good quality device with analog stick, two buttons and an accelerometer. I bought mine for under $10 – it’s not original but works just fine.

The I2C pins on Netduino are in the same place as on Arduino (SDA on analog pin4, and SCL on analog 5), but Arduino can be also set to provide required power on neighboring pins (analog pin 2 for ground, and analog pin 3 for +5V). It seems that this can’t be done on Netduino so I had to plug the adapter to the breadboard and wire it properly instead.

The second project called NetduinoSerbRemote contains the WiiChuck class with my implementation of .NET MF driver for Wii Nunchuck. It is based on the oryginal code by Tod E. Kurt, but I extended it with information found on WiiBrew, Arduino and other forums. For example it implements motion calculations to calibrate the accelerometer output (found in the oomlout version). It also has new I2C device initialization procedure that should disable encryption (this might improve compatibility with some wireless Nunchucks).

After creating the WiiChuck instance, you simply call the GetData method, and it will return true if it succeeded, or false otherwise. Then you can get the extracted values from properties representing position of analog stick, buttons, and accelerometer. For the robot I’m simply mapping the joystick position to directly to speed and direction. Another mode is activated when you press and hold the Z button. Then it will use values from accelerometer instead of the joystick.

Remote control

Looking at the previous photos some of you might already guessed that I’m going to use XBee radios for communication from my remote to the robot. In fact this is the easiest way to add wireless communication between two microcontrollers. It uses serial ports, thus you only need to connect the corresponding UART pins to the radios to get it working.

Note that there are several models of XBee modules on the market. Some provide many advanced capabilities including mesh networking. But if you are going to use them only to transmit data from one device to another you should get an older version now called XBee 802.15.4 (series 1) that can be easily configures for point-to-point networking. I got mine from Adafruit with corresponding adapters that make it easy to plug the module on breadboard or directly to the USB FTDI-TTL-232 cable. You can learn much more from Lady Ada’s website and from Tom Igoe’s book Making Things Talk.

In this project I decided to use UART1 on both Netduinos, so I put a wire from Netduino digital pin 0 to TX pin on XBee, and from pin 1 to RX (and of course connected it to +5V and ground as well). For communication I adapted the simple protocol used in yet another instructable from oomlout. Each message begins with header ‘AAA’, followed by single letter command code, and optional parameter. Thus messages are always 5 bytes long. Here are currently implemented command codes:

private static class Command
{
   public const char Unknown = '?';
   public const char Forward = 'F';
   public const char Backward = 'B';
   public const char Left = 'L';
   public const char Right = 'R';
   public const char SetPower = 'P';
   public const char Stop = 'S';
   public const char SetSpeedLeft = 'X';
   public const char SetSpeedRight = 'Y';
}

On the Netduino acting as the remote the values are read from Wii Nunchuck, mapped to SetSpeedLeft and SetSpeedRight commands, and send to serial port. On the other side the SerbRemoteClient class parses incoming data, and interprets these commands accordingly. I hope the code will be easy to follow for everyone.

The solution also contains a very simple WPF application that I used for testing. To use this app I connected one of the XBee modules to PC via with FTDI USB cable. The name and baud rate of the serial port can be set in the app.config file.

Here is the source code for this project:

First day with FEZ Mini Robot Kit

Szymon Kobalczyk — Thu, 25 Feb 2010 01:49:51 GMT

Yesterday I picked up a nice package from TinyCLR.com. Yes, it is yet another robot (third in fact), but this time it runs .NET! How freaking cool is that!

This robot is controlled by FEZ Mini board that runs .NET Micro Framework. What’s interesting is that this board has pin-out compatible with Basic Stamp from Parallax. You can also uses it easily on a breadboard for prototyping (just like Boarduino). TinyCLR.com also offers a larger board called FEZ Domino that has pin-out compatible with Arduino so you can use your existing shields. It is more expensive but notice that this board already includes microSD card reader and USB host connector. Both boards are based on USBizi chipset from GHI Electronics that in turns runs on 72Mhz NXP ARM processor.

But the huge thing for me is that I can program this robot in Visual Studio and benefit from all the debugging goodies (breakpoints, variable inspection, stepping, etc.).

The robot kit itself comes from INEX Robotics – company that makes many interesting educational kits for robotics and electronics. Over there the robot kit is called POP-BOT and only difference is that it is controlled by Arduino compatible board. But you can also download the POP-BOT Manual that has 130 pages of many cool project ideas (line tracking, object avoiding, controlling servo motor, and serial LCD). I’m sure it will be lots of fun converting these projects to .NET Micro Framework.

Two reflective sensors are included in the kit (useful for line following and edge detection projects), and you can order additional components both from TinyCLR.com and other robotics sites. Many construction parts are included in the kit so it is very easy to attach additional sensors or other parts. As you can see on the picture above, I already added a Sharp IR distance sensor in front (so I can teach the robot to not bump on walls). I also added an Xbee expansion board on the back so one day I can control the robot remotely (and my Holy Grail is to connect the robot to Microsoft Robotics Developer Studio).

Here is a video of the robot running the default program:

And here is my little robot builder crew at work:

Of course both FEZ Mini and FEZ Domino boards can be used not only for robotics, but also in many different applications. Go to the TinyCLR.com website and check out the Projects tab. For quick introduction to .NET MF you should also download the Beginners Guide to C# and .NET Micro Framework, free ebook from Gus Issa.

In my previous post I complained how upset I’m that there is no cheap .NET Micro Framework hardware for hobbyists. Now I can take it back. IMHO we finally have a very powerful alternative to Arduino and similar platforms, with the price that won’t break the bank (especially with FEZ Mini).

More fun with robots

Szymon Kobalczyk — Mon, 06 Jul 2009 02:27:46 GMT

Last Friday I’ve received new Futaba S3001 servos. Turns out they are more easier to modify to Hitec’s, and at the same seem more reliable. I’ve simply followed this Instructable, and you can also find some additional photos in my gallery. What most important the servos are also easier to calibrate, so now my SERB will actually stop in place when I want it.

Below is a short video of the completed SERB robot where it just runs in random directions:

This weekend I’ve also started looking at Microsoft Robotics Development Studio 2008. This environment promises easy entry level to robotics. However this is true only when you have a compatible robotics platform (like Lego Mindstorms NXT, fishertechnik, iRobot and few others). There are pretty good tutorials on how to control these robots both from C# and from VPL. However before I can apply them to my SERB robot, first I need to implement the hardware interface and generic services to control the robot. Not much information on this and closest what I found so for is the Robotics Tutorial 6 – Remotely Connected Robots. It would be cool to get more detailed example on writing such services, but fortunately source code of services for other robots is included. In particular I’m trying to understand the code for iRobot and this additional service for VEX Robotics. If you know of any other good examples or tutorials please let me know.

Building Arduino Controlled Servo Robot (SERB)

Szymon Kobalczyk — Thu, 02 Jul 2009 00:05:25 GMT

Few weeks ego we went to an exhibition in one of Kraków’s malls to celebrate the 100 year anniversary of robotics. Besides some nice exhibits there was also a place where kids could try to build a robot from Lego Mindstorms NXT and Fishertechnik sets. We spent few hours there with my older son Jaś and even managed to build a walking robot.

It was fun for both of us so I started looking if we could continue playing with robots at home. Unfortunately most of the sets I found are pretty expensive (starting at $200). This is where my good pal Marcin Książek turned me to the Arduino electronic prototyping platform.

Arduino is really a simple and cheap microcontroller kit that can be easily connected to a PC and programmed. What makes it fun is that there are also many extensions that come as “shields” and adapters for the board and add capabilities such as XBee and Ethernet communication, accelerometer, DC motor control, GPS or even a touch LCD. The platform is open source so there are tons of information and fun projects on the web. Good place to start would be the Arduino Experimentation Kit (ARDX) – you can buy the kit from oomlout, but it’s also open source so you can download all guides and buy the parts in your local electronics store yourself. I also enjoy reading the book “Getting started with Arduino” by Massimo Banzi. And make sure to send the Arduino gift guide to your relatives. There are even Arduino user groups such as Howduino in Liverpool.

[In Poland you can buy Arduino from Nettigo]

All of this makes Arduino a great basis for building a simple robot. And in fact there is already a project on Instructables that shows exactly How to build a Arduino Controlled Servo Robot. Again this project is open source so you can buy a kit from oomlout or download the blueprints and find all the parts yourself. The body of the robot is done from acrylic sheets and I found a local shop with a laser cutter that could cut the parts for me. Most of the other parts can be easily found in your local DIY store.

One exception are the servo motors. Normal servos for RC models are constrained to movement in 180 degrees range, but what we need here is a “Continuous Rotation” servo. You can get one that was pre-modified such as Parallax, GWS S35 or Hitec HSR-1425CR. Another option is to modify the servo yourself, and there are also many instructions on how to do it on the web. I found that it’s really not hard to do, but you have to work a bit on the calibration.

So having all the parts I could finally begin the assembly. Below you can see is a photo gallery where we build our first SERB robot. As you can see I’m one happy geek dad, because both kids were pretty interested with this.

Right now the robot can’t do much besides running around in random directions, but I have some plans to make it smarter.

Add remote control via Xbox pad or WiiMote. There is already a project showing how to use a netbook to control the robot via Skype. But being a .NET geek I would like to use Microsoft Robotics Studio for this.
Add wireless connection with XBee so that robot can roam freely without cables the but still being controlled from the PC.
Add some sensors so the robot gets more information from the world. I think first I would add bumpers to detect obstacles as shown in this project. Later I might also add wheel encoders (such as Nubotics WheelWatcher) for odometry.
Play with some AI algorithms.

So it looks like I already have found myself a summer project :-)