PIR module for .NET Gadgeteer (Motion Sensor)

24 Friday May 2013

Posted by sjj698 in .NET Gadgeteer, C#, Hardware, Drivers, PIR

Tags

.NET Gadgeteer, PIR sensor, Motion sensor

(Module: http://gadgeteering.net/module/ghi-pir-sensor)

We met up last night to have a look at a .NET Gadgeteer module, picking a nice easy module to look at to begin with for: http://www.meetup.com/GadgeteerSouthCoast/. Despite being called the GHI PIR Sensor it is found in the toolbox as a “Motion Sensor”

Here is the view from the top of the module:

There is just the one event which is triggered whenever the sensor spots an IR source (Heat/person), called Motion_Sensed. There is a property that can be checked to see if the sensor can still see the source once it was triggered.

I would have expected to see a data sheen in codeplex, http://gadgeteer.codeplex.com/SourceControl/latest, but there is nothing. Next stop is the module manufacture website/forum. In this case it is GHI and I am not the first to ask questions about the PIR module:

GHI Forum: http://www.ghielectronics.com/community/forum/topic?id=6930
Datasheet: http://elecfreaks.com/store/download/datasheet/sensor/DYP-ME003/Specification.pdf
Info: http://www.elecfreaks.com/398.html

Based on this information I have labelled the POTS and jumper below.

Motion_Sensed event

First lets see how often this event gets triggered. First add code for the event:

Debug.Print("Program Started");
startTime = DateTime.Now;
motion_Sensor.Motion_Sensed += new GTM.GHIElectronics.Motion_Sensor.Motion_SensorEventHandler(motion_Sensor_Motion_Sensed);

And here is what we will execute every time it is triggered:

void motion_Sensor_Motion_Sensed(GTM.GHIElectronics.Motion_Sensor sender, GTM.GHIElectronics.Motion_Sensor.Motion_SensorState state)
{
    Debug.Print("Time span = " + (DateTime.UtcNow – startTime).ToString());
    startTime = DateTime.UtcNow;
    Debug.Print("TRIGGER");
}

By setting the time POT to min (anti-clockwise) so the events will be triggered as often as possible. (The distance POT is at the mid point). We get the following output.

Using mainboard GHI Electronics FEZHydra version 1.2
Program Started
Sensor = False
Time span = 00:00:09.9934515
TRIGGER
The thread ‘<No Name>’ (0×3) has exited with code 0 (0×0).
Time span = 00:00:07.8206963
TRIGGER
Time span = 00:00:07.7379289
TRIGGER
Time span = 00:00:06.4709773
TRIGGER
Time span = 00:00:08.7667315
TRIGGER
Time span = 00:00:07.6156723
TRIGGER
Time span = 00:00:06.2445184
TRIGGER
Time span = 00:00:06.6116992

By setting the time POT to max (Clockwise) we get the following output:

Time span = 00:03:42.0452275
TRIGGER
Time span = 00:03:58.3361766
TRIGGER
Time span = 00:03:41.4596557
TRIGGER
Time span = 00:03:40.7306982

So the time range is around 7sec (min) to 230sec (max) which is in keeping with the data sheet, which I think says 5 sec – 300 sec :

Changing the distance POT certainly did change range or sensitivity but it was not so easy to work out the exact trigger distances. however the datasheet shows a range or around 5 –7m and it certainly gets triggered within those ranges.

SensorStillActive property

There is a property that is readable and is of type Boolean, but what can we use it for?

If we run in with the time POT on minimum, distance on 50% and the jumper set to “Repeatedly trigger” we get the following output:

TRIGGER
State changed to: False @ 00:00:00.0011277
State changed to: True @ 00:00:02.2871399
Time span = 00:00:09.5215143
TRIGGER
State changed to: False @ 00:00:00.0650803
State changed to: True @ 00:00:02.4655180

And if we set the jumper to “Single trigger” we get the following:

TRIGGER
State changed to: False @ 00:00:00.0010278
State changed to: True @ 00:00:08.3824435
Time span = 00:00:11.9519795
TRIGGER
State changed to: False @ 00:00:00.0300698
State changed to: True @ 00:00:03.0303744
Time span = 00:00:06.5282752
TRIGGER
State changed to: False @ 00:00:00.0019021
State changed to: True @ 00:00:02.5016538
Time span = 00:00:04.7239091
TRIGGER
State changed to: False @ 00:00:00.0771596
State changed to: True @ 00:00:02.9764812
State changed to: False @ 00:00:06.4768678
Time span = 00:00:06.4945881
TRIGGER
State changed to: True @ 00:00:07.4823129
Time span = 00:00:11.0135769

So I am unsure what the jumper does, but the event is triggered when the SensorStillActive goes to false, it is held false for around 3 seconds then returns to true. The trigger happens every 6sec as expected. I suspect this will get held to false as long as the sensor can still detect an IR source, however my one always stops sensing despite being waved around at a source. Here is what the datasheet has to say about the jumper:

Have some source code:

using System;
using System.Collections;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Controls;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Touch;
 
using Gadgeteer.Networking;
using GT = Gadgeteer;
using GTM = Gadgeteer.Modules;
 
namespace CompassDriverExample
{
    public partial class Program
    {
        private DateTime startTime;
        private bool sensorState; 
           
        void ProgramStarted()
        {
            Debug.Print("Program Started");
            startTime = DateTime.Now;
            sensorState = motion_Sensor.SensorStillActive;
            motion_Sensor.Motion_Sensed += new GTM.GHIElectronics.Motion_Sensor.Motion_SensorEventHandler(motion_Sensor_Motion_Sensed);
            GT.Timer tmr = new GT.Timer(50, GT.Timer.BehaviorType.RunContinuously);
            tmr.Tick += new GT.Timer.TickEventHandler(tmr_Tick);
            tmr.Start();
        }
 
        
        void tmr_Tick(GT.Timer timer)
        {
            if (motion_Sensor.SensorStillActive != sensorState)
            {
                Debug.Print("State changed to: " + motion_Sensor.SensorStillActive + " @ "+ (DateTime.UtcNow – startTime).ToString());
                sensorState = motion_Sensor.SensorStillActive;
            }
        }
 
        void motion_Sensor_Motion_Sensed(GTM.GHIElectronics.Motion_Sensor sender, GTM.GHIElectronics.Motion_Sensor.Motion_SensorState state)
        {
            Debug.Print("Time span = " + (DateTime.UtcNow – startTime).ToString());
            startTime = DateTime.UtcNow;
            Debug.Print("TRIGGER");
        }
    }
}

I want to edit the .NET Gadgeteer drivers for a particular module!

23 Thursday May 2013

Posted by sjj698 in .NET Gadgeteer, C#, Hardware, Drivers, Debug

≈ Leave a Comment

Tags

.Net Gadgeteer drivers, debug, edit

When you drag a module from the toolbox onto the designer it references the correct DLL’s and adds import statements to the program.cs.

Fig 1: Adding a compass module to the designer.

This way you are ready to just use the module in your code. This is the normal way to to things… However what if you want to make a change to the driver for a particular module, for example to:

add an event, method or property,
perhaps fix an annoying bug,
add extra debug, or work out how the hardware works,
load a different driver, such as the GPS/Bluetooth module drivers from Codeplex.com ,
copy the driver for a similar piece of hardware,
you want to compile a driver for a different version of NetMF (e.g. upgrade 4.1 –> 4.2)
you cant be bothered to get WIX setup and working just to make a small change.

The correct way to change a driver is to get the source code VS solution, edit it and then rebuild. This will build an installer (msi) which can be installed and distributed with the changes intact. This process is fine for the final edits and distribution of a driver, but what if you just want to try a few changes? This is a long process as each change results in a build, reinstall , test.

This post is designed to show how to simply edit drivers or include different drivers. It is NOT a substitute for building the install files which should be distributed with each hardware module.

Example

Lets say we want to make an edit to the compass driver, perhaps it does not function as we expected. Here is a summary of what to do:

Get the source code. (Either the existing source, or substitute with a different one)
Remove the existing driver from your solution.
Add the (new) source code to your solution.
Add the module to your project.
Edit the driver and test.

Get the source code.

There are multiple drivers for some modules, and the alternatives can often be better. (Well at least until the manufacturer incorporates the changes into the distributed driver.)

If you are looking for other drivers try: http://www.codeplex.com/site/search?query=.net%20gadgeteer

The source for the distributed drivers lives here: http://gadgeteer.codeplex.com/SourceControl/latest

I use SVN to get the latest source, but if you just want the source then click the download button. It will give you a zip, be sure to expand it to somewhere sensible, we will be using it later.

Remove the existing driver from your solution.

This step is important as it can drive you crazy later by swapping your new driver with the old one when you least suspect it.

Here is some background information first:

If we look a the code behind the designer we can see what happens when the compass module is added.

Click “Show all files” if you cannot see the “Program.gadgeteer.cs” file. This file is generated EVERY time you save the designer (the place you drag modules onto). Inside this file there is the following code. (For this example project)

namespace CompassDriverExample {
    using Gadgeteer;
    using GTM = Gadgeteer.Modules;
    
    
    public partial class Program : Gadgeteer.Program {
        
        private Gadgeteer.Modules.Seeed.Compass compass;
        
        public static void Main() {
            // Important to initialize the Mainboard first
            Program.Mainboard = new LoveElectronics.Gadgeteer.ArgonR1();
            Program p = new Program();
            p.InitializeModules();
            p.ProgramStarted();
            // Starts Dispatcher
            p.Run();
        }
        
        private void InitializeModules() {
            this.compass = new GTM.Seeed.Compass(8);
        }
    }
}

The first line of importance creates a compass variable of type Gadgeteer.Modules.Seeed.Compass.

private Gadgeteer.Modules.Seeed.Compass compass;

The second line of importance is the one that creates an instance of the compass object and specifies the socket number.

this.compass = new GTM.Seeed.Compass(8);

In order to create the compass object it needs to know about it. This is achieved automatically by adding a reference to the compiled DLL, when you dragged in a new module.

Here are the things you need to change to remove the old driver:

1) Delete the module from the designer.

- This will remove it from the generated code and will stop the auto generated code swapping back to the old driver when you save.

2) Check that the references on your project no longer reference the DLL for the old driver. (highlighted above)

You could just start with a blank project.

The reason I show all this is that later on you will need to instantiate the object yourself. If you don’t know what to write you can copy the auto generated code … more later.

Add the (new) source code to your solution.

At this point you have a blank project or one that does NOT reference/use the module that you plan to edit the driver for. First we need to add the source code, this is the code that you downloaded earlier or can be a different driver that you wish to try.

In Visual studio right click on the solution and add an existing project by navigating to the correct project. (This can be a little confusing as it tends to be a long way down the folder structure, and you need to be sure of the version you are using, v4.2)

Inside the Compass –> software folder you are looking for the compass.csproj file. (I would expect to see 2 versions, one for 4.1 and one for 4.2, but this may not be the case if an old driver template was used.)

A little note: In this particular case there is just a driver for the 4.1 version of NetMF, yet when you install the latest SDK the compass is available in 4.2. This means that the manufacturer has updated the driver but not uploaded the changes to Codeplex. Be sure to encourage manufacturers to keep the source updated. This could also be the case if the Codeplex source code has different methods/signatures. Since my project is v4.2 I will just choose to update the target framework in the project properties.(Good example of how to upgrade versions)

Add the module to your project

At this stage you should have multiple projects in your solution. Your project as well as the project for the module you are wanting to edit. So now we have all the source code in place. Lets use it.

First we need to let our project know about the new project by adding a reference, but instead of referencing the DLL we reference the project with the source code.

It is under projects not the .NET tab:

You will then see a reference to the Compass project, note that this is different to the reference show above when you let the designer import it.

Now we are ready to use the module. Remember all the automatically generated code that the designer does for you, well now you have to do it yourself. Instead of adding to code to the generated file (you will loose it , when it auto generates) we add it to the main program.cs file. (only 2 lines)

First create a private variable for the compass then in the program started create an instance, on socket 8. Be sure not to use the socket in the designer – you will get a warning if you do so fear not.

using System;
using System.Collections;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Controls;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Touch;
 
using Gadgeteer.Networking;
using GT = Gadgeteer;
using GTM = Gadgeteer.Modules;
 
namespace CompassDriverExample
{
    public partial class Program
    {
        private Gadgeteer.Modules.Seeed.Compass compass; //Declare the compass
             
        void ProgramStarted()
        {
            this.compass = new GTM.Seeed.Compass(8);// create an instance on socket 8
            Debug.Print("Program Started");
        }
    }
}

Edit the driver and test.

If you have made it this far then you have a solution that builds a module from source and instantiates the module, ready for use. Have a go to see if it works as expected and all the methods are there.

Now down to the best bit, you can now just change the module source and deploy as you normally would. The compass project will be rebuild every time. For example you may want to know exactly what the ‘Gain’ value is and how it is set. The module has a setgain method which takes a Gain property. The property ranges from Gain1 to Gian8, if you hold your mouse over the property it will display a tooltip, but lets go look at the source.

If you right click on a method (and have the source available) you can select “Go to definition” and it will take you to the code – got to love Visual Studio.

The method source simply writes a value to a register, where the value is of type ‘Gain’ (Right click on ‘Gain’ and go to definition)

public void SetGain(Gain gain)
        {
            Write(Register.CRB, (byte)gain);
        }

Here are the values :

public enum Gain : byte
        {
            /// <summary>
            /// +/- 0.88 Ga
            /// </summary>
            Gain1 = 0×00,
 
            /// <summary>
            /// +/- 1.2 Ga (default)
            /// </summary>
            Gain2 = 0×20,
 
            /// <summary>
            /// +/- 1.9 Ga
            /// </summary>
            Gain3 = 0×40,
 
            /// <summary>
            /// +/- 2.5 Ga
            /// </summary>
            Gain4 = 0×60,
 
            /// <summary>
            /// +/- 4.0 Ga
            /// </summary>
            Gain5 = 0×80,
 
            /// <summary>
            /// +/- 4.7 Ga
            /// </summary>
            Gain6 = 0xA0,
 
            /// <summary>
            /// +/- 5.6 Ga
            /// </summary>
            Gain7 = 0xC0,
 
            /// <summary>
            /// +/- 8.1 Ga
            /// </summary>
            Gain8 = 0xE0,
 
        }

If you rename one of these values, it will have an immediate effect on your code. For example:

public enum Gain : byte
        {
            /// <summary>
            /// +/- 0.88 Ga
            /// </summary>
            Gain1RenamedToSomethingBetter = 0×00,
 
            /// <summary>

Will immediately change in your program.cs

Job done, you are now able to edit the driver and have the changes take effect immediately. Compile is same as always and the solution will deploy your latest code to the hardware when you deploy. This way you can edit and change code until you are satisfied. Once that is done you can then go back to the Compass SOLUTION and build an installer…..

Advanced – where did these numbers come from?

But you have to wonder what these values are and what do they mean? Here is where we need the datasheet. A few folders up from the source code there is a ‘Hardware’ folder that has a datasheet. I you have a custom modules or there is not datasheet you can do very well by searching for the chip number. If stuck pester the manufacturer to add a link to the datasheet for the module.

This compass module is a HMC5883 and there is a data sheet in the Hardware folder (in the downloaded zip from codeplex) :

These can be hard to read, but we can use the bits we are interested in. For example searching the datasheet for ‘Gain’ shows that there is a gain control and that there are 3 bits dedicated to changing it.

Further on in the datasheet there is a section about ‘configuration register B’ this is for setting the gain. Remember that the gain method just writes a byte (8 bits) to a register (Register B), table 10 lets us know that the register is 1 byte (8 bits) – same as our code. So now we just need to check the values that are to be written. Table 10 on page 13 shows that bits 7,6,5 are for setting the gain and 4-0 must be set to zero. Table 12 shows the different gain values and shows how this changes the output.

For example the default gain is 1024 counts/Gauss and this is done by setting the 8 bits of the register to [0,0,1,0,0,0,0,0] but if we look at the code the values are written in hex not binary.

If you are not comfortable converting, believe it or not calculator is your friend! Change calculator into programmer mode:

Select binary and then input the binary you want to convert, in this case [0,0,1,0,0,0,0,0] (note you do not need to leading zeros)

If you then select hex, it will convert the value. (Answer 20)

Since the compiler would not know if we meant 20 (twenty) or 20 (thirty two in decimal,or binary [0,0,1,0,0,0,0,0]) there is a prefix added to a number to let it know that it is hex, the prefix is ‘0x’. And sure enough if we look at the code the default gain is ‘0×20’ which is the correct value according to the data sheet.

public enum Gain : byte
        {
            /// <summary>
            /// +/- 0.88 Ga
            /// </summary>
            Gain1RenamedToSomethingBetter = 0×00,
 
            /// <summary>
            /// +/- 1.2 Ga (default)
            /// </summary>
            Gain2 = 0×20,

Have a look around the datasheet, perhaps there are hardware features that are not implemented in code, so you can improve the performance, enhance the driver, solve bugs or trouble shoot issues.

For example register A can be used to set the sensor rate (default 15Hz) as well as a bias for different axis, but if you right click on the register name and select ‘find all references’, it shows that the driver never uses it….

Happy Gadgeteering…. check www.gadgeteering.net for a complete list of hardware.

Tips

If you are using the express version of Visual Studio it only supports one language. So if you have a VB project and import a C# project, you wont get any debug and things will look a bit strange.

Remember that since you are compiling from source you can now add a break point inside the driver! (F9) This is a fantastic way to halt execution and inspect what is going on, with out having to write tonnes of output lines……

Colour sensor + LED strip video

15 Monday Apr 2013

Posted by sjj698 in .NET Gadgeteer, C#, Hardware

≈ Leave a Comment

[UPDATE] RGB Slider – LED Strip with RGB slider

As requested here is an example of my colour sensor in continuous mode setting the colours of the LED strip. The code below uses the tweaks shown in these two posts:

1) http://stevenjohnston.co.uk/2013/04/15/colour-sensor-on-net-gadgeteer-tcs3414/

2) http://stevenjohnston.co.uk/2013/04/11/individually-addressable-multicolour-leds-on-net-gadgeteer/

Video

The colour changes are much better that this video captures but it is hard to record them (Rather than looking at the ‘white’ over saturated LED, look at the surrounding colour!) In the first few seconds of the video I reset the entire 5m of LEDs and you can see the delay in sending the messages all the way to the last LED. Running the SPI bus at 14MHz I get a refresh of about 5hz (5 full refreshes per second)

Source code

using System;
using System.Collections;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Controls;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Touch;
 
using Gadgeteer.Networking;
using GT = Gadgeteer;
using Gadgeteer.Interfaces;
using GTM = Gadgeteer.Modules;
using Gadgeteer.Modules.GHIElectronics;
 
namespace MagicLights
{
    public partial class Program
    {
        FEZtive feztive;
        void ProgramStarted()
        {
            Debug.Print("Program Started");
            //Calibrate the colour sensor
            colorSense.SetIntegrationTime(ColorSense.TimingRegister.FallingEdge_FreeRunning_400ms);//Set the time span for integration
            colorSense.SetGain(ColorSense.GainRegister.Gain16x_PreScalerDivide4);//Set Gain and PreScalar. 
 
            //Init the LED strip (test other SPI bus speeds)
            feztive = new GTM.GHIElectronics.FEZtive(9);
            //feztive.Initialize(160, 500);//OK
            //feztive.Initialize(160, 1000);//OK
            //feztive.Initialize(160, 2000);//OK
            //feztive.Initialize(160, 4000);//OK
            //feztive.Initialize(160, 8000);//OK
            //feztive.Initialize(160, 16000);//Some LEDS are the wrong colour
            //feztive.Initialize(160, 12000);//OK
            //feztive.Initialize(160, 14000);//OK
            //feztive.Initialize(160, 15000);//Some LEDS are the wrong colour
            //feztive.Initialize(160, 14500);//Some LEDS are the wrong colour
            feztive.Initialize(160, 14000);//OK
 
            //Show some colours
            feztive.SetAll(feztive.Black);
            // Set every LED to Red
            feztive.SetAll(feztive.Red);
            // Set every LED to Red
            feztive.SetAll(feztive.Red);
            // Set every LED to Green
            feztive.SetAll(feztive.Green);
 
            //Toggle the colour sensor white LEDs
            button.ButtonPressed += new Button.ButtonEventHandler(button_ButtonPressed);
 
            //Threads: http://blogs.msdn.com/b/netmfteam/archive/2011/01/17/threads-and-thread-priorities-in-netmf.aspx
            //Dont block the main thread/dispatcher          
            Thread t = new Thread(ContiniousReader);
            t.Start();
        }
 
        //Some variables for debug
        uint r = 0, g = 0, b = 0, c = 0;
        private void ContiniousReader()
        {
            //Loop forever – seperate threads!
            while (true)
            {
                ColorSense.ColorChannels cChan = colorSense.ReadColorChannels();
                if (cChan.Red > r) { r = cChan.Red; }
                Debug.Print("RED: " + cChan.Red + " MAX" + r);//DEBUG – check for saturation
                if (cChan.Green > g) { g = cChan.Green; }
                Debug.Print("GREEN: " + cChan.Green + " MAX" + g);
                if (cChan.Blue > b) { b = cChan.Blue; }
                Debug.Print("BLUE: " + cChan.Blue + " MAX" + b);
                if (cChan.Clear > c) { c = cChan.Clear; }
                Debug.Print("CLEAR: " + cChan.Clear + " MAX" + c);
                GTM.GHIElectronics.Color newColour = new GTM.GHIElectronics.Color(
                  normaliseColourChannel(cChan.Red),
                  normaliseColourChannel(cChan.Green),
                  normaliseColourChannel(cChan.Blue));
                feztive.SetAll(newColour);
 
            }
        }
 
 
        // Take values in the range 0-65k and scale to 0-127       
        byte normaliseColourChannel(uint value)
        {
            var res = ((value / 65536.0) * 127.0);
            return (byte)res;
        }
 
        bool ledStatus = false;//Last known state
        void button_ButtonPressed(Button sender, Button.ButtonState state)
        {
            ledStatus = !ledStatus;
            colorSense.ToggleOnboardLED(ledStatus);
        }
    }
}

Colour sensor on .NET Gadgeteer (TCS3414)

15 Monday Apr 2013

Posted by sjj698 in .NET Gadgeteer, C#, Hardware

≈ 5 Comments

Last post I was looking at the individually addressable LEDs and used the ‘ColorSense’ module to detect colours. (But did not get very good results)

This post addresses the issues with the colour sensor.

I am using the ColorSense REV 1.2 which has a TCS3414 digital colour sensor and 4 white LEDs to illuminate any sources. Each sensor has 16 photodiodes, 4 per channel (R,G,B,Clear) each channel has a 16 bit ADC and we are communicating to the module using I2C. The original driver form GHI can be found in Codeplex: http://gadgeteer.codeplex.com/SourceControl/changeset/view/24955#333941

There are a few settings you may wish to change in order to calibrate she sensor for the task you have in mind. (you may even want to change these values during operation)

1) Integration time.

You can change the length of time that the sensor takes per integration cycle. There are 3 settings and 12ms is the default. (10ms / 400ms being the other options.) The code to enable changes to this is shown below. (If you are getting saturated, lower the integration time)

public struct TimingRegister
{
    //http://www.ghielectronics.com/downloads/man/ColorSense_TCS3404_TCS3414-A.pdf
    public static byte RegisterAddress = 0×81;
    public static byte FallingEdge_FreeRunning_12ms = 0×00;
    public static byte FallingEdge_FreeRunning_100ms = 0×01;
    public static byte FallingEdge_FreeRunning_400ms = 0×02;
}

public void SetIntegrationTime(byte value)
{
    softwareI2C.Write(colorAddress, new byte[] { TimingRegister.RegisterAddress, value});
}

2) Setting the Gain and the prescalar.

The gain and prescalar are set in a single operation. The gain provides “gain control for all four parallel ADC channels” and can be used to ensure the ADC range is modified to avoid saturation. I.e. if the output is always low, then increasing the gain will improve the sensitivity and the channel outputs will increase. The gain can be changed to 4 discrete multipliers, 1x, 4x, 16x and 64x – 64x would make the sensor very sensitive. (Saturation can be avoided by lowering the integration time)

The prescalar divides the ADC output, thus reducing the sensitivity of the ADC. There are 7 different prescalars - divide by 1,2,4,8,16,32,64.

I have put the gain and prescalar options into a struct with a supporting method to change them:

public struct GainRegister
{
    public static byte RegisterAddress = 0×87;
    //Reserved bit (7 = high)
    static byte Reserved = 0×80;
    //Gain – This field switches the common analog gain of the four ADC channels. Four gain modes are provide
    //bit 5:4
    static byte Gain1x = 0×00;
    static byte Gain4x = 0×10;
    static byte Gain16x = 0×20;
    static byte Gain64x = 0×30;
    //Prescaler. This field controls a 6-bit digital prescaler and divider. The prescaler reduces the 
    //sensitivity of each ADC integrator as shown below:
    //Bit 2:0
    static byte PreScalerDivide1 = 0×00;
    static byte PreScalerDivide2 = 0×01;
    static byte PreScalerDivide4 = 0×02;
    static byte PreScalerDivide8 = 0×03;
    static byte PreScalerDivide16 = 0×04;
    static byte PreScalerDivide32 = 0×05;
    static byte PreScalerDivide64 = 0×06;
    public static byte Gain1x_PreScalerDivide1 = (byte)(Reserved | Gain1x | PreScalerDivide1);
    public static byte Gain4x_PreScalerDivide1 = (byte)(Reserved | Gain4x | PreScalerDivide1);
    public static byte Gain16x_PreScalerDivide1 = (byte)(Reserved | Gain16x | PreScalerDivide1);
    public static byte Gain64x_PreScalerDivide1 = (byte)(Reserved | Gain64x | PreScalerDivide1);
    public static byte Gain1x_PreScalerDivide2 = (byte)(Reserved | Gain1x | PreScalerDivide2);
    public static byte Gain1x_PreScalerDivide4 = (byte)(Reserved | Gain1x | PreScalerDivide4);
    public static byte Gain1x_PreScalerDivide8 = (byte)(Reserved | Gain1x | PreScalerDivide8);
    public static byte Gain1x_PreScalerDivide16 = (byte)(Reserved | Gain1x | PreScalerDivide16);
    public static byte Gain1x_PreScalerDivide32 = (byte)(Reserved | Gain1x | PreScalerDivide32);
    public static byte Gain1x_PreScalerDivide64 = (byte)(Reserved | Gain1x | PreScalerDivide64);
    public static byte Gain4x_PreScalerDivide2 = (byte)(Reserved | Gain4x | PreScalerDivide2);
    public static byte Gain4x_PreScalerDivide4 = (byte)(Reserved | Gain4x | PreScalerDivide4);
    public static byte Gain4x_PreScalerDivide8 = (byte)(Reserved | Gain4x | PreScalerDivide8);
    public static byte Gain4x_PreScalerDivide16 = (byte)(Reserved | Gain4x | PreScalerDivide16);
    public static byte Gain4x_PreScalerDivide32 = (byte)(Reserved | Gain4x | PreScalerDivide32);
    public static byte Gain4x_PreScalerDivide64 = (byte)(Reserved | Gain4x | PreScalerDivide64);
    public static byte Gain16x_PreScalerDivide2 = (byte)(Reserved | Gain16x | PreScalerDivide2);
    public static byte Gain16x_PreScalerDivide4 = (byte)(Reserved | Gain16x | PreScalerDivide4);
    public static byte Gain16x_PreScalerDivide8 = (byte)(Reserved | Gain16x | PreScalerDivide8);
    public static byte Gain16x_PreScalerDivide16 = (byte)(Reserved | Gain16x | PreScalerDivide16);
    public static byte Gain16x_PreScalerDivide32 = (byte)(Reserved | Gain16x | PreScalerDivide32);
    public static byte Gain16x_PreScalerDivide64 = (byte)(Reserved | Gain16x | PreScalerDivide64);
    public static byte Gain64x_PreScalerDivide2 = (byte)(Reserved | Gain64x | PreScalerDivide2);
    public static byte Gain64x_PreScalerDivide4 = (byte)(Reserved | Gain64x | PreScalerDivide4);
    public static byte Gain64x_PreScalerDivide8 = (byte)(Reserved | Gain64x | PreScalerDivide8);
    public static byte Gain64x_PreScalerDivide16 = (byte)(Reserved | Gain64x | PreScalerDivide16);
    public static byte Gain64x_PreScalerDivide32 = (byte)(Reserved | Gain64x | PreScalerDivide64);
    public static byte Gain64x_PreScalerDivide64 = (byte)(Reserved | Gain64x | PreScalerDivide64);
 
}

public void SetGain(byte value)
{
    softwareI2C.Write(colorAddress, new byte[] { GainRegister.RegisterAddress,value });
}

3) Enable disable

It may also be useful to enable/disable the module.

public struct ControlRegister
{
    public static byte RegisterAddress = 0×80;
 
    public static byte EnableADC_PowerOn = 0×03;
    public static byte DisableADC_PowerOff = 0×00;
}

public void EnableSensor(bool enable)
{
    if (enable)
    {
        softwareI2C.Write(colorAddress, new byte[] { ControlRegister.RegisterAddress, ControlRegister.EnableADC_PowerOn });
    }
    else
    {
        softwareI2C.Write(colorAddress, new byte[] { ControlRegister.RegisterAddress, ControlRegister.DisableADC_PowerOff });
    }
}

Example

For the task I have in mind setting the following provides me with RGB values between 0-65k and rarely gets saturated (About as sensitive as I dare push it) . Note there are public methods on this module to change these parameters.

this.EnableSensor(true);//Power sensor on
this.SetIntegrationTime(TimingRegister.FallingEdge_FreeRunning_100ms);//Set the time span for integration
this.SetGain(GainRegister.Gain64x_PreScalerDivide2);//Set Gain and PreScalar.

Complete code below

using System;
using Microsoft.SPOT;
 
using GT = Gadgeteer;
using GTM = Gadgeteer.Modules;
using GTI = Gadgeteer.Interfaces;
 
namespace Gadgeteer.Modules.GHIElectronics
{
    //http://www.ghielectronics.com/downloads/man/ColorSense_TCS3404_TCS3414-A.pdf    
    //ADDRESS REGISTER NAME REGISTER FUNCTION – Set MSB high ( OR register address with 0×80)
    // COMMAND Specifies register address
    //00h CONTROL Control of basic functions
    //01h TIMING Integration time/gain control
    //02h INTERRUPT Interrupt control
    //03h INT SOURCE Interrupt source
    //04h ID Part number/ Rev ID
    //07h GAIN ADC gain control
    //08h LOW_THRESH_LOW_BYTE Low byte of low interrupt threshold
    //09h LOW_THRESH_HIGH_BYTE High byte of low interrupt threshold
    //0Ah HIGH_THRESH_LOW_BYTE Low byte of high interrupt threshold
    //0Bh HIGH_THRESH_HIGH_BYTE High byte of high interrupt threshold
    //0Fh  SMBus block read (10h through 17h)
    //10h DATA1LOW Low byte of ADC green channel
    //11h DATA1HIGH High byte of ADC green channel
    //12h DATA2LOW Low byte of ADC red channel
    //13h DATA2HIGH High byte of ADC red channel
    //14h DATA3LOW Low byte of ADC blue channel
    //15h DATA3HIGH High byte of ADC blue channel
    //16h DATA4LOW Low byte of ADC clear channel
    //17h DATA4HIGH High byte of ADC clear channel
 
 
    /// <summary>
    /// A ColorSense module for Microsoft .NET Gadgeteer
    /// </summary>
    public class ColorSense : GTM.Module
    {
        private static GTI.DigitalOutput LEDControl;
        private static GTI.SoftwareI2C softwareI2C;
        private static byte[] readRegisterData = new byte[2];
        private const byte colorAddress = 0×39;//Address for the Colour sense module on I2C
 
        // Note: A constructor summary is auto-generated by the doc builder.
        /// <summary></summary>
        /// <param name="socketNumber">The socket that this module is plugged in to.</param>
        public ColorSense(int socketNumber)
        {
            Socket socket = Socket.GetSocket(socketNumber, true, this, null);
 
            socket.EnsureTypeIsSupported(new char[] { 'X', 'Y' }, this);
 
            LEDControl = new GTI.DigitalOutput(socket, Socket.Pin.Three, false, this);
 
            softwareI2C = new GTI.SoftwareI2C(socket, Socket.Pin.Five, Socket.Pin.Four, this);
 
            // Send COMMAND to access control register for chip power-up
            // Send to power-up chip
            this.EnableSensor(true);//Power sensor on
            this.SetIntegrationTime(TimingRegister.FallingEdge_FreeRunning_100ms);//Set the time span for integration
            this.SetGain(GainRegister.Gain64x_PreScalerDivide2);//Set Gain and PreScalar. 
        }
 
        /// <summary>
        /// Turn the sensor on/off
        /// </summary>
        /// <param name="enable"></param>
        public void EnableSensor(bool enable)
        {
            if (enable)
            {
                softwareI2C.Write(colorAddress, new byte[] { ControlRegister.RegisterAddress, ControlRegister.EnableADC_PowerOn });
            }
            else
            {
                softwareI2C.Write(colorAddress, new byte[] { ControlRegister.RegisterAddress, ControlRegister.DisableADC_PowerOff });
            }
        }
 
        /// <summary>
        /// The TIMING register controls the synchronization and integration time of the ADC channels. The Timing
        /// Register settings apply to all four ADC channels.
        /// </summary>
        /// <param name="value"></param>
        public void SetIntegrationTime(byte value)
        {
            softwareI2C.Write(colorAddress, new byte[] { TimingRegister.RegisterAddress, value});
        }
 
        /// <summary>
        /// http://www.ghielectronics.com/downloads/man/ColorSense_TCS3404_TCS3414-A.pdf
        /// The Gain register provides a common gain control adjustment for all four parallel ADC output channels. Two
        //gain bits [5:4] in the Gain Register allow the relative gain to be adjusted from 1 to 64 in 4 increments. The
        //advantage of the gain adjust is to extend the dynamic range of the light input up to a factor of 64 before analog
        //or digital saturation occurs. If analog saturation has occurred, lowering the gain sensitivity will likely prevent
        //analog saturation especially when the integration time is relatively short. For longer integration times, the 16-bit
        //output could be in digital saturation (64K). If lowering the gain to 1 does not prevent digital saturation from
        //occurring, the use of PRESCALER can be useful.
        //The PRESCALER is 3 bits [2:0] in the gain register that divides down the output count (i.e. shifts the LSB of the
        //count value to the right). The PRESCALER adjustment range is divide by 1 to 64 in multiples of 2.
        //The most sensitive gain setting of the device would be when GAIN is set to 11b (64), and PRESCALER is set
        //to 000b (divide by 1). The least sensitive part setting would be GAIN 00 (1) and PRESCALER 110 (divide by
        //64). If the part continues to be in digital saturation at the least sensitive setting, the integration time can be
        //lowered (see Timing Register section).
        /// </summary>
        /// <param name="value">GainRegister value </param>
        public void SetGain(byte value)
        {
            softwareI2C.Write(colorAddress, new byte[] { GainRegister.RegisterAddress,value });
        }
 
        /// <summary>
        /// Toggles the on-board LEDs to the passed in state.
        /// </summary>
        /// <param name="LEDState">State to set the LEDs to.</param>
        public void ToggleOnboardLED(bool LEDState)
        {
            LEDControl.Write(LEDState);
        }
 
        /// <summary>
        /// Reads the current color from the sensor and returns the results
        /// </summary>
        /// <returns>Returns an instance of the ColorChannels structure, holding the current measurement of color values.</returns>
        public ColorChannels ReadColorChannels()
        {
            ColorChannels returnData;
 
            byte[] TransmitBuffer = new byte[1];
 
            TransmitBuffer[0] = 0×90; // Send COMMAND to access Green Color Channel register for chip
            returnData.Green = readWord(0×90, TransmitBuffer)[0];
            TransmitBuffer[0] = 0×91;
            returnData.Green |= (uint)readWord(0×91, TransmitBuffer)[0] << 8;
            //returnData.Green = 256 * (uint)readWord(TransmitBuffer)[0] + returnData.Green;
 
            TransmitBuffer[0] = 0×92; // Send COMMAND to access Red Color Channel register for chip
            returnData.Red = readWord(0×92, TransmitBuffer)[0];
            TransmitBuffer[0] = 0×93;
            returnData.Red |= (uint)readWord(0×93, TransmitBuffer)[0] << 8;
 
            TransmitBuffer[0] = 0×94; // Send COMMAND to access Blue Color Channel register for chip
            returnData.Blue = readWord(0×94, TransmitBuffer)[0];
            TransmitBuffer[0] = 0×95;
            returnData.Blue |= (uint)readWord(0×95, TransmitBuffer)[0] << 8;
 
            TransmitBuffer[0] = 0×96; // Send COMMAND to access Clear Channel register for chip
            returnData.Clear = readWord(0×96, TransmitBuffer)[0];
            TransmitBuffer[0] = 0×97;
            returnData.Clear |= (uint)readWord(0×97, TransmitBuffer)[0] << 8;
 
            return returnData;
        }
 
        private byte[] readWord(byte address, byte[] CommandBytes)
        {
            softwareI2C.WriteRead(colorAddress, CommandBytes, readRegisterData);
            return readRegisterData;
        }
 
        /// <summary>
        /// Structure to hold color data
        /// </summary>
        public struct ColorChannels
        {
            /// <summary>
            /// Intensity of green-filtered channel
            /// </summary>
            public uint Green;
            /// <summary>
            /// Intensity of red-filtered channel
            /// </summary>
            public uint Red;
            /// <summary>
            /// Intensity of blue-filtered channel
            /// </summary>
            public uint Blue;
            /// <summary>
            /// Intensity of non-filtered channel
            /// </summary>
            public uint Clear;
        }
 
        /// <summary>
        /// Enable / disable
        /// </summary>
        public struct ControlRegister
        {
            public static byte RegisterAddress = 0×80;
            public static byte EnableADC_PowerOn = 0×03;
            public static byte DisableADC_PowerOff = 0×00;
        }
 
        /// <summary>
        /// Integration time
        /// </summary>
        public struct TimingRegister
        {
            public static byte RegisterAddress = 0×81;
            public static byte FallingEdge_FreeRunning_12ms = 0×00;
            public static byte FallingEdge_FreeRunning_100ms = 0×01;
            public static byte FallingEdge_FreeRunning_400ms = 0×02;
        }
 
        /// <summary>
        /// ADC Gain control- Gain = ADC adjustment, PreScaler = divides down the digital output
        /// </summary>
        public struct GainRegister
        {
            public static byte RegisterAddress = 0×87;
            //Reserved bit (7 = high)
            static byte Reserved = 0×80;
            //Gain – This field switches the common analog gain of the four ADC channels. Four gain modes are provide
            //bit 5:4
            static byte Gain1x = 0×00;
            static byte Gain4x = 0×10;
            static byte Gain16x = 0×20;
            static byte Gain64x = 0×30;
            //Prescaler. This field controls a 6-bit digital prescaler and divider. The prescaler reduces the 
            //sensitivity of each ADC integrator as shown below:
            //Bit 2:0
            static byte PreScalerDivide1 = 0×00;
            static byte PreScalerDivide2 = 0×01;
            static byte PreScalerDivide4 = 0×02;
            static byte PreScalerDivide8 = 0×03;
            static byte PreScalerDivide16 = 0×04;
            static byte PreScalerDivide32 = 0×05;
            static byte PreScalerDivide64 = 0×06;
            public static byte Gain1x_PreScalerDivide1 = (byte)(Reserved | Gain1x | PreScalerDivide1);
            public static byte Gain4x_PreScalerDivide1 = (byte)(Reserved | Gain4x | PreScalerDivide1);
            public static byte Gain16x_PreScalerDivide1 = (byte)(Reserved | Gain16x | PreScalerDivide1);
            public static byte Gain64x_PreScalerDivide1 = (byte)(Reserved | Gain64x | PreScalerDivide1);
            public static byte Gain1x_PreScalerDivide2 = (byte)(Reserved | Gain1x | PreScalerDivide2);
            public static byte Gain1x_PreScalerDivide4 = (byte)(Reserved | Gain1x | PreScalerDivide4);
            public static byte Gain1x_PreScalerDivide8 = (byte)(Reserved | Gain1x | PreScalerDivide8);
            public static byte Gain1x_PreScalerDivide16 = (byte)(Reserved | Gain1x | PreScalerDivide16);
            public static byte Gain1x_PreScalerDivide32 = (byte)(Reserved | Gain1x | PreScalerDivide32);
            public static byte Gain1x_PreScalerDivide64 = (byte)(Reserved | Gain1x | PreScalerDivide64);
            public static byte Gain4x_PreScalerDivide2 = (byte)(Reserved | Gain4x | PreScalerDivide2);
            public static byte Gain4x_PreScalerDivide4 = (byte)(Reserved | Gain4x | PreScalerDivide4);
            public static byte Gain4x_PreScalerDivide8 = (byte)(Reserved | Gain4x | PreScalerDivide8);
            public static byte Gain4x_PreScalerDivide16 = (byte)(Reserved | Gain4x | PreScalerDivide16);
            public static byte Gain4x_PreScalerDivide32 = (byte)(Reserved | Gain4x | PreScalerDivide32);
            public static byte Gain4x_PreScalerDivide64 = (byte)(Reserved | Gain4x | PreScalerDivide64);
            public static byte Gain16x_PreScalerDivide2 = (byte)(Reserved | Gain16x | PreScalerDivide2);
            public static byte Gain16x_PreScalerDivide4 = (byte)(Reserved | Gain16x | PreScalerDivide4);
            public static byte Gain16x_PreScalerDivide8 = (byte)(Reserved | Gain16x | PreScalerDivide8);
            public static byte Gain16x_PreScalerDivide16 = (byte)(Reserved | Gain16x | PreScalerDivide16);
            public static byte Gain16x_PreScalerDivide32 = (byte)(Reserved | Gain16x | PreScalerDivide32);
            public static byte Gain16x_PreScalerDivide64 = (byte)(Reserved | Gain16x | PreScalerDivide64);
            public static byte Gain64x_PreScalerDivide2 = (byte)(Reserved | Gain64x | PreScalerDivide2);
            public static byte Gain64x_PreScalerDivide4 = (byte)(Reserved | Gain64x | PreScalerDivide4);
            public static byte Gain64x_PreScalerDivide8 = (byte)(Reserved | Gain64x | PreScalerDivide8);
            public static byte Gain64x_PreScalerDivide16 = (byte)(Reserved | Gain64x | PreScalerDivide16);
            public static byte Gain64x_PreScalerDivide32 = (byte)(Reserved | Gain64x | PreScalerDivide64);
            public static byte Gain64x_PreScalerDivide64 = (byte)(Reserved | Gain64x | PreScalerDivide64);
 
        }
    }
}

Individually addressable multicolour LED’s on .NET Gadgeteer

11 Thursday Apr 2013

Posted by sjj698 in .NET Gadgeteer, C#, Hardware

≈ 2 Comments

Who does not like LED’s? They are fun and amazing, especially if you by a 5m strip of individually addressable multicolour LED’s. I had a whole pile of important work to get done today but for some reason the FEZtive kit I ordered ages ago was just begging to be used. More importantly I found a power supply that will give 10A@5v so I had to have a play.

The first hurdle was finding out how to power the module 160×3 LEDs (RGB) is a lot to power and GHI recommend a good power supply which is attached to the FEZtive module board part A, this way you are not drawing power through the .NET Gadgeteer mainboard. In the picture below you can see my power connector. (Not I have not split the PCB as I only need one connector for now and this way I don’t loose the other half.)

Next I need to connect the connect the LED strip to the PCB, my strip had a connector on each end and as I planed to run this as a single strip, I cut the connector off the end and attached it to the PCB. This way I can disconnect the LED strip. Now I have power, data (Gadgeteer cable) and a connector for the lights.

Connect it all up and we are ready for some software….

There is a great example of how the use the module here : http://wiki.tinyclr.com/index.php?title=FEZtive_Module

At the time of writing the FEZtive module is not part of the main GHI installer (I guess it will be in time) so you need to download the project from the link above. Be sure to add this project to your solution (or new project),

Next add a reference from your project to the FEZtive project you just downloaded. (I am using NetMF 4.2 so add a reference to the _42 project.)

Since you cannot drag and drop the module from the designer (not yet) you need to create the object on the socket that you are using, I have a Spider with SPI on socket 9. Here is the example code from: http://wiki.tinyclr.com/index.php?title=FEZtive_Module

public partial class Program
{
    // This method is run when the mainboard is powered up or reset.
 
    FEZtive feztive;
    void ProgramStarted()
    {
        Debug.Print("Program Started");
        feztive = new GTM.GHIElectronics.FEZtive(9);
        // Initialize the module to use 80 LEDs, with an SPI clock rate of 4Mhz
        feztive.Initialize(160, 4000);
        // Set every LED to Black (off)
        feztive.SetAll(feztive.Black);
        // Set every LED to Red
        feztive.SetAll(feztive.Red);
        // Set every LED to Red
        feztive.SetAll(feztive.Red);
        // Set every LED to Green
        feztive.SetAll(feztive.Green);

Fantastic this works! (It is hard to take a picture, they look better in real life)

The FEZtive part B

The LED’s are connected by 4 lines (Gnd, CI, DI, +5v) and you don’t need anything on the ‘end’ of the LED strip, as it is just one big long SPI bus. So in theory you can cut the strip (there are marked points to cut after each LED- see the white line) into different sizes. The PCB that my kit came with has 2 parts and A and a B, each with 5 areas to connect an LED strip. Think of these PCBs as U-turns in the LED strip. You can cut it into 5 x 1m strips and then zigzag them between part A and part B, note that this will make the order of the LEDs into a long snake, so if you are writing text or showing a picture you will need to calculate which LED is where. (Yes you can link multiple together – I only have one)

How does it work?

If you look at the GHI driver for this module you can see that there is a large array (one for each LED) which contains a custom ‘colour’ object. There are a series of public methods that let you manipulate this array (change the colour) and then there is a draw method that will ‘write’ the entire array of ‘colour’ objects to the SPI bus.

There are some interesting effects of this. Imaging you have a LONG strip, say 5m and decide to set the colour to blue, you can see the new colour advancing along the strip. It is easier to see if you slow the clock speed down.

feztive = new GTM.GHIElectronics.FEZtive(9);
feztive.Initialize(160, 500);

This got me thinking, how is it working? Imagine you built a new (very large) HD TV out of this would it work? Well not exactly, you would get rather ugly ‘scan’ lines and the refresh would be poor.

Change the colour

I have a .NET Gadgeteer colour sensor and setup a button that would read the sensor and set all LEDs to that colour. Handy to test and a little more fun as you can point it at an object, press a button and all the LEDs change colour.

Here is a bit of code:

void button_ButtonPressed(Button sender, Button.ButtonState state)
{
   // colorSense.ToggleOnboardLED(true);
   ColorSense.ColorChannels cChan = colorSense.ReadColorChannels();            
   GTM.GHIElectronics.Color newColour = new GTM.GHIElectronics.Color((byte)(cChan.Red / 2), (byte)(cChan.Green / 2), (byte)(cChan.Blue / 2));
   //  colorSense.ToggleOnboardLED(false);
   feztive.SetAll(newColour);
}

Something is a bit strange here, the colour sensor returns a uint for each of RGB as well as an intensity. The FEZtive LED strip takes a value between 0-127 for each of the RGB. For now I halved the channels, but this is not correct and for extreme lighting conditions it will produce strange results. I plan to normalise these values, but so I can test a bit more this will do for now. I could not find a datasheet for the Colour sensor module and the source code does not give away much. humph! – GHI? The driver reads 2 bytes fore each channel 2^16 colour options per channel, but I noticed that with a bright light the values rarely top 10,000. (e.g RED: 9715, GREEN: 12368, BLUE: 11918) [UPDATE : http://stevenjohnston.co.uk/2013/04/15/colour-sensor-on-net-gadgeteer-tcs3414/]

public ColorChannels ReadColorChannels()
{
    ColorChannels returnData;
 
    byte[] TransmitBuffer = new byte[1];
 
    TransmitBuffer[0] = 0×90; // Send COMMAND to access Green Color Channel register for chip
    returnData.Green = readWord(0×90, TransmitBuffer)[0];
    TransmitBuffer[0] = 0×91;
    returnData.Green |= (uint)readWord(0×91, TransmitBuffer)[0] << 8;

The LDP8806

Each multicolour led on the strip has a processor next to it, yes every one! This is the LDP8806 – anyone got a data sheet?

Something is interesting here, you just tell the Gadgeteer initialiser how many LEDs there are, and then ram data down the SPI bus. If you say there are only 10 LEDs then only the first 10 in your strip will work. This means that the data is fed to the first led in the strip, the colour is set and then all subsequent data is passed down the SPI bus, to the next LED and so on.

There is a series of zeros that are passed into SPI before and after each call, and this depends on the length of the strip. (presumably to set the LED into a state where it can obtain a new colour). I think this explains why each value is limited to a range of 0-127, the high bit is being used to command each LED.

_zeros = new byte[3 * ((numLEDS + 63) / 64)];

Ok, enough speculation, here is a much better explanation: https://github.com/adafruit/LPD8806/blob/master/LPD8806.cpp

Can it go faster?

For a bit of fun I decided to see what SPI clock rates would work with my 5m strip.

FEZtive feztive;
void ProgramStarted()
{
    Debug.Print("Program Started");
    feztive = new GTM.GHIElectronics.FEZtive(9);
    feztive.Initialize(160, 500);//OK
    feztive.Initialize(160, 1000);//OK
    feztive.Initialize(160, 2000);//OK
    feztive.Initialize(160, 4000);//OK
    feztive.Initialize(160, 8000);//OK
    feztive.Initialize(160, 16000);//Some LEDS are the wrong colour
    feztive.Initialize(160, 12000);//OK
    feztive.Initialize(160, 14000);//OK
    feztive.Initialize(160, 15000);//Some LEDS are the wrong colour
    feztive.Initialize(160, 14500);//Some LEDS are the wrong colour
    feztive.Initialize(160, 14000);//OK

So it would look like 14MHz is as fast as this will run without errors. It is not exactly scientific, so the plan is to run at at this speed for a bit and see how it copes.

.NET Gadgeteer digital camera with a SerCam

10 Wednesday Apr 2013

Posted by sjj698 in .NET Gadgeteer, C#

≈ Leave a Comment

[UPDATE: C# and VB solutions are at the end, the first part is ONLY an explanation. You do not need to follow the steps, just look at the code at the very end if you are after a fix. ]

I have had a few people mention that they hit issues when swapping from the GHI Camera module to a GHI SerCam module. So here is an explanation and example:

First remember that things are constantly being updated so make sure you have the updates! (Updates/Debug help)

I am using NetMF QFE2, version 4.2 with the GHI software last updated Feb 18, 2013, (I also have no idea if the source code on codeplex has been updated to reflect this release.)

(Expect this post to get out of date, it is here to help those who need a workaround NOW – solution at the bottom)

Issue 1

1) The NullReferenceException:

Create a new project and call the take picture method on the camera.

void button_ButtonPressed(Button sender, Button.ButtonState state)
{
    serCam.TakePicture();
}

When you run the code it throws an exception. The exception is in the SerCam.dll and you do not have the source code in your project so you cant see what is going on.

I downloaded the latest GHI source from codeplex (http://gadgeteer.codeplex.com/)

Link the downloaded code into your project:

1) Delete the reference to the GHI SerCam.dll

2) Add the 4.2 SerCam project to your solution (codeplex source folder : \Main\Modules\GHIElectronics\SerCam\Software\SerCam\SerCam_42).

3) Add a reference from your project to the codeplex SerCam.

Right now you are good to go, when it deploys it will now halt execution at the code that is causing the problem :

The problem here is that the code assumes that there is at least one delegate to call when the StartDataCaptured event is triggered. A simple work around (if you don’t want to change the source) is to ensure that all events have something to call, even if it is empty. Then when you run the code you should not get the NullReferenceException.

void ProgramStarted()
{            
    Debug.Print("Program Started");
    serCam.StartDataCaptured += new SerCam.StartDataCapturedEventHandler(serCam_StartDataCaptured);
    serCam.FinishDataCaptured += new SerCam.FinishDataCapturedEventHandler(serCam_FinishDataCaptured);
    serCam.OnDataCaptured += new SerCam.DataCapturedEventHandler(serCam_OnDataCaptured);
    serCam.TakePicture();
}
 
}
 
void serCam_OnDataCaptured(SerCam sender, byte[] data)
{            
}
 
void serCam_FinishDataCaptured(SerCam sender)
{
}
 
void serCam_StartDataCaptured(SerCam sender, int sizeImage)
{
}

Issue 2

The methods are not the same as the camera I am used to, where is the Picture object, how do i get it and why is it not returned to me?

There are 3 events on the SerCam, one that is triggered at the start of a picture capture (StartDataCaptured), one that is triggered once the picture has been captured (FinishDataCaptured) and one that is triggered when some data is available (OnDataCaptured). The key here is that you only get the picture back in chunks, handy if memory is an issue. You have to take these chunks and piece them together. If we take a picture and set a breakpoint in the ReadFrameBuffer method (the one that triggers the OnDataCaptured event) we can see that the picture is split into blocks, each block is returned as it is read. There are 95 blocks in this particular picture, so we have to put them all back together to reconstruct the picture for the display.

<snip>

Solution/workaround

Make sure there is code to execute for every event and rebuild the picture.

1) First create a Byte array to store the reconstructed picture in your program, I will call it rawPicData:

namespace SerCamExample
{
    public partial class Program
    {
 
        byte[] rawPicData; 
        void ProgramStarted()
        {            
            Debug.Print("Program Started");

3) When we start to take a picture lets reset the rawPicData array. That way we know it is initialised and is reset for every picture.

void serCam_StartDataCaptured(SerCam sender, int sizeImage)
{
    rawPicData = new byte[] { };
}

4) Every time there is a block (chunk) of picture data ready, we read it and append it to the end of the picture array (Not the optimal solution, it will be a bit slow, but it is one line). I added a debug line so you can see that something is happening.

void serCam_OnDataCaptured(SerCam sender, byte[] data)
{
    rawPicData = Microsoft.SPOT.Hardware.Utility.CombineArrays(rawPicData, data);
    Debug.Print("Working…");
}

5) Finally when the camera has finished taking a picture and you have read all the blocks, the FinishedDataCaptured event will be triggered. Now you can take the byte array and convert it into a picture object. You can only do this once you have ALL the blocks and you should check for an exception, in case of an error. In this case it is Jpeg

var picB = new Bitmap(rawPicData, Bitmap.BitmapImageType.Jpeg);

You can then display the picture:

 display_T35.SimpleGraphics.DisplayImage(picB, 0, 0);

Source Code

If you read nothing above and just want a working example here it is:

using System;
using System.Collections;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Controls;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Touch;
using Gadgeteer.Networking;
using GT = Gadgeteer;
using GTM = Gadgeteer.Modules;
using Gadgeteer.Modules.GHIElectronics;
 
namespace SerCamExample
{
    public partial class Program
    {
        byte[] rawPicData; 
        void ProgramStarted()
        {            
            Debug.Print("Program Started");
            serCam.StartDataCaptured += new SerCam.StartDataCapturedEventHandler(serCam_StartDataCaptured);
            serCam.FinishDataCaptured += new SerCam.FinishDataCapturedEventHandler(serCam_FinishDataCaptured);
            serCam.OnDataCaptured += new SerCam.DataCapturedEventHandler(serCam_OnDataCaptured);           
            button.ButtonPressed += new Button.ButtonEventHandler(button_ButtonPressed);        
        }
        
        void serCam_OnDataCaptured(SerCam sender, byte[] data)
        {
            rawPicData = Microsoft.SPOT.Hardware.Utility.CombineArrays(rawPicData, data);
            Debug.Print("Working…");
        }
 
        void serCam_FinishDataCaptured(SerCam sender)
        {
            var picB = new Bitmap(rawPicData, Bitmap.BitmapImageType.Jpeg);
            display_T35.SimpleGraphics.DisplayImage(picB, 0, 0);
        }
 
        void serCam_StartDataCaptured(SerCam sender, int sizeImage)
        {
            rawPicData = new byte[] { };
        }
 
        void button_ButtonPressed(Button sender, Button.ButtonState state)
        {
            serCam.TakePicture();
        }        
    }
}

And in VB (Thanks to Sue)

Imports GT = Gadgeteer
Imports GTM = Gadgeteer.Modules
Imports Gadgeteer.Modules.GHIElectronics
 
 
Partial Public Class Program
    ' Dim datajpg As Byte() = {8}
    Dim datajpg() As Byte = New Byte() {}
    Dim index As Integer
    ' This is run when the mainboard is powered up or reset. 
    Public Sub ProgramStarted()       
        ' Use Debug.Print to show messages in Visual Studio's "Output" window during debugging.
        Debug.Print("Program Started")
        serCam.SetImageSize(serCam.Camera_Resolution.SIZE_QVGA)
 
    End Sub
 
    Private Sub button_ButtonPressed(sender As Gadgeteer.Modules.GHIElectronics.Button, state As Gadgeteer.Modules.GHIElectronics.Button.ButtonState) Handles button.ButtonPressed
        serCam.TakePicture()
        Debug.Print("Taken picture")
 
    End Sub
 
    Private Sub serCam_FinishDataCaptured(sender As Gadgeteer.Modules.GHIElectronics.SerCam) Handles serCam.FinishDataCaptured
        Dim picture As Bitmap = New Bitmap(datajpg, Bitmap.BitmapImageType.Jpeg)
        display_T35.SimpleGraphics.DisplayImage(picture, 0, 0)
 
    End Sub
 
    Private Sub serCam_OnDataCaptured(sender As Gadgeteer.Modules.GHIElectronics.SerCam, data() As Byte) Handles serCam.OnDataCaptured
 
        datajpg = Microsoft.SPOT.Hardware.Utility.CombineArrays(datajpg, data)
    End Sub
 
    Private Sub serCam_StartDataCaptured(sender As Gadgeteer.Modules.GHIElectronics.SerCam, sizeImage As Integer) Handles serCam.StartDataCaptured
        ' At present need an empty sub here to stop a Null Reference error occurring.
        ' Hopefully this will be fixed soon (11/4/2013)
    End Sub
End Class

.NET Gadgeteer Led Matrix Part 2 – the code

10 Wednesday Apr 2013

Posted by sjj698 in .NET Gadgeteer, C#, LED Matrix

≈ 1 Comment

I was asked to show the source behind the example shown in the .NET Gadgeteer LED Matrix blog post.

(as is, no warranty, and I am sure there are bugs etc blah blah)

The code is supplied below, it has a display buffer that you fill with text and it will scroll based on the timer ( turn off if annoying) . This is a class that you can just add to your project and call the methods to display text.

1) Add code to project (new class)

2) Create instance, supplying an array of your hardware modules to the constructor

LedDisplayArray ledArray;
ledArray = new LedDisplayArray(new LEDMatrix[] { lEDMatrix, lEDMatrix1 ,lEDMatrix2,lEDMatrix3});

3) Call DrawString with the text you need to display.

string displayText =   " 1 2 3 4 5 6 7 8 9 0 :  !  o   ";//Example text
ledArray.clear();//Reset/clear any previous text
ledArray.DrawString(displayText);//Display the text
ledArray.Scroll(); //Start scrolling

NOTE: You will have to create a lookup table for each character/digit you want to display. I have only added a few.

using System;
using System.Collections;
using Gadgeteer;
using Gadgeteer.Modules.GHIElectronics;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
 
namespace LedArray
{
    class LedDisplayArray
    {
        //The array with the chars that we will display
        private byte[] displayArray = new byte[] { };
        //An array of the physical matrix modules, so we can add more
        private LEDMatrix[] displays;
        int destinationIndex = 0;
 
        //A list of all possible characters (you have to make your own, examples below)
        Hashtable AsciiLookup = new Hashtable();
 
        Timer timer = new Timer(400);
        private int arrayOffset = 1;
 
        //Constructor, give it all your physical displays
        public LedDisplayArray(LEDMatrix[] displays)
        {
 
            //Setup characters/digits – add more
            AsciiLookup.Add((int)'1', new byte[] { 0×02, 0xFE, 0×42 });
            AsciiLookup.Add((int)'2', new byte[] { 0xF2, 0×92, 0x9E });
            AsciiLookup.Add((int)'3', new byte[] { 0xFE, 0×92, 0×92 });
            AsciiLookup.Add((int)'4', new byte[] { 0xFE, 0×10, 0xF0 });
            AsciiLookup.Add((int)'5', new byte[] { 0x9E, 0×92, 0xF2 });
            AsciiLookup.Add((int)'6', new byte[] { 0x9E, 0×92, 0xFE });
            AsciiLookup.Add((int)'7', new byte[] { 0xFE, 0×80, 0×80 });
            AsciiLookup.Add((int)'8', new byte[] { 0xFE, 0×92, 0xFE });
            AsciiLookup.Add((int)'9', new byte[] { 0xFE, 0×90, 0xF0 });
            AsciiLookup.Add((int)'0', new byte[] { 0xFE, 0×82, 0xFE });
            AsciiLookup.Add((int)' ', new byte[] { 0×00 });
            AsciiLookup.Add((int)':', new byte[] { 0×28 });
            AsciiLookup.Add((int)'!', new byte[] { 0×20, 0×10, 0xD7, 0xF8, 0xD7, 0×10, 0×20 });
            AsciiLookup.Add((int)'o', new byte[] { 0×06, 0×63, 0×63, 0x0B, 0×63, 0×63, 0×06 });
 
            //All hardware
            this.displays = displays;
            displayArray = new byte[displays.Length * 8];
 
            //scroller
            timer.Tick += new Timer.TickEventHandler(timer_Tick);
 
        }
 
        void timer_Tick(Timer timer)
        {
            //move array
 
            displayArray = Utility.CombineArrays(displayArray, displayArray.Length – arrayOffset, arrayOffset, displayArray, 0, displayArray.Length – arrayOffset);
 
            Draw();//redraw
        }
 
        public void Scroll()
        {
            //start timer
            timer.Start();
 
        }
 
        private void Draw()
        {
            //pad array to display size – minimum
            if (displayArray.Length < displays.Length * 8)
            {
                displayArray = Utility.CombineArrays(displayArray, new byte[(displays.Length * 8) - displayArray.Length]);
            }
            //For each matrix.
            for (int ctr = 0; ctr < displays.Length; ctr++)
            {
                //The text can be bigger than we can display, get the bit we want to display
                byte[] currentDisplayData = new byte[] { };
 
                //if the text is small, just display it. 
                if ((displayArray.Length >= (ctr + 1) * 8))
                {
                    //display all text
                    currentDisplayData = Utility.ExtractRangeFromArray(displayArray, ctr * 8, 8);
                }
                else
                {
                    //Start of text
                    currentDisplayData = Utility.ExtractRangeFromArray(displayArray, ctr * 8,
                                                                       displayArray.Length – (ctr * 8));
                    //wrap round and get beginning text if at end. 
                    currentDisplayData = Utility.CombineArrays(currentDisplayData,
                                                               new byte[8 - currentDisplayData.Length]);
                }
 
                //Display the text that we have decided should be shown 
                displays[ctr].DrawBitmap(currentDisplayData);
            }
 
        }
 
        public void DrawString(string str)
        {
            //Given a string , put it in the draw buffer
            char[] characterArray = str.ToCharArray();
            //get each char and look it up – be sure to add all the chars you will need
            foreach (char c in characterArray)
            {
                this.AddCharacter((byte[])this.AsciiLookup[(int)c]);
            }
            //Draw it
            this.Draw();
        }
 
 
        private void AddCharacter(byte[] characterBytes)
        {
            //add characters to the diaplay array
            displayArray = Utility.CombineArrays(characterBytes, displayArray);
        }
 
        internal void clear()
        {
            //remove all text
            displayArray = new byte[] { };
        }
    }
 
 
 
 
 
 
}

.NET Gadgeteer temperature logger example

12 Wednesday Dec 2012

Posted by sjj698 in .NET Gadgeteer, C#

≈ 1 Comment

Tags

data logger, example, humidity, temperature, webserver

An example can go a long way, so rather than a 2 hour presentation with nothing but slides, I decided that the NxtGenUG Christmas special should include an end-to-end .NET Gadgeteer example. The example below includes the steps to build your own data logger to log both temperature and humidity. The coding examples were purposely kept short and do not include all the error checking that should be included, the aim was to show a wide variety of .NET Gadgeteer capabilities resulting in a final working prototype – within the 2 hour limit (including all coding and hardware building)!

[Note: I assume you have the latest SDK’s installed and that the firmware has been updated. I am using Visual Studio Ultimate, but the following will also work in the free version of VS.]

1) Lets start with a new project..

I have updated to the latest SDK/Drivers and firmware so we are currently targeting v4.2

2) There are currently a wide variety of sensors, actuators and displays available (over 130 different modules)- Lets start with a simple temperature sensor, this module uses the SHT10 temp and humidity sensor. To create a basic prototype using this we will need a mainboard ( GHI Spider) and a power module. This is achieved by dragging the modules from the toolbox on the right into the designer (main panel). By right clicking and selecting connect all modules you should end up with the following in the designer.

3) To begin with we will code the bare minimum so we can see the development cycle and get a feel for the environment. Notice that dragging modules on to the designer instantiates them, so they are ready to be used in your code. First we add some code to the MeasurementCompleted event and then put the sensor into continuous measurement mode. Each time the sensor acquires a new measurement our code will just print the readings out to the debug console. (Remember to turn this on if you are using VS Express – Debug-> Windows-> Output, See http://wp.me/p2pktY-3q). As you type VS will prompt you with intellisense and auto complete assistance, be sure to use these as it saves time.

{        
      void ProgramStarted()
      {                       
          Debug.Print("Program Started");
          temperatureHumidity.MeasurementComplete += new TemperatureHumidity.MeasurementCompleteEventHandler(temperatureHumidity_MeasurementComplete);
          temperatureHumidity.StartContinuousMeasurements();
      }
 
      void temperatureHumidity_MeasurementComplete(TemperatureHumidity sender, double temperature, double relativeHumidity)
      {
          Debug.Print("Temp : " + temperature + " RH: " + relativeHumidity);
      }

4) Next we will deploy the solution (hit F5/ Green arrow) this will compile the code and flash your mainboard with the solution. Note we are using the USB cable to power hardware as well as debug inside VS. Once the program has been deployed it will start and you can see the debug output in VS.

5) This is all very well but the Debug output is not a great place to view data, so let us add a display. There are a few to choose from but lets start with the T35 from GHI. Dragging and dropping the display in the designer and selecting connect all modules will result in the layout below.

6)I prefer to have a separate method to configure the display but feel free to have the code inside the program started method. We will need a font, one of the two supplied with the template. There are 2 modes of operation for the display, WPF and simple graphics. Many examples include the simple graphics option so we will use the WPF as a demo, suffice to say that this is a very basic interface and WPF is very powerful, so worth looking at further. The hardware display module has a WPFWindow property, this is the root of all the graphics that we will add. First we will add some text to the main canvas.

Font baseFont;
Window window;
Canvas canvas = new Canvas();
Text txtMsg;
 
private void setupWindow()
{
    baseFont = Resources.GetFont(Resources.FontResources.NinaB);
    window = display_TE35.WPFWindow;
    window.Child = canvas;
    txtMsg = new Text(baseFont, "Starting…");
    canvas.Children.Add(txtMsg);
}

7) Each time the sensor returns a new reading we can use it to change the text content on the canvas. Note that we do not need to refresh the text, we are using the same text object.

void temperatureHumidity_MeasurementComplete(TemperatureHumidity sender, double temperature, double relativeHumidity)
{
    Debug.Print("Temp : " + temperature + " RH: " + relativeHumidity);
    txtMsg.TextContent =  "Temp : " + temperature + " RH: " + relativeHumidity;                        
}

8) This text is a bit long, and has a few too many decimal places, so lets shorten the text.

void temperatureHumidity_MeasurementComplete(TemperatureHumidity sender, double temperature, double relativeHumidity)
{
    Debug.Print("Temp : " + temperature + " RH: " + relativeHumidity);
    txtMsg.TextContent = "Temp : " + temperature.ToString("F") + "           RH: " + relativeHumidity.ToString("F");                        
}

9) The text is also rather close to the top of the screen, so we can nudge the canvas down a bit by adding a margin.

canvas.SetMargin(5);

10) If all went well we are left with a user interface that updates, but is perhaps not beautiful.

11) Imagine that you are happy with this prototype and show it to friends/colleagues, who like the prototype but think the display is not very good and suggest adding a larger display. (Substituting hardware is something that is often required but can be very difficult to achieve, particularly when working with embedded systems). Lets go to the designer and deleted the T35 display and drag and drop the CP7 display into the solution. Connecting up the new display is the same as the old one and hitting build will result in an error. The error occurs because the display variable names are different (I just used the default names) – correcting this will let the solution compile and deploy.

12) With minimal effort the new display should look like the picture below. (Still not a fantastic interface) Remember that you need to build different prototype versions, experiment with hardware and test your ideas. The quicker you can develop new versions the quicker you can test you ideas and bring them into reality.

13) The next step is to do something about this interface, it is lacking a bit of readability. The first step is to make the font bigger. This is not as simple as you imagine as there are just 2 default fonts in the template and they do not come in different sizes. Basically you would not want to waste all your precious embedded device memory on fonts! So you can add just the fonts (and character sets) that you need! There is a tool to import fonts called TFConvert which is command line driven (TFConvert more info: http://msdn.microsoft.com/en-us/library/cc533019.aspx). Like most things someone has written a tool to improve it :- http://informatix.miloush.net/microframework/Utilities/TinyFontTool.aspx

Once you have a new .tinyfnt file simply import is as a resource in VS (Add resource –> File-> *.tinyfnt) and it will become available in your code.

14) Lets just swap the font for the new font, intellisense will auto complete the FontResources, to show all the fonts you now have (should be 3).

private void setupWindow()
{
    baseFont = Resources.GetFont(Resources.FontResources.SegoeUILarge);

15) Simply writing text to the display is a bit lazy, remember this is a WPFWindow, we have a canvas and a whole collection of WPF components that we could add. Most things in WPF end up in a stack panel of some sort, think of it as a bag that lets you throw things into and can display them either as a row or a column. I will add a stack panel to the canvas and then add the text for humidity and temperature as two separate text objects. Feel free to explore some of the methods at this point. For example you can catch touch events on WPF components such as a text object. I have added the complete code below as a reference.

namespace TemperatureLogger
{
    public partial class Program
    {
        Font baseFont;
        Window window;
        Canvas canvas = new Canvas();
        Text txtMsgTemp;
        Text txtMsgRH;
 
 
        private void setupWindow()
        {
            baseFont = Resources.GetFont(Resources.FontResources.SegoeUILarge);
            window = display_CP7.WPFWindow;
            window.Child = canvas;
            txtMsgTemp = new Text(baseFont, "Starting…");
            txtMsgRH = new Text(baseFont, "Starting…");
            canvas.SetMargin(5);
            txtMsgTemp.TextWrap = true;
            StackPanel stack = new StackPanel();
            stack.Children.Add(txtMsgTemp);
            stack.Children.Add(txtMsgRH);
            canvas.Children.Add(stack);
             
        }
 
        void ProgramStarted()
        {
            Debug.Print("Program Started");
            setupWindow();
 
            temperatureHumidity.MeasurementComplete += new TemperatureHumidity.MeasurementCompleteEventHandler(temperatureHumidity_MeasurementComplete);
            temperatureHumidity.StartContinuousMeasurements();
        }
 
        void temperatureHumidity_MeasurementComplete(TemperatureHumidity sender, double temperature, double relativeHumidity)
        {
            Debug.Print("Temp : " + temperature + " RH: " + relativeHumidity);
            txtMsgTemp.TextContent = "Temp : " + temperature.ToString("F");
            txtMsgRH.TextContent = "RH: " + relativeHumidity.ToString("F");
        }
    }
}

16) Text that updates is lovely but sometimes you just need to draw something! This is the only code that I will not manually type but it is short and simple enough to read through and understand. There is a basic graphing class that will draw grid lines and plot data points. Source code copied from from http://gadgeteering.net/sites/default/files/users/nvillar/files/SimpleGraph.cs . Code listed below for completeness.

using System;
using Microsoft.SPOT;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Presentation.Media;
using Microsoft.SPOT.Presentation.Shapes;
using Microsoft.SPOT.Presentation.Controls;
 
using GT = Gadgeteer;
 
namespace TemperatureLogger
{
    /// <summary>
    /// This is a SimpleLine graph implemented as a WPF control.
    /// </summary>
    class SimpleGraph : Canvas
    {
        private int[] PointsX;
        private int[] PointsY;
 
        Pen GraphPen;
        private int PointIndex;
        private double MinYValue;
        private double MaxYValue;
        private int DataPoints;
 
        private Pen GridPen;
        private int VerticalGridSpacing = 0;
        private int HorizontalGridSpacing = 0;
        private bool ShowGrid = false;
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="height">Height of the graph, in pixels.</param>
        /// <param name="width">Width of the graph, in pixels.</param>
        /// <param name="minYValue">The smallest expected data value.</param>
        /// <param name="maxYValue">The largest expected data value.</param>
        /// <param name="dataPoints">The number of data points.</param>
        /// <param name="lineThickness">The thickness of the graph line.</param>
        /// <param name="lineColor">The color of the graph line.</param>
        public SimpleGraph(uint height, uint width, double minYValue, double maxYValue, int dataPoints, ushort lineThickness, Color lineColor)
        {
            this.Width = (int)width + 1; // Extra pixels to accomodate a border (only visible when grid lines are on)
            this.Height = (int)height + 1;
            this.MinYValue = minYValue;
            this.MaxYValue = maxYValue;
            this.DataPoints = dataPoints;
 
            PointsX = new int[dataPoints];
            PointsY = new int[dataPoints];
 
            GraphPen = new Pen(lineColor, lineThickness);
 
            Clear();
        }
 
        /// <summary>
        /// Plot a new value onto the graph. When there is no more room for new values, the graph will scroll.
        /// </summary>
        /// <param name="value"></param>
        public void Plot(double value)
        {
            AddValue(value);
 
            this.Invalidate();
        }
 
        /// <summary>
        /// Clear the graph.
        /// </summary>
        public void Clear()
        {
            for (int i = 0; i < DataPoints; i++)
            {
                PointsX[i] = i * (int)((double)this.Width / DataPoints);
                PointsY[i] = 0;
            }
 
            PointIndex = 0;
            this.Invalidate();
        }
 
        /// <summary>
        /// Display grid lines in the background of the graph.
        /// </summary>
        /// <param name="verticalLineSpacing">Spacing of vertical grid lines, in pixels.</param>
        /// <param name="horizontalLineSpacing">Spacing of horizontal grid lines, in pixels.</param>
        /// <param name="lineColor">Grid line color.</param>
        public void DisplayGridLines(int verticalLineSpacing, int horizontalLineSpacing, GT.Color lineColor)
        {
            VerticalGridSpacing = verticalLineSpacing;
            HorizontalGridSpacing = horizontalLineSpacing;
 
            GridPen = new Pen(lineColor, 1);
            ShowGrid = true;
        }
 
        public void HideGrid()
        {
            ShowGrid = false;
        }
 
        public override void OnRender(DrawingContext dc)
        {
            base.OnRender(dc);
 
            if (ShowGrid)
            {
                if (VerticalGridSpacing > 0)
                {
                    // Draw vertical grid lines
                    for (int x = 0; x < this.Width; x += VerticalGridSpacing)
                    {
                        dc.DrawLine(GridPen, x, 0, x, this.Height);
                    }
                }
 
                if (HorizontalGridSpacing > 0)
                {
                    // Draw horizontal grid lines
                    for (int y = 0; y < this.Height; y += HorizontalGridSpacing)
                    {
                        dc.DrawLine(GridPen, 0, y, this.Width, y);
                    }
                }
            }
 
            // Draw the graph lines
            for (int i = 1; i < PointIndex; i++)
            {
                dc.DrawLine(GraphPen, PointsX[i-1], PointsY[i-1], PointsX[i], PointsY[i]);
                dc.DrawLine(GraphPen, PointsX[i - 1], PointsY[i - 1] – 1, PointsX[i], PointsY[i] – 1);
            }
        }
 
        private void AddValue(double value)
        {
            int yPos = (int)(this.Height – (((double)(value – MinYValue) / (MaxYValue – MinYValue)) * this.Height));
 
            if (PointIndex < PointsY.Length)
            {
                PointsY[PointIndex] = yPos;
                PointIndex++;  
            }
            else
            {
                Array.Copy(PointsY, 1, PointsY, 0, DataPoints – 1);
                PointsY[DataPoints - 1] = yPos;
            }
        }
 
    }
}

17) Import the simple graphing class and create a graph object.

 SimpleGraph tempGraph;

Select the colours, size and grid lines. Then add the graph object to the stack panel that we created earlier.

tempGraph = new SimpleGraph(200, 300, 0,50, 300, 1, Colors.Blue);                    
tempGraph.DisplayGridLines(60, 20, GT.Color.LightGray);
 
stack.Children.Add(tempGraph);

Then every time the sensor event triggers add the data to the graph.

tempGraph.Plot(temperature);

The result should be a nice stack of text , text, graph! (Axis, units, colour, background, buttons are still required!) Hopefully that demonstrates how quite sophisticated GUIs can be generated using .NET Gadgeteer and very few lines of code.

18) Clearly we are making a sensor logger here, assuming the display now meets all you requirements, lets log the data to an SD card. First step is to add an SD module to the designer. (Drag, drop)

19) First be sure to check you have an SD card, that it is formatted etc! We will just mount the storage that is in the SD module.

//SDCard
sdCard.MountSDCard();
storage =  sdCard.GetStorageDevice(); //Do checks here

20) Every time the sensor gets some data, append it to the end of a file. Be sure to consider if this is a wise move, especially if you are polling the sensor frequently. ( I will add a fs.flush() for the demo to show that data is written). There is also a storage FileWrite method that is worth considering, I did not use it here as I plan to flush the FileStream, to show that data ends up on the card without having to wait for a flush.

byte[] data = Encoding.UTF8.GetBytes(msg + "\n");
using (FileStream fs = storage.Open("data.log", FileMode.Append, FileAccess.Write))
{
    fs.Write(data, 0, data.Length);
}

21) We have a data display, and logger, but nothing is complete without some sort of internet capability. Lets make our sensor available across the internet! .NET Gadgeteer easily lets you set up a web server. Lets add an Ethernet connection in the designer:

You could just as easily add a WiFi module:

Note: If you use a WiFi module here is a handy way to setup an adhoc network on your Win8 laptop/PC

Setup wireless network (from http://www.addictivetips.com/windows-tips/how-to-create-wireless-ad-hoc-internet-connection-in-windows-8/)

> netsh wlan set hostednetwork mode=allow ssid=MyNetwork key=MyNetwork

> netsh wlan start hostednetwork

(Be sure to run as admin)

Note: Here is a good webserver example http://mikedodaro.net/2011/10/15/gadgeteer-web-service-surveillance-camera/

22) Be sure to add more error checking than is shown here, to your networking capabilities.

23) Lets start a webserver when we get an IP address. First register to get notifications when the IP changes, enable DHCP and then open the network.

ethernet_J11D.Interface.NetworkAddressChanged += new NetworkInterfaceExtension.NetworkAddressChangedEventHandler(Interface_NetworkAddressChanged);
ethernet_J11D.Interface.NetworkInterface.EnableDhcp();
ethernet_J11D.Interface.Open();

As an aside I noticed that it can take the WiFi module a while to start-up so I added the initialisation into a delayed timer.

//WiFi connect
GT.Timer wifiTmr = new GT.Timer(15000);
wifiTmr.Tick += new GT.Timer.TickEventHandler(wifiTmr_Tick);
wifiTmr.Start();

24) Again it is wise to add some sanity checks here, but we will assume that our networking is perfect , that we get an IP address and simply start a webserver on port 80. The great thing about the webserver is that you can setup events on the url, here we add an event that will be triggered when the url http://<IP>/Temp is requested. (Simple eh!)

void Interface_NetworkAddressChanged(object sender, EventArgs e)
{
   WebServer.StartLocalServer(ethernet_J11D.Interface.NetworkInterface.IPAddress, 80);
   WebEvent we = WebServer.SetupWebEvent("Temp");
   we.WebEventReceived += new WebEvent.ReceivedWebEventHandler(we_WebEventReceived);
}

It is always polite to return a response, we can simply return a webpage (basic!)

void we_WebEventReceived(string path, WebServer.HttpMethod method, Responder responder)
{
    
    responder.Respond("<html><body> Temperature : "+ txtMsgTemp.TextContent+ "</body></html>");
}

Summary

In just 2 hours we have built an example data logger, with a graphical frontend, storage capabilities as well as making the datalogger internet capable! Aside from the SimpleGraph capabilities we have assembled all the hardware and typed all the code to make the prototype work, including importing a custom font. Hopefully this demonstrates the power of .NET Gadgeteer for rapid prototype creations! A few shortcuts were taken and it is highly recommended to add some error checking.

Note: Throughout this presentation I have purposely iterated through the development cycle to simulate the process you will encounter developing a prototype. Each change resulted in a build, compile and deploy (F5 in VS) and then a simple test to show the expected output. We will have also experienced the debug breakpoint feature which is very powerful. It is important to realise that we can halt execution on the actual hardware and inspect the objects that are in scope, this is probably one of the most valuable debug features and is a fantastic capability for embedded devices!

Help Visual Studio wont deploy my .NET Gadgeteer project!

20 Tuesday Nov 2012

Posted by sjj698 in .NET Gadgeteer, C#, VB

≈ 1 Comment

Tags

deploy error, Visual studio

[Note: Firmware, versions and hardware will change over time and I expect this guide to get out of date, it is intended to help those with 4.1 –> 4.2 migration issues.]

What is changing?

.NET Gadgeteer is built upon NetMF (a cut down version of the full .NET runtime) and since NetMF has released a new version v4.2 then everything that depends on this layer so to speak also has to change. In theory you would only update if you need a particular feature, but it is always nice to be sure that you are on the latest versions. For example NetMF v4.2 provides the ability to code in VB (as well as the existing C#). You may also find that some annoying bug has been fixed in a later version.

The symptoms

You realise something is up when Visual Studio complains that there are deployment issues but everything is plugged in and should work!

Before you go any further so a sanity check:

Did the project/solution build/rebuild without errors? You can always try with a blank Gadgeteer project.
Is the hardware plugged in? (seriously)
Don’t plug into USB3.0 ports, there are some issues (they tend the be blue USB sockets)

Update the software

Depending if you have a policy to stick to a particular version updating may or may not be a good idea – your call. I like to keep things updated so look at the hardware you have and go to the manufacturers site and download the latest bits, e.g. GHI: http://www.ghielectronics.com/support/dotnet-micro-framework

Step 1 – Is my hardware recognised?

With your mainboard plugged into a USB port, go to Device manager and see if the device has been found. You are looking for something similar to the name on your hardware and you don’t want any errors, unrecognised devices. (They don’t all appear the same, so here are a few examples).

FEZ Cerberus and FEZ Cerberus Bee (healthy)
FEZ Hydra (Healthy)
Love Electronics Argon R1 (Healthy)
Sytech Nano (Healthy)
Mountaineer Eth

So you get the idea, plug the device in and out and see if any devices are found/removed if you are unsure. If you can see your hardware here and it does not have any warnings then things look good and you can move on assuming that you hardware has been recognised.

Step 2 – If the hardware was recognised…

If you got a deployment issue and your hardware is recognised, then be sure that Visual Studio can see the hardware. Right click on the project (not solution) and select properties.

The properties window has a .NET Micro Framework tab which will show you which device you have plugged in and is . If your device is NOT listed here then it was not recognised. Be careful if you change this setting you need to save for the change to take effect. The easy, safe option here is to select another transport such as serial then re-select the USB transport. Select your device again (so you end up where you started) and save (hit ctrl + s) or close the properties window.

If your hardware is recognised and Visual Studio can see the device, you should not get a deployment error, be sure your project compiles (test with a blank new Gadgeteer project). Check the output window for errors (see further in this post if you are unsure where the output window is located.) and check to see if it is a firmware version issue (read on).

Step 3 – If the hardware is not recognised…

If you get a yellow exclamation on the hardware the driver did not load and the hardware will not work until you get the driver fixed. The transition between NetMF 4.1 and 4.2 resulted in a change of USB driver to WinUSB – which is installed on most OS (For Windows XP check http://stevenjohnston.co.uk/2012/11/14/net-gadgeteer-on-windows-xp/)

Manually update your USB driver, Plugin your mainboard and in device manager right click the unknown/error device and update the driver to a legacy driver. (located in the GHI install directory) – something like “C:\Program Files (x86)\GHI Electronics\GHI Premium NETMF v4.2 SDK\USB Drivers”

This has been known to help for the following mainboards : Hydra, Cerberus,

There is a GHI forum here: http://www.tinyclr.com/forum/topic?id=9521

Do i have a firmware version error/mismatch?

If your hardware is recognised in device manager, but the firmware needs updating you will see the following in the output window

If you do not have the output window showing then this problem is harder to find as the deploy will look like it is doing nothing (it has really failed and put the error on the output window – see section below if you are unsure where the output window is located)

Update the Firmware

This is different for each manufacturer, have a look at their site, for example:

FEZ Hydra and Spider may be options on your start menu:

GHI update FEZ Cerberus instructions: http://wiki.tinyclr.com/index.php?title=Firmware_Update_FEZ_Cerberus

GHI Hydra: http://wiki.tinyclr.com/index.php?title=Firmware_Update_FEZ_Hydra

Use the output window!

Before you go any further be sure to have the ‘output’ window displayed in Visual Studio. Whilst this may appear obvious it is not on by default if you use the express version.

To view, the output window, Debug –> Windows –> Output.

The output window will show you errors and is usually located at the bottom of the main Visual Studio windows (you may need to select the tab) Below is the output of a blank project once it has been rebuilt (all went ok)

The diagnostics loop summary

Update the software
Check the hardware is recognised
Check USB drivers
Deploy a blank solution
Update the firmware
Try different boards

.NET Gadgeteer on Windows XP

14 Wednesday Nov 2012

Posted by sjj698 in .NET Gadgeteer, C#, VB

≈ 1 Comment

Tags

legacy, usb driver, windows xp

I have had a few reports that people are having issues with the USB drivers on Windows XP.

The problem

When a mainboard (spider) is connected the USB driver never loads, the device is not found and VS cannot deploy. If you look in the device manager it will appear as unknown.

Solution

Make sure you have Win XP SP2 installed.
Get the latest .NET Gadgeteer bits. Probably from GHI, and remember they are updated often; probably fixing some other issue you may hit!
During the install select the ‘Legacy USB Driver’ option.
Plugin your mainboard (spider) and in device manager right click the unknown/error device and update the driver to a legacy driver. (located in the GHI install directory) – something like

“C:\Program Files (x86)\GHI Electronics\GHI Premium NETMF v4.2 SDK\USB Drivers”

Motion_Sensed event

SensorStillActive property

Example

Get the source code.

Remove the existing driver from your solution.

Add the (new) source code to your solution.

Add the module to your project

Edit the driver and test.

Advanced – where did these numbers come from?

Tips

Video

Source code

1) Integration time.

2) Setting the Gain and the prescalar.

3) Enable disable

Example

Complete code below

The FEZtive part B

How does it work?

Change the colour

The LDP8806

Can it go faster?

Issue 1

Issue 2

Solution/workaround

Source Code

Summary

What is changing?

The symptoms

Update the software

Step 1 – Is my hardware recognised?

Step 2 – If the hardware was recognised…

Step 3 – If the hardware is not recognised…

Do i have a firmware version error/mismatch?

Update the Firmware

Use the output window!

The diagnostics loop summary

The problem

Solution

Other reading

Follow “Steven Johnston”