Lego Mindstorms NXT, Robots and Other Blurbs ....

Mindsensors' Numeric Pad

2010-11-12T18:43:00.000+01:00

Last week I received the new Numeric Pad from Mindsensors to test. It has 10 digits (0...9) a "*" and a "#" key. The keyboard can be operated without actually pushing buttons. They sense the presence of your finger. Great ! To give some feedback that the key was pressed, I added a 'beep' to the software.

To give it a spin I created 2 contraptions. The first was a simple calculator. It consists of an NXT and the keypad. Nothing fancy, but it does work.

The second is a gate that is locked with a code. If you enter the correct code the gate opens, if not it stays closed. I used the colorsensor to show the state : Blue = Initializing / Red = don't drive / Green = drive

Nissan Patrol - WIP

2010-07-29T11:55:00.002+02:00

Inspired by Sariel and ATR, I wanted to build my own scale model of an off-road jeep. I chose the Nissan Patrol 4x4 (model 1980) and want to build it on scale 1:13. This has proven hard work with many changes and restarts to make something that actually works and fits in the limited space, but I think I am making good progress. The chassis, steering mechanism and drive train are ready.

Here is a video of the tests I have done so far :

I hope it will be good enough to participate in a TruckTrial :-)

Brickmania 2010

2010-05-16T21:32:00.002+02:00

Today I visited Brickmania, an event organized by the Belgian Lego Users Group in Wetteren (Belgium). The event itself was relative small in size, but that doesn't mean it wasn't fun or interesting. During my visit I made following video

1 NXT, 5 Motors

2010-04-30T21:37:00.009+02:00

Mindsensors is developing a new multiplexer which allows to connect 2 extra engines to the NXT. It is a complex device that has its own built-in controller and needs a seperate power supply. How does it work ? You connect it to any of the NXT sensor ports for the communication, connect 1 or 2 engines to the multipler and hook up the batterypack with 6AA batteries. To control the engines you need software that can be downloaded from the Mindsensors website, including some test programs. Controlling the engines is pretty similar to controlling the standard engines because the microcontroller on the multiplexer handles the intelligent part. It reads the motor encoders and therefore allows you to accurately control the number of rotations, time, speed of any of the engines. Furthermore you can still connect a sensor to the port, since the multiplexer has a pass-through connector that allows you to add an I²C connector to that same port. Pretty neat !

Here is a little video that was meant as a teaser

Ground control to Major Tom

2010-02-28T18:46:00.006+01:00

Debugging microcontrollers has always been a challenge for us, mere mortals. You can of course buy an in-circuit debugger, but this will cost you a few hundred bucks. Given that most microcontrollers have a serial connection (USART) built-in, a cheaper solution is to build a cheap, simple RS232 interface to your computer. Two problems :1) modern laptops don't have an RS232 connector anymore. 2) We build robots and they move around making a cable a bit of a nuisance, so we wanted to have a wireless connection to our PC. Several options exist : Wifi, Zigbee/Xbee, FM, ... but we decided to build a bluetooth connection using a BlueSmirf module (Sparkfun). This modules has a serial interface at TTL level and can be directly interfaced with the microcontroller and emulates a virtual COM port on the PC where you can read/write to it using a terminal program.

The hardware implementation was straigtforward : connect the +5V, Ground, connect RX to TX, TX to RX and you are good to go.

The pairing was straightforward : let your PC search for new Bluetooth devices, enter the password and Windows will do the rest. All you now need is a terminal program (e.g. Hyperterminal or Putty), choose the correct virtual COM port, set the baudrate and other settings correctly. That's all. Sadly enough that leaves you with a blank screen. One more step ...

The last part is the hardest : write the code for your microcontroller. Luckily there are very good examples to be found. Like this one for the Arduino. I decided to use a Microchip PIC (18F4550) and write the code in MPLAB C18 (the student version). C18 has a library to interface with the hardware USART module, making it easy to write programs. Reading can even be done via an interrupt routine or simply by polling the input queue. An afternoon of searching, trying and coding and ... tada ... I could send messages from my PIC to PC and vice versa.

One drawback is that I need to power-on the PIC (with BlueSmirf) first, then PuTTY on the PC. At that moment the PIC can send messages to the PC. To allow the PC to send messages to the PIC I need to reset the PIC after PuTTY has started. Not too much of a problem, but something to keep in mind. Some other wireless systems are less sensitive to the order in which the programs are started.

Anyway, not bad for an afternoon of fooling around, even if I say so myself !

Lego Crane Truck 8258 NXTfied

2010-02-21T18:50:00.007+01:00

Remember the truck I got for Christmas ? Remember that I wanted to automate it ? Well, the job is done, the movie made and the pictures taken. The brain of the truck is a NXT which controls the driving and steering motor directly, but also controls the 3 PowerFunction engines I used for the Crane. Instead of using the standard remote control of the PF engines, the NXT uses a HiTechnic IRLink to control speed and direction of the engines. The entire truck is controlled from my mobile phone via Bluetooth. The software for this was written by Alexander Demin. We made some changes to the portion that runs on the NXT to allow the commands from the phone to be interpreted correctly.

Here are some pictures and here is a video of the truck in action.

WOLL-Y : Wake On LAN Appliance

2010-01-09T19:16:00.009+01:00

Sorry, No LEGO this time, Guys & Gals…
A friend of mine had decided to build his own DVD/Hard disk recorder based on a PC with Linux and a TV card. This turns out to be a very cost-effective and future-proof solution that allowed to add many features. However it had also one disadvantage : the PC had to be switched on before the recording would start. Not very power friendly. Some experimenting showed that it was possible to turn on the PC using a the 'Wake-On-LAN' feature in the BIOS. Having one PC switch on another was obviously nonsense, so the idea grew to develop a power-friendly, microcontroller based little appliance that could send a 'Wake-On-LAN' signal to the PC at predefined times.

The appliance we built is based on a microcontroller (PIC 18F458) with an extra Ethernet interface. Via this interface the device will receive commands from a host computer. These commands allow the user to specify at which times which computer has to be turned on, sort of an alarm clock with repetitive alarms. WOLL-Y will then issue so called 'Wake-On-Lan' Magic packets at the preset times and send them to the desired computer (identified via its MAC address). To allow WOLLY to determine the time it has a battery backed up real time clock. All configuration is stored in non-volatile RAM (either EEPROM or battery backed up RAM). To allow monitoring of the health state of WOLLY, the device has a status led and will send broadcast UDP packets at preset intervals containing its basic settings.

The PC user interface is written in Qt4 and automatically finds WOLLY on the LAN (by looking for the packets WOLLY broadcasts) and then allows to read the current config and add/remove or change entries in the table.

More detailed information, the circuit, the PC software and firmware can be found [HERE]

Thanks, Santa !

2009-12-30T14:47:00.004+01:00

After a period of turkey dinners and unwrapping gifts, there is finally time for a new challenge. Don’t misunderstand me, I don’t hate opening presents at all, and certainly not when the presents turn out to be Lego! Shrewdly I started mentioning that I fancy the new Lego Technic Crane Truck (8258) several months ago. On December 25th, when I opened my present, there it was!

So I started building the box and in the mean time I also discovered the technical functions of the crane and how they work. Pretty cool, I thought. I took some pictures of the original truck.

The only thing I don’t like is that there is only one motor inside. But wait a minute !!! Somewhere in the house, there should be a NXT lying about. Perhaps I can use that one ?

Stay tuned !

Mindsensors’ PowerMeter as Morse Decoder

2009-12-29T21:36:00.006+01:00

After finishing the multimeter project and seeing some other creations from Xander S. and Andy M., I thought we had used the Mindsensors’ PowerMeter to its limits : reading voltage/current, logging it or displaying it graphically. However, during a walk on the beach, it dawned on me: this is not ‘just’ a power meter, it is the sensor of all sensors, the must-have for all Robotics and Electronics fanatics. With the PowerMeter extending the NXT with a special sensor becomes a no-brainer. Most electronic sensors work by varying voltage or current. The PowerMeter is actually a generic A/D converter for the NXT which allows you to quickly and safely interface your home-made sensor to the NXT. It is even a bit more than that, since it has a built-in timer you can use as well and in this example we will. Measuring distance, temperature, humidity, … all becomes easy with the PowerMeter.

Once I realized this, I was up for a new challenge. To keep the electronics simple, I made a light sensor for the PowerMeter with a photodiode and a resistor. As transmitter I use a simple flashlight. The circuit shown here is not very critical. In fact I left out C2 and R4. I first used the multimeter program from the previous project and learned that -depending on the surrounding light- the ‘dark’ value was 1350 mV, the ‘light’ value was 20 mV. I decided to use 20% of the dark value as threshold between light and dark.

Instead of using the RobotC drivers, which I created for my previous PowerMeter project, I wanted to use LeJOS for this one. LeJOS is a Java Virtual Machine for the NXT. Java promises cross-platform portability ("Write Once, Run Anywhere") and this is partially true. LeJOS allows to create programs in Java that run entirely on the NXT, partly on the NXT and partly on the PC or completely on the PC. This means that instead of needing different programming environments if you want to communicate between NXT and PC, all can be done from the same environment. However, there is a catch. Some parts of LeJOS are very sophisticated, while other parts are very basic. Most notably, LeJOS has no IDE. It is all command line based and even the firmware for the NXT has this same basic look-and-feel. Most of this is not a real issue and you can use your preferred development environment. For me that is Eclipse.

First I created a new Java class ‘PowerMeter’ that contains all the code to interface with the sensor. This class is the basis for all other programs. I must admit that interfacing with I²C turned out to be very simple in LeJOS. Then I rewrote the multimeter program in Java as proof-of-concept. Now was the time for the real work. Several hours, crashes and lots of coffee later, the Morse decoder was born. The usage is simple. First you learn the NXT what a ‘short flash’ and a ‘long flash’ is. Then the NXT starts waiting and every time a short pulse is received it takes is as a DOT, a long pulse as a DASH. Once a full character is received – the end of a character is denoted a dark period equal to 3 short pulses in time - the character is decoded using a simple lookup table.

The code is available here.

Mindsensors' NXT PowerMeter

2009-12-22T17:45:00.010+01:00

Mindsensors currently has a new sensor in beta. It is a sensor which is a bit out of the ordinary. It is not to make robots or automated devices, but it is more a tool to help in electronics. It allows to measure current and voltage used either by the NXT brick itself (using the provided probes) or an external circuit (without using the probes). The firmware of the sensor is not completely finished yet which means some of the features are not available yet. However, even in its current state it is a marvel ! It can measure up to 13.5 volts and 3 amps.

I decided to start slowly and created a simple circuit with a 9V battery, one fixed resistor of 50 ohm and one variable resistor of 1K. Since the battery is a rechargeable battery I measure around 7-8V, which is normal and the current depends on the variable resistor. After trying the provided NXC program written by Deepak, I decided to convert it into a RobotC library. I used the same naming convention as Deepak's NXC library. Once I got it working, I added all routines to read all registers of the NXT PowerMeter, so that the library is ready for future expansion (meaning when Mindsensors adds features to the firmware)

Finally I wrote a program that turns the NXT into a simple multimeter. It shows the device ID, vendor ID, firmware version of the PowerMeter along with the measured current and voltage. Using Ohm's Law it is easy to calculate the resistance from this. The NXT shows those 3 values but by pressing the buttons you can change which one is shown in a big font. The other 2 are shown in small fonts. It also displays the internal timer. The PowerMeter has an internal timer in msec which can be reset.

The video is available on YouTube, the software on the Mindsensors website.

CommLib + GCC + QT4 = NXT Remote control

2009-12-22T12:17:00.007+01:00

By coincidence I stumbled on Anders' Mindstorms website where a library was available to communicate between the PC and NXT via Bluetooth. There was a testprogram available so I decided to give it a spin. I downloaded the MinGW framework -GCC/G++ compiler for Windows -made a simple testprogram based on his example. After changing the code to the correct COM port, the example worked instantaneously. However it used an ugly console window.

So I decided to push my luck a bit and make a graphical userinterface for it. Graphical as in a GUI ? Yep. But coding a windows UI from scratch is not for those with a weak heart, so I needed a framework that would handle the nitty-gritty details. Several exist and I used a few of them : wxWidgets, Qt and -yes even- the MFC. Over time I became a fan of QT. This is a crossplatform application platform which includes a GUI (amongst others) and works on Windows, Linux, Mac, Windows CE, Symbian, .... . It was created by TrollTech and the first version was released in 1991. A few years ago, Nokia bought the company. The frameworks remained open-source. In the old days I used it only on Linux, because the version for Windows was a commercial license. However, since version 4 it is now also free of charge on Windows. Maybe it has nothing to do with the version as such, maybe it is like this since Nokia bought TrollTech. Not sure ...

One of the neat things of Qt is that it is a very consistent framework. At first glance it looks scary, but in fact it is very neat, clean and straightforward. The key to understanding it is 'signals' and 'slots'. An object can generate signals and other objects can intercept those signals by connecting one of their methods to a so-called slot. When the first object generates a signal, the framework will call all routines that are connected to it. This mechanism is used throughout the entire framework (not just for the GUI, but also for system routines) and once you understand it, it makes all the rest a walk in the park. A lot of examples are provided to guide you through the maze from simple to complex. Amazing how easy it is to use.

Here is a simple example : A pushbutton that calls one of my methods when clicked

1:     QPushButton *leftFwd = new QPushButton(this);
2:     leftFwd->setIconSize (QSize (60,60)) ;
3:     leftFwd->setIcon (QIcon("images/leftForward.png")) ;
4:     leftFwd->setGeometry (10, 40, 60, 60) ;
5:     connect(leftFwd, SIGNAL(clicked()), this, SLOT(leftForwardEvent()));

On line 5 it reads : connect the signal ‘clicked()’ of the object ‘leftFwd’ to the slot ‘leftForwardEvent()’ of ‘this’ object.

Anyhow... To cut a long story short. After a day of coding and tweaking I ended up with a simple graphical UI for my robot that works pretty neat !

The source code can be found here