Netduino

Over the last few weeks Harford Hackerspace has had the pleasure of beta testing the Netduino. The Netduino is a development board with a form factor similar to the Arduino. Care was taken when designing the Netduino to ensure compatibility with most of the existing Arduino shields. That’s about where the similarities of the two devices ends.

The Netduino uses Microsoft’s Open Source .net Micro Framework SDK along with Visual Studio C# (or VS C# Express) as the primary development environment. C# application developers will be able to quickly adapt to the .net Micro Framework and start programming microcontrollers in a matter of minutes. However, this does not let them off the hook for learning the basics of electronics.

After downloading and installing Visual Studio C# Express 2010, the .net Micro Framework 4.1 SDK , and the Secret Labs Netduino SDK we started with the “Hello World” of microcontrollers and blinked the on-board LED. That was easy…! You’ll be able to get details to do this yourself from the Netduino website.

SparkFun Color Sensor

ADJD-S371-Q999

The ADJD-S371 is a 4 channel RGB+Clear sensor and uses the 2-wire I2C protocol to communicate with the microcontroller.  It’s a complex little device that will test your puzzle solving skills. What I mean is that the device does not simply give you the correct color when you ask for it. You’ll have to play around with the Gain calibration algorithm and come up with something that works best for your application. However, for simple testing purposes you can use the code described in this tutorial. Here’s a quick video to demonstrate the project:

The code was originally created by Nathan Seidle for the PIC microcontroller and was ported and modified for the Arduino by Marcus from Interactive Matter. Paul King and I ported it once again to the C# Language for the .net Micro Framework.

Click to Enlarge

C# Code

Lines 1 through 6 define a namespace. This allows you to use classes or types without having to type out the full namespace where those types exist. For example, instead of typing:
SecretLabs.NETMF.Hardware.Netduino.Pins.ONBOARD_LED
We can simply type:
Pins.ONBOARD_LED

Lines 7 through 33 are constants defined in the Color Sensors documentation. Line 35 creates a new I²C device object named rtc. We use this object to actually send the data from the Netduino to the Color Sensor. I²C is a bus protocol which means that multiple devices can share the same wires. So the I2CDevice object requires us to give it a slave address. We defined this as the constant I2C_Address on line 11. The I2CDevice object also requires us to specify a rate in Kilohertz(Khz). 100Khz seemed to do that trick. We tried other speeds without much luck.

Line 37 creates a variable of type byte array. Note that we are only initializing the size of the array to 1. The color sensor does not actually need an array of bytes but the I2CDevice.CreateReadTransaction requires a byte array as one of its parameters and does not have an overloaded method for using just a byte.

Lines 38 is the main entry point for our program. On lines 40 through 42 we setup 3 pins which we are using to control an RGB LED. By adding the SecretLabs.NETMF.Hardware.Netduino.dll to our list of resources and declaring it with the using statement on line 6 we don’t have to remember the actual microcontrollers pin numbers. SecretLabs has already looked all this up for us and they allow us to use Pins.xxxxx. You notice that the intellisense aka code complete feature of Visual Studio automatically pops up a context menu allowing you to select from a list of available pins.

[*UPDATE: If you use the SecretLabs SDK Installer you can start a new "Netduino Application" which removes the need for manually adding the dll's to your resource list and also removes the need to manually add the SecretLabs using statements.]

On line 56 we create an infinite loop so that our program never ends. Without this our program would only run once and then terminate.

Lines 58 through 64 is where you could get creative. The color sensors datasheet and application note are a little fuzzy on explaining the proper way to calibrate and set the gain of your sensor. However, you MUST set the gain for each color before you request the color. If you fail to set the gain then you will get low results. We learned this the hard way. We just could not figure out why we only got numbers from 0 to 3!

Lines 65 through 78 is where we sample the colors through the use of a few helper methods which you’ll read about below. The key thing to note here is that the more samples you take the more stable your numbers will appear. We are taking 10 samples and adding the results together and dividing by 10 to get the average value.

Lines 80 through 93 is where we set the color of our RGB LED. We are using a very simple algorithm to determine the most dominate color and turning on just that leg of the RGB LED. We experimented with mixing colors but our LED was not diffused enough to mix the colors together. We were able to see the individual colors which did not have a good effect.

On Line 95 we call Debug.Print and output the values to Visual Studios output window. The clear value indicates an overall light intensity which the Red, Green, and Blue values are the intensity as seen through a light filter.

Now we start getting deep into the color sensors protocol. To tell the color sensor to take a sample we set the register 0×00 to the value of 0×01. The color sensor then takes a sample and stores it.

The color sensor stores its color values in two 8 bit registers. So. on lines 103 through 106, get_readout() takes the first register as a parameter and assumes the next register is just 1 more address above that register. So we read the value of the first register and then read the value of the second register and then shift the value of the second register 8 bits to the left leaving us with the full 16 bit integer. However, only 10 bits are actually put into the integer because the High registers only return the two least significant bits and the Low register returns 7 Bits.

Each color has two of its own gain registers. We defined these in our constants in the first few lines. Here we again assume that since we know the register address of the lower register, we can just add 1 to that address to get the higher register address. Then we assign the gain values through the help of set_register().

set_register is where the magic happens. Here we create a new byte array which contains two values. The first is r for register and the second is v for value. We pass this byte array to a new I2CDevice.CreateWriteTransaction object and then pass that object to the rtc.Execute method. You should recall that rtc is our I2CDevice object which knows about the slave address of our color sensor. So, in a nutshell our set_register function is where we package everything up and send it on its way.

On Lines 127 through 136 we are sending a request for our color values. We pass it ‘r’ which is the color we want to read. Remember that this happens twice for each color in order to get the full value. We wait 5000 milliseconds or 5 seconds for the return before we timeout.

Lines 137 to 174 is where you can again play around to perfect your results. You’ll need to derive a way to obtain a gain value which compensates for the ambient light and all the other environmental factors which may change the sensitivity. I’ll be honest. I’m not too sure what is going on here. You should check out Interactive Matter for more information about this method.

Finally, lines 175 to 220 tries to establish a suitable gain for each color. This will be called 3 times because each color has a different sensitivity. You can get creative here and come up with your own algorithm which suits your specific application. If you had a controlled environment then in theory this would be very simple. Make sure you post back here and let us know if you stumble across a better way to determine the gain values.

Me and my wife recently had our first child.  I’ve been trying to come up with some projects I can do for the kid.  Well, around this time of the year the fireflies go crazy around my house, so we came up with the idea to do led fireflies in a jar.  It should be something cool for him to stare at and is easy to build.

Schematics, C source code and hex file are available here on our wiki.  If you want to build one it should only take about an hour.

I’m planning on making a version 2 with some changes, stay tuned for that one.

[Show as slideshow]

PicKit2 Debug Express

Around the space, we have been using the PICkit 2 Debug Express quite a bit lately.  This has allowed us to get pretty cozy with the functions of this handy little programmer and I thought I would share some of these features with you.

I’m sure you’ve read the previous tutorial ‘Programming PIC Microcontrollers in C‘, if you haven’t, you should go familiarize yourself with it now.  Continuing on from there, after we have a successful build of a led blinking we can use the PICkit 2 to program our chip via the ICSP header.

Our Debug Express Kit’s came with a Demo Board which has a 44 pin PIC16F887 microchip. The microcontroller is connected to a 6 Pin Male header called the ICSP (In-Circuit Serial Programmer) header.  All PIC microcontrollers with the letter “F” in their name can be programmed this way, even if you are using a breadboard and wires to make the connections. The “F” stands for Flash.  Maybe in a future article we will show you how to construct the ICSP header from the data sheet, but we will just assume you are using the 44 Pin Demo Board for now.

You should already have the PICkit 2 connected to your PC via the USB port, so after a successful build of our program, we can program the chip by selecting the ‘Programmer’ menu from within MPLAB, and then selecting ‘Select Programmer’, then ‘PICkit 2′.

At that point below in the debug window you should see a message such as ‘Found PICkit 2 – Operating System Version 2.32.0 …’ If you do not, select ‘Programmer’ then ‘Connect’ from MPLAB.

Finally we select ‘Programmer’ then ‘Program’, and it should start erasing and programming the chip.

Lastly, one tip that speeds up the programming process is to go to the ‘Programmer’ menu and then click ‘settings’. Then check the boxes ‘Program after a successful build’ and ‘Run after a successful program’.  Once you do that you can just hit F10 to compile and flash the pic over and over as you make small adjustments to your code.

In the end, this simple task is actually quite convenient. Being able to program a chip in-circuit, instead of taking the chip out of the socket, putting it in a programmer, programming it, taking it out, putting it back into the other socket, turning on, etc.

Finally, an often overlooked feature is that the PICkit 2 will power your chip if it doesn’t detect any voltage, which for me personally is the case before I have a power supply set up.  I wouldn’t overdue it, you can power small things, led’s, tiny motors but don’t try to draw too much current from it.  The maximum power draw is 200-300mA less than the USB port puts out, which in most cases is around 500mA leaving you with 200-300mA.  So don’t try to overdue it, if you’ve got a lot of power draw in your circuit, set up your own power source and the PICkit 2 will detect the voltage during program and wont try to power it.

Happy Hacking!