Laurent Ellerbach

Adding Bluetooth support to a NETMF board (.NET Microframework)

Laurelle — Mon, 29 Apr 2013 09:59:39 GMT

I recently bought a very cheap Bluetooth adaptor for my Netduino. I wanted to test how easy/hard it is to support Bluetooth. I see lots of advantages with Bluetooth for a near field communication like piloting easily a robot with a Phone without the need of other network or Infrared. Also Bluetooth is a secured communication with a peering.

So I bought this cheap Bluetooth adaptor for $8.20. It does expose itself to the world with a serial port on one side and as a normal Bluetooth device on the other side. Communication is supported with a serial port from one side to the other. On a PC, Phone or whatever device, it creates a serial port. So communication is basically very transparent and assimilated to a serial port from end to end.

When I received it, I was impatient to test it. First step was to peer it with a PC. I looked at the documentation and found the default name for this device was “linvor” and found out the passkey was 1234. After cabling it with 3.3V (my board support 3.3V to 12V alimentation) and the ground, and approximately 1 minutes, I peered it!

New step was to write a bit of code to test all this. I decided to do a very basic echo program. So whatever it will receive, it will send it back to the calling program. On the netduino board, I’ll use the COM1 (pins D0 and D1). I found also in less than 1 minute that the default configuration was 9600 bauds, 8 bits, no parity and 1 bit stop. So I wrote this very simple code for the test, very hard to do more basic than that:

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
using System.Text; 
using System.IO.Ports;   

namespace Bluetooth
{
    public class Program
    {
        static SerialPort serial;

        public static void Main()
        {
            // initialize the serial port for COM1 (pins D0 and D1)             
            serial = new SerialPort(SerialPorts.COM1, 9600, Parity.None, 8, StopBits.One);             
            // open the serial-port, so we can send and receive data             
            serial.Open();             
            // add an event-handler for handling incoming data             
            serial.DataReceived += new SerialDataReceivedEventHandler(serial_DataReceived);       
            //wait until the end of the Universe :-)
            
            Thread.Sleep(Timeout.Infinite);         
        }            
        static void serial_DataReceived(object sender, SerialDataReceivedEventArgs e)         
        {             
            // create a single byte array             
            byte[] bytes = new byte[1];                
            // as long as there is data waiting to be read             
            while (serial.BytesToRead > 0)             
            {                 
                // read a single byte                 
                serial.Read(bytes, 0, bytes.Length);                 
                // send the same byte back                 
                serial.Write(bytes, 0, bytes.Length);             
            }         
        }       
        
    }
}

I launch a simple serial port program like the old Hyper terminal on the PC where I peered the Bluetooth device and ran the test. Good surprise, I selected the port created on my PC (was port 6), open the port. The Bluetooth device went from a red blinking led to a always on led showing the device was correctly peered. Sounds good so far! So I typed “bonjour” and send it. instantly I get the “bonjour” back.

So cool it’s working! I wanted to know more about the cheap and what can be setup, changes like the name of the device, the pin, the baud rate, etc. I used my preferred search engine Bing and quickly found out that it’s possible to change lots of things by sending couple of AT command. Those commands were used at the old age of modems It just remembered me that!

Even if there are lots of cheap existing like the one I bought, most support exactly the same commands. I found a good documentation there. It’s not the same cheap and the AT commands are a bit different but I quickly found out that most were working. So I’ve decided to test if it was working. All what you have to do is send the commands when the device is not peered. You can do it either with a USB to serial FTDI cheap or directly from the board. I did it directly from the Netduino by modifying a bit the code to send the commands. I found the most interesting commands were the following:

AT+NAMEnewname\r\n to change the device name, you get an answer
AT+PINxxxx\r\n to change the pin code, default is 1234
AT+BAUDx\r\n where X goes from 1 to 8 (1 = 1200 to 8 = 115200) to change the baud rate

I send couple of commands to test and it worked just perfectly So I renamed the device to LaurelleBT instead of linvor. As the device was already peered, Windows did not had to reinstall drivers or cut the communication, it was just about changing the displayed name:

So that’s it! In 5 minutes I had a working Bluetooth module on my board. I was positively surprised and I’ll buy more for sure! Next step it to mount it on a robot and pilot it from a Windows Phone or Windows 8 device.

.NET Microframework (NETMF) Web Server source code available

Laurelle — Sun, 07 Apr 2013 14:55:00 GMT

So as I got lots of asks to get the code of my Web Server, I’ve decided to create a Codeplex project. You’ll find the source here: https://netmfwebserver.codeplex.com/

It does include the following features:

Start, stop, Pause the Web Server
Creation of a Web Server on any port
Fully functional multithread Web Server supporting GET only
Downloading any file present on a SD (or any other physical storage)
A full function to get all the parameters of a URL

Examples of usage can be found on this blog. Working to publish a fully functional example.

Feedback welcome!

Web Server and CSS files in NETMF (.NET Microframework)

Laurelle — Fri, 05 Apr 2013 08:16:37 GMT

It’s been a long time I did not write anything on my blog. Not that I haven’t developed anything but just because I did not take the time to write proper articles. I’ve continue to add features to my Lego city by piloting the trains but also the switches. And I’ll try to write articles to explain how to do that for all the features.

But I will start with the modification of my Web Server to support CSS file. I did couple of demonstration of my development and each time I show the interface people were telling to me I need to work with a designer. And that’s what I finally did I worked with Michel Rousseau who is designer at Microsoft in the French team. And I gave him a challenge: “Design this simple web page without changing the code too much and keep it less than couple of K without any image”. Michel is used to design Windows 8 and Windows Phone apps but not very very simple page like the one I had.

And he has done an excellent job! Here is the view before and after:

Now I had to implement this in my code. As the brief was to have minimal effect on the code, I was expecting to implement this quickly. Reality was a bit different. It took me a bit more time than expected for the following reasons:

I had to implement in my basic web server a function to be able to download a file (the CSS one)
To read and download a file from an SD, you have to do it by chunk as the buffer size is limited (in the case of my Netduino 1024 bit)
Modify the main code to care about downloaded file and also add the lines of code to support CSS
But the main issue was that I’ve discovered that to be able to have a CSS file, you need to have the specific type “text/css”. This is to avoid cross domain fishing and other hacking

So let see how to implement this step by step. So let start with the reading part of the file and how to send it. As explained in the last point, a CSS file has to have the correct mime type in the header. In fact, Internet Explorer and most of the other browsers such as Chrome and Firefox does not need the mime type to determine what kind of fire you are downloading. They do it with the mime type and/or with the extension. Most of the time, it’s just with the extension and reading the header of the file. But for security reason, it’s better if you have to determine correctly the type matching with the extension and the header of the file. And for CSS, it is forced like this to reinforce the security in Internet Explorer 8, 9 and 10.

So as I had to implement this feature for CSS, I made a simple function to support some types I’ll use in other creation:

        public static void SendFileOverHTTP(Socket response, string strFilePath)
        {
            string ContentType = "text/html";
            //determine the type of file for the http header
            if (strFilePath.IndexOf(".cs") != -1 ||
                strFilePath.IndexOf(".txt") != -1 ||
                strFilePath.IndexOf(".csproj") != -1
            )
            {
                ContentType = "text/plain";
            }

            if (strFilePath.IndexOf(".jpg") != -1 ||
                strFilePath.IndexOf(".bmp") != -1 ||
                strFilePath.IndexOf(".jpeg") != -1
              )
            {
                ContentType = "image";
            }

            if (strFilePath.IndexOf(".htm") != -1 ||
                strFilePath.IndexOf(".html") != -1
              )
            {
                ContentType = "text/html";
            }

            if (strFilePath.IndexOf(".mp3") != -1)
            {
                ContentType = "audio/mpeg";
            }
            if (strFilePath.IndexOf(".css") != -1)
            {
                ContentType = "text/css";
            }

            string strResp = "HTTP/1.1 200 OK\r\nContent-Type: "

 + ContentType + "; charset=UTF-8\r\nCache-Control:

no-cache\r\nConnection: close\r\n\r\n";
            OutPutStream(response, strResp);

So very simple and straight forward code. I do determine the extension of the file I want to read and create a ContentType variable with the right format. Then I build the HTTP header and send the header. Very simple, efficient and straight forward code. We are doing Embedded code, it’s not the code I would do in a normal development of a real web server. But it does the job there!

Next step is reading the file and outputting it to the Socket. And I do this in the same function, right after this first part:

            FileStream fileToServe = null;
            try
            {
                fileToServe = new FileStream(strFilePath,

FileMode.Open, FileAccess.Read);
                long fileLength = fileToServe.Length;
                // Now loops sending all the data.

                byte[] buf = new byte[MAX_BUFF];
                for (long bytesSent = 0; bytesSent < fileLength; )
                {
                    // Determines amount of data left.
                    long bytesToRead = fileLength - bytesSent;
                    bytesToRead = bytesToRead < MAX_BUFF ? bytesToRead : MAX_BUFF;
                    // Reads the data.
                    fileToServe.Read(buf, 0, (int)bytesToRead);
                    // Writes data to browser
                    response.Send(buf, 0, (int)bytesToRead, SocketFlags.None);

                    System.Threading.Thread.Sleep(100);
                    // Updates bytes read.
                    bytesSent += bytesToRead;
                }
                fileToServe.Close();
            }
            catch (Exception e)
            {
                if (fileToServe != null)
                {
                    fileToServe.Close();
                }
                throw e;
            }

        }

First step is to create a FileStream and create the Stream with the path of the file and read the length of the file. MAX_BUFF = 1024 and is the maximum size of a buffer. It depends on the .NET Microframework Platform. And we will start a loop to read part of the file and send it.

The System.Threading.Thread.Sleep(100) is necessary to allow some time for the system and other tasks. If you don’t put it and have other tasks, the risk is that the memory will get full very quickly and you’ll block all the code.

In my Web Server I have an event raised when an HTTP request is done. Here is an example of code you can place in your handling function to manage on one side the files to be downloaded from the SD and on the other side a page you’ll generate dynamically like in ASP, ASP.NET, PHP or any other dynamic language:

            //PageCSS
            if (strFilePath.Length >= pageCSS.Length)
            {
                if (strFilePath.Substring(0, pageCSS.Length).ToLower() == pageCSS)
                {
                    string strDefaultDir = "";
                    if (Microsoft.SPOT.Hardware.SystemInfo.IsEmulator)
                        strDefaultDir = "WINFS";
                    else
                        strDefaultDir = "SD";
                    WebServer.SendFileOverHTTP(response, strDefaultDir + "\\" + pageCSS);
                    return;
                }
            }
            //HTTP header
            strResp = "HTTP/1.1 200 OK\r\nContent-Type: text/html;

charset=utf-8\r\nCache-Control: no-cache\r\nConnection: close\r\n\r\n";
            strResp = WebServer.OutPutStream(response, strResp);

            // Page util
            if (strFilePath.Length >= pageUtil.Length)
            {
                if (strFilePath.Substring(0, pageUtil.Length).ToLower() == pageUtil)
                {
                    ProcessUtil(response, strFilePath);
                    return;
                }
            }

Here PageCSS = the file name of the file you are looking for (including the path if in sub directory) so something like “page.css” and pageUtil = name of a page you will generate dynamically (including the path subdirectory) so something like “util.aspx”

strFilePath = full URL including the parameters so something like “util.apsx?bd=3;tc=4”

so code looks for the name of the page in the URL and brunch it to a either the SendFileOverHTTP function we’ve just look at or another function in the case of a dynamic page.

You’ll note also that the is a case in the file part as the default directory is not the same if you are in the emulator or on a real board. The path depend also from the Platform. In the case of my Netduino, it’s CD. For emulator, it’s always WINFS.

And please do all your file reading brunching before the HTTP header part. As for files, the header is already send out. Which is not the case for the dynamic generated page. As you can send whatever you want including images, text, binary files and you’ll need to set it up correctly.

Now, lets have a look at the CSS file:

@charset "utf-8";
/* CSS Document */

body {
    font-family: "Lucida Console", Monaco, monospace;
    font-size: 16px;
    color: #09C;
    text-align: center;
    margin-left: 0px;
    margin-top: 0px;
    margin-right: 0px;
    margin-bottom: 0px;
}

a {
    font-family: "Lucida Console", Monaco, monospace;
    font-size: 14px;
    color: #09F;
}
td {
    font-family: Arial, Helvetica, sans-serif;
    color: #004262;
    font-size: 14px;
}
input {
    font-family: "Lucida Console", Monaco, monospace;
    font-size: 16px;
    color: #09F;
    background-color: #FFF;
    -webkit-transition: all 0s linear 0s;
    -moz-transition: all 0s linear 0s;
    -ms-transition: all 0s linear 0s;
    -o-transition: all 0s linear 0s;
    transition: all 0s linear 0s;
    border: 1px none #FFF;
}

h1 {
    font-family: Arial, Helvetica, sans-serif;
    color: #FFF;
    background-color: #006699;
    font-size: 24px;
    border: thick solid #006699;
}
td {
    font-family: Arial, Helvetica, sans-serif;
    text-align: left;
    font-size: 16px;
}
footer {
    color: #09C;
}
input:hover {
    background-color: #09F;
    color: #FFF;
}
input:active {
    background-color: #003;
}

As you can see, it is very simple CSS that Michel did. It is just over righting the normal styles with colors and fonts. Nothing really complex but complicated to do something nice in only few lines of code! Well done Michel

Now implementation in the rest of the code and all the pages is quite straight forward and simple, here is an example:

// Start HTML document
strResp += "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"

\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
strResp += "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head><title>Gestion des trains</title>";
//this is the css to make it nice :-)
strResp += "<link href=\"" + pageCSS + "?" + securityKey + "\" rel=\"stylesheet\" type=\"text/css\" />";
strResp += "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"/></head><body>";
strResp += "<meta http-equiv=\"Cache-control\" content=\"no-cache\"/>";
strResp = WebServer.OutPutStream(response, strResp);

The HTML page is build and the CSS page is added with a parameter (a security key). And this line including the CSS is the only line I have to add to go from the original design to the nice new one!

So that’s it for this part. I’ll try to find some time to write additional examples.

How software can solve hardware problems

Laurelle — Mon, 30 Jul 2012 12:09:17 GMT

I’ve developed my own sprinkler system and my own humidity sensor. This sensor is extremely simple as you can read in my article. The main problem of this sensor is that the data to be read is an analogic data and the length of the cable is very long. There are lots of problems implied with long cables. You can read an excellent article from Mario Vernari here. In his article, you can clearly see the impact of an alimentation, of other signals into a long distance cable.

Of course my humidity sensor will follow the same problem. And I’ve logged couple of days of data every minute to have enough data to see how the data looks like.

As you can visually see the bleu line represents the data and with 19000 data, you can feel like it is very random. In fact those data are not random, they are just noisy. There are couple of solutions to avoid this problem. First solution is of course hardware, changing the hardware to remove a maximum of noise and clear the signal. But I will not do this for my example.

I will use a pure software solution to remove this noise. As explained in Mario’s blog, most of the noise is kid of high frequency compare to the normal signal. And this apply to any scale. So in my scale, I will also have this issue. What I know is that my signal do not change much. Remember I’m measuring the soil humidity or moisture and this is not changing so quickly. It can change very quickly in less than couple of minutes in case of huge rain.

So one of the solution is to do a mobile average. By doing this, you can remove the high frequency. The principle is simple, it’s about doing an average of N values that “moves” with the signal. And the effect is to mathematically remove the high frequencies. Let use an example with a period of 15 points. In my graph, that would say an average of a moving quarter. Applied to the previous graph, the black line does represent it:

and visually, you can see that it does remove lots of the randomness. Of course, if you do an average on more points, you’ll remove even more of the noise. The orange one does represent an average on 60 points so a mobile average of 1h:

The period you have to choose depend on the quality of the signal and of course the change of data you still want to measure. The longest the period is and the less changes you can evaluate. So let use this last example with a 1 hour filter and let see if we can read anything on it. I know what was the weather and when I did sprinkler. Logically, each time it has rain, the signal should increase and decrease with no rain and high temperatures. And it should also increase if I did sprinkler. On this graph, I’ve put in red when it did rain and in green when I did sprinkler.

So even if we have this 60 points mobile filter and this remove rapid change in the measurement, it is still possible to see the impact of a rain or of a sprinkler. Now, I’ve added a 600 points mobile average and I let the pic where they were, here is the result:

it is still readable but the impact of an event can be read later. And the pic are lower. I don’t want to enter in the theory but to be simple, it’s just because, you are using more data, so as explain, the average will lower the result as it is there to remove high frequencies. And you’ll need more “higher” data to see an impact. It’s like if you had a field of green grass and add couple of red flowers. Take a picture and do an average of the color. It will be green. Add couple of other red flours, take a picture again, do the average and continue like this. And you’ll need to have lots of red flours added to see a change while you’ve started adding flowers some time ago. This is exactly what is happening there. You will detect the phenomenon much later than it happened.

So if you want to use those kind of filters, make sure you use them wisely and not with a too long period. In my case, I will probably use for production something between 15 and 60 points. I need to have an idea of the humidity, not a very precise value. And as shown in the previous graph, it is visible when there’s been some rain or if the sprinkler was on.

And of course, I’ll need also to work on the isolation of the cable to try to remove some of the noise.

You may Wonder how I was able to log 19000 points? Well, it is very simple and the code is there:

class LogToFile
{
    static public bool Print(string StrFileName, string strToLog)
    {
        try
        {
            FileStream fileToWrite = new FileStream(StrFileName, FileMode.OpenOrCreate, FileAccess.Write);
            byte[] buff = Encoding.UTF8.GetBytes(strToLog);
            fileToWrite.Seek(fileToWrite.Length, 0);
            fileToWrite.Write(buff, 0, buff.Length);
            fileToWrite.Close();
            return true; 
        }
        catch (Exception e)
        { 
            return false;  
        }
    
    }
}

It takes a simple file name as an input and something to write. The code is straight forward, it first create or open a file. Then encode the string to write in the buff variable. Seek to the end of the file, write the buff and close the file. So extremely simple code!

LogToFile.Print("WINFS\\out.txt", DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + ";" + mSensor.Humidity + "\r\n");

And the usage is as simple as the code, one line to log data like in this example. and as a result, you get data like this in the text file:

07/29/2012 13:34:46;86
07/29/2012 13:34:47;93
07/29/2012 13:34:48;91
07/29/2012 13:34:49;93

For the next article, we will see how to implement the filter in the real code.

A soil low cost humidity sensor (moisture) and .NET Micro Framework (NETMF)

Laurelle — Wed, 18 Jul 2012 01:22:40 GMT

I’m working on my own sprinkler system which I can pilot thru Internet wherever I am. I can add programs and also open and close sprinklers when I want. I recently build a prototype of a humidity sensor. Now it’s time to implement this humidity sensor in pre production and see how it is working for real. Next phase will be an automatic piloting based on this humidity sensor. Thanks also to all the feedback I get which encourage me to continue those posts. I’m just a marketing guy doing hardware and software development

Based on the work of the prototype, I’ve build a normal size sensor and put it for real in my garden:

It is the same principle as the prototype, there are 2 coppers cables put in the soil (approx. 10 centimeters) and current arriving to those 2 cables. The potential is measured and interpreted to see how humid it is. To summarize, the more humid it is the lower the resistance of the soil is. So I need 3 cables only: one for ground, one for +3.3V and one for the measurement. I can chain sensors and will only need 1 additional cable per sensor. This solution is very simple and very easy to implement. There are smartest way to do this with a real serial bus self powered. But for the moment, I’m fine with this solution. I will explore the other solution when I will want to add temperature, luminosity and others like wind.

Now, looking at the code, I wanted to make part of the code reusable and I’ve define a humidity sensor with simple Properties and a class to initialize the analogic input.

public struct HumiditySenrorParam
{
    public int MinValue;
    public int MaxValue;
    public int DeclValue;
    public int UpdateTime;
}

public class HumiditySensor
{
    private SecretLabs.NETMF.Hardware.AnalogInput HumSensor;
    private Timer MyTimer;
    private int myDeclUpdate;
    private int myHumidity;
    private bool bhumid = false;
   
    public HumiditySensor(Cpu.Pin HumidityPin, 
HumiditySenrorParam MyHumidityStruct)
    {
        if (!Microsoft.SPOT.Hardware.SystemInfo.IsEmulator)
            HumSensor = 
new SecretLabs.NETMF.Hardware.AnalogInput(HumidityPin);
        MyTimer = new Timer(new TimerCallback(ClockTimer_Tick), 
this, MyHumidityStruct.UpdateTime * 1000, 0);
        MinValue = MyHumidityStruct.MinValue;
        MaxValue = MyHumidityStruct.MaxValue;
        DeclValue = MyHumidityStruct.DeclValue;
        UpdateTime = MyHumidityStruct.UpdateTime;
    }

The HumiditySensorParam class is used to pass the initialization value to the HumiditySensor class. Each class is using an analogic input on a specific Pin from the CPU. This value is also passed in the constructor.

An analogic input on the netduino has 1024 points from 0 to 3.3V starting from 0 to 1023. But as explained in the previous article on the prototype, only part of this range is used. So I’m using 3 parameters: a minimum value, a maximum value and a value to determine the limit between dry and humid. All should be from 0 to 1023. It is not checked in the class but a good programmer will do

Also, the analogic input has to be read in a regular timeframe. This is done by the UpdateTime value in seconds. A timer is raised every period to update the value of the humidity sensor.

public int MinValue
{ get; set; }

public int MaxValue
{ get; set; }

public int DeclValue
{ get; set; }

public int UpdateTime
{
    get { return myDeclUpdate; }
    set
    {
        MyTimer.Change(0, value * 1000);
        myDeclUpdate = value; 
    }
}

All 4 parameters are stored into Properties. The min, max and decl value are stored in normal Properties. The UpdateTime is a bit different. It has to change the value of the timer. Again, here, I do things in a simple way, but all those values should be checked before setting them.

Now let have a look at the timer

static void ClockTimer_Tick(object sender)
{
    HumiditySensor mSensor = (HumiditySensor)sender;
    mSensor.Update();
    //Debug.Print(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") 
+ " Humidity: " + mSensor.Humidity + " IsHumid: " + mSensor.IsHumid);
}

The code is quite simple, it first get the object. This function must be a static one as it is called by .NETMF when it is time. The sender object is the humidity sensor itself as setup in the constructor. After the cast, it is possible to call the update method.

public void Update()
{
    if (!Microsoft.SPOT.Hardware.SystemInfo.IsEmulator)
        Humidity = HumSensor.Read();
    else
        Humidity = new Random().Next(MaxValue);
}

I first check if we are in the emulator or on a real Platform. In the case I’m in the emulator, I just return a random number. This allow to test the software when I do development in planes like now on my way to Atlanta

In the other case, I read the analogic input and put the value into the Humidity property.

public int Humidity
{ get {
    return myHumidity;
}
    internal set {
        if (value < MinValue) value = MinValue;
        if (value > MaxValue) value = MaxValue;
        if (value >= DeclValue) bhumid = true; else bhumid = false;
        myHumidity = 100 * (value - MinValue)/(MaxValue - MinValue);} 
}

I allow to update this property only internally. I do the math with the Min, Max values to compute a percentage. And check if it is dry or humid.

And I’ve also created 2 other Properties I can use later in the code:

public bool IsHumid
{
    get
    { return bhumid; }
}

public int DeclHumidity
{ 
    get { return (100 * (DeclValue - MinValue) / (MaxValue - MinValue)) ; }
}

The IsHumid return true if it is humid compare to the level and the DeclHumidity return this level in percentage.

Here it is, you have a humidity sensor and the code to read the values Now we will look at how to use it. For this, I display the humidity level in the main web page with the information regarding the sprinklers. And I’ve also build a page to be able to change dynamically the values of the Humidity sensor. This is useful when you need to calibrate it.

HumiditySenrorParam MyHumidityStruc = new HumiditySenrorParam();
MyHumidityStruc.MinValue = 0;
MyHumidityStruc.MaxValue = 1023;
MyHumidityStruc.DeclValue = 500;
MyHumidityStruc.UpdateTime = 60;

Sprinklers[0].HumiditySensor = new HumiditySensor(Pins.GPIO_PIN_A0, MyHumidityStruc);

Nothing complex in this initialization phase. I’ve already explained in previous posts the Sprinkler class. I just added a HumiditySensor member. So I can have 1 humidity sensor per sprinkling zone. Looking at how it’s working in the industry. And I want to be flexible. So I can have a humidity sensor wherever I want. I’m using a parameter file which I read and interpret at boot time.

The final result looks like this with 1 humidity sensor:

And the code to build the page is easy:

strResp = "<HTML><BODY>netduino sprinkler<p>";
// need to test!
strResp = WebServer.OutPutStream(response, strResp);
for (int i = 0; i < NUMBER_SPRINKLERS; i++)
{
    strResp += "Springler " + Sprinklers[i].Name + ": <a href='/" 
+ paramPageSprinkler + ParamStart + securityKey + ParamSeparator 
+ paramSpr + i + ParamEqual + !Sprinklers[i].Open + "'>" 
+ Sprinklers[i].Open + "</a><br>";
    strResp += "<a href='/" + paramPageCalendar + ParamStart 
+ securityKey + ParamSeparator + paramYear + ParamEqual + DateTime.Now.Year 
+ ParamSeparator + paramMonth + ParamEqual + DateTime.Now.Month 
+ ParamSeparator + paramSpr + ParamEqual + i + "'>Program Sprinkler " 
+ Sprinklers[i].Name + "</a><br>";
    strResp += "<a href='/" + paramPageListPrgm + ParamStart 
+ securityKey + ParamSeparator + paramSpr + ParamEqual + i 
+ "'>List all programs for Sprinkler " + Sprinklers[i].Name + "</a><br>";
    if (Sprinklers[i].HumiditySensor != null)
    {
        strResp += "Humidity: " + Sprinklers[i].HumiditySensor.Humidity;
        if (Sprinklers[i].HumiditySensor.IsHumid)
            strResp += " and it is humid<br>";
        else
            strResp += " and it is time to sprinkle!<br>";
    }
    strResp = WebServer.OutPutStream(response, strResp);
}
strResp += "<p><a href='/" + paramPageUtil + ParamStart 
+ securityKey + ParamSeparator + paramClk + ParamEqual 
+ "1'>Update date and time</a><br>";
strResp += "<p><a href='/" + paramPageUtil + ParamStart 
+ securityKey + ParamSeparator + paramReboot + ParamEqual 
+ "1'>Reboot</a><br>";
strResp += DateTime.Now.ToString();
strResp += "</BODY></HTML>";
strResp = WebServer.OutPutStream(response, strResp);

ParamStart = ‘?’, ParamSeparator = ‘&’, ParamEqual = ‘=’, the various paramPage are the name of the page (like “spr.aspx” for paramPageSprinkler). It is mainly about building and URL like spr.aspx?sec=seckey&spr0=True

I display only the information regarding a humidity sensor if one has been setup. If not, I don’t display anything. And as you can see, it is really simple, the Humidity property return the humidity in percentage. and IsHumid allow to check if it is dry or humid so if it time to sprinkle or not

You’ve read this blog post up to this point. So I’m sure you still have energy! I’ve build a page to be able to update the various parameters. The page look like this with one humidity sensor. With multiple humidity sensor, it will just display more forms on the same page:

When updates, the result is the following:

My code allow also to get this information without and UI, just with the data. It allow also to just change one sensor and not all. I will not show all the code, I will just explain the core part with the forms:

for (int i = 0; i < NUMBER_SPRINKLERS; i++)
    if (Sprinklers[i].HumiditySensor != null)
    {
        //display a form with all params to be modified
        strResp += "<form method=\"get\" action=\"" 
+ paramPageHumidity + "\"><p>Humidity sensor " 
+ Sprinklers[i].Name;
        strResp += "<br />Humidity = " 
+ Sprinklers[i].HumiditySensor.Humidity + " and is Humid = " 
+ Sprinklers[i].HumiditySensor.IsHumid + "<br />";
        strResp += "Min = <input type=\"text\" name=\""
+ paramHumidityMinValue +"\" value=\"" + Sprinklers[i].HumiditySensor.MinValue 
+ "\" /><br />";
        strResp += "Max = <input type=\"text\" name=\""
+ paramHumidityMaxValue +"\" value=\"" + Sprinklers[i].HumiditySensor.MaxValue 
+ "\" /><br />";
        strResp += "Decl = <input type=\"text\" name=\""
+ paramHumidityDeclValue +"\" value=\"" + Sprinklers[i].HumiditySensor.DeclValue 
+ "\" /><br />";
        strResp += "Time update (sec) = <input type=\"text\" name=\""
+ paramHumidityTimeUpdate +"\" value=\"" 
+ Sprinklers[i].HumiditySensor.UpdateTime + "\" /><br />";
        strResp += "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<input id=\"Submit\" type=\"submit\" value=\"Update\" /></p>";
        strResp += "<input type=\"hidden\" name=\"" 
+ paramSpr + "\" value=\"" + i + "\">";
        strResp += "<input type=\"hidden\" name=\"" 
+ paramSecurityKey + "\" value=\"" + MySecurityKey + "\"></form>";
        strResp += "<br />";
        strResp = WebServer.OutPutStream(response, strResp);
    }

Nothing really complicated here, it’s just building a HTML page by hands The form will be posted with the GET method. So all parameters will be passed thru the URL. I’ve used this method for all the development I’ve done and you’ll find examples in my previous posts. Including the web server itself.

So enjoy this humidity sensor And I hope the weather will get dryer in Paris this summer so I’ll be able to calibrate it correctly, find the right level Under which it is interesting to sprinkle. And of course, next step is to automate all this! And let the system manage itself based on the soil humidity. And I will add other sensors like temperature! Stay tune and feedback welcome as usual.

A low cost humidity sensor for my sprinkler system

Laurelle — Sun, 24 Jun 2012 15:23:47 GMT

I’ve developed my own sprinkler system which embed a web server and allow me to control it remotely where ever I am. I can program when and how long I will sprinkler on which circuit. I have 3 circuits but my system can work with a large number of circuits.

What I want to do is to be able to add intelligence into my netduino board. This .NET Microframework (NETMF) board runs without any OS. So now Windows, no Linux, no Mac, nothing! Directly .NET on the chip. Not a full .NET of course but all what is necessary to be able to pilot IO, have a web server, etc. All this in an embedded board smallest of the size of a credit card.

Part of my project is to be able to measure the soil humidity. So I’ve decided to develop my own sensor. The basic idea is to measure the conductivity (or resistor) of the soil. Any object/material has it’s own resistance. The more conductive it is, the smallest the resistor is and the less conductive, the higher the resistor is. And it does apply to anything. Metals are usually excellent resistors with a very low resistance of less than 1 Ω. And something like a plastic will have more than 1 MΩ resistor. So if you apply a huge voltage, you’ll get a very small current.

The rule you have to know to do some electronic is U = R x I where U is the voltage (tension in volt V), R is the resistor (in ohm Ω) and I is the intensity of the current (in ampere, A). So I will measure the resistor 'of the soil and I will determine if it is dry or humid.

Let start wit a bit of theory there regarding soil conductivity. It is possible to measure the soil conductivity with a Tellurometer. Soil conductivity is measured by this specific sensor and the resistance of the soil is determined. In my case what will interest me is to be able to measure the difference of conductivity between a humid and a dry soil at the same place. It just need to have 2 stick of copper or any other metal put into the soil and have a current going thru one stick and measuring the difference of voltage from the other.

When a soil is humid the resistor decrease and when it is dry, it does increase. So imagine I will build something like a voltmeter put into the soil and I will measure the resistance. As my netduino has an analogic input I will use it for this purpose. What I measure here, is a voltage so indirectly this variance or resistance. As per the light sensor, I’ll use the same principle:

So I will measure the voltage of R3. R3 is a high value of 10K to do a pull down. It is a high resistor which will create a small current between the ground and A0. If I don’t put any resistor,I won’t be able to measure any intensity. And if I place A0 on the ogher side of my sensor and remove R3, I will use more current than in this design. It is possible to do the same as for the light sensor but in my case it will be a bit less efficient I guess.

R1 is here to reduce a bit the current and I will have to adjust this value regarding of my current soil.

The code is extremely simple:

SecretLabs.NETMF.Hardware.AnalogInput SoilSensor =
 new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);
//lightSensor.SetRange(0, 100);

int lSoilSensorReading = 0;
while (true)
{
    SoilSensorReading = SoilSensor.Read();
    Debug.Print(SoilSensorReading.ToString());
    Thread.Sleep(500);
}

I create an analogic input on port A0. And then I read the value every 500 milliseconds. And that’s it!

I’ve done the test with real soil, one is very humid, one a bit humid and one is very dry.

I get the following results:

very humid = 650
a bit humid = 630
very dry = 550

And here is the picture of the prototype:

As the analogic port has 1024 values going from 0 to 1023 on 3.3V, I have an amplitude of 100 values which represent a variance of approximately 0.32V.

So with this prototype I have a difference of 0.32V between dry and very humid with this specific soil.

I’m sure I can change a bit the sensitivity to use a broader range of the analogic input. I can do like for the light sensor an remove the R3 resistor and measure directly the tension between the sensor and the ground. I can also change R1 to a value close to the middle of the resistance of the soil. I can also change the alimentation value to 5V or so.

That was just a first experiment! Just to prove it is working Now, I need to improve a bit the system and see how far I can go. Any feedback from an electronic guy welcome.

Using XMLHttpRequest to pilot a Lego train dynamically in HTML 5

Laurelle — Wed, 20 Jun 2012 20:51:25 GMT

It’s a long time I did not write a blog post. I was very busy and had no time to write and code anything in the last weeks. I still have a lot of work but I need an intellectual break for the evening. So I do not write this post from a plane but from an hotel room. In my past blog posts I’ve explained how to pilot any Lego Power System with a Netduino using .NET Microframework.

In the HTTP Web server I’ve implemented, I command the train thru a URL with arguments. Those arguments are transformed into parameters which are given to a class. This class output a wave form into an infrared led amplified by a transistor. This is a simple and efficient way to command anything. I do the same for my sprinkler system.

Now if you want to pilot in a web interface multiple trains, and click on buttons or pictures to get an action without opening a new web page or refreshing the page, you need to do some Scripting in your HTML page. I’m not a web developer, I don’t like Scripting languages as they are not strict enough to write correct code and imply too many errors. They drastically increase your development time! I truly prefer a good language like C#, VB or even Java and I can go up to C/C++ Now, if I want to avoid any problem, I can jump into Eiffel OK, I won’t go up to there, I’ll stay with java script in an HTML5 page.

What I want is to call my command page in the background of the page and stay in the HTML page when I click on a button. There is a nice object in HTML which allow you to do that which is XMLHttpRequest. It is implemented in all decent browsers.

Here is the code that I generate dynamically (I’ll show you the code later) and I’ll explain you how it works:

<html xmlns="http://www.w3.org/1999/xhtml"><head>
<title></title></head><body>
<SCRIPT language="JavaScript">
var xhr = new XMLHttpRequest();
function btnclicked(boxMSG, cmdSend) {
    boxMSG.innerHTML = "Waiting";
    xhr.open('GET', 'singlepwm.aspx?' + cmdSend + '&sec=');
    xhr.send(null);
    xhr.onreadystatechange = function () {
        if (xhr.readyState == 4)
        { boxMSG.innerHTML = xhr.responseText; } 
};
}
</SCRIPT>
<TABLE BORDER="0"><TR><TD>
<FORM>Super train</TD><TD>
<INPUT type="button" 
onClick="btnclicked(document.getElementById('train0'),
'pw=11&op=0&ch=254')" 
value="<"></TD><TD>
<INPUT type="button" 
onClick="btnclicked(document.getElementById('train0'),
'pw=8&op=0&ch=254')" value="Stop"></TD><TD>
<INPUT type="button" 
onClick="btnclicked(document.getElementById('train0'),
'pw=5&op=0&ch=254')" value=">"></TD><TD>
<span id='train0'></span></FORM></TD></TR>

In the script part of the page, I have created a simple script. Those lines of code is what is necessary to do a synchronous call of an HTTP page and display the result in the page.

I create an XMLHttpRequest object which I call xhr. The function call btnclicked takes 2 arguments. the first one is the element of the page I will put the results of the request. And the second one is the command (the parameters) to pass to the URL which will pilot the infrared led as explain previously.

The function is very simple. First, I put “Waiting” in the element. Then I open the XMLHttpRequest object. I open it with GET and pass the overall URL.

The request is done when the send function is called. It is a synchronous call, so it get to the onreadystatechange when it is finished.

Here, when you read the documentation, the readyState 4 mean that everything went well and you have your data back. My function return “OK” when everything is OK and “Problem” if there is a problem.

Now let have a look at the rest of the HTML page. I decided to create a form with button input. Each button input has a onClick event. This event can be linked to a script. So I will call the fucntion describe before and give a span element (here train0) and the URL. The URL is different depending if you want to train to go forward, backward or stop. And I put all this in a nice table top be able to have multiple trains.

The page with 4 trains looks like this:

I’ve clicked on the forward button, “Wainting” is displayed in span. And as soon as the command will finish, it will either display OK or Problem. In my case, Problem will be displayed as in the Emulator, there is no SPI port!

// Start HTML document
strResp = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"
 \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
strResp += "<html xmlns=\"http://www.w3.org/1999/xhtml\">
<head><title></title></head><body>";
//creat the script part
strResp += "<SCRIPT language=\"JavaScript\">";
strResp += "var xhr = new XMLHttpRequest(); function btnclicked(boxMSG, cmdSend) 
{ boxMSG.innerHTML=\"Waiting\";";
strResp += "xhr.open('GET', 'singlepwm.aspx?' + cmdSend + '&" + securityKey + "');";
strResp += "xhr.send(null); xhr.onreadystatechange = function() 
{if (xhr.readyState == 4) {boxMSG.innerHTML=xhr.responseText;}};}";
strResp += "</SCRIPT>";
strResp = WebServer.OutPutStream(response, strResp);
// Create one section for each train
strResp += "<TABLE BORDER=\"0\">";
for (byte i = 0; i < myParamRail.NumberOfTrains; i++)
{
    strResp += "<TR><TD><FORM>" + myParamRail.Trains[i].TrainName + "</TD>
<TD><INPUT type=\"button\" 
onClick=\"btnclicked(document.getElementById('train" + i + "')
,'pw=" + (16 - myParamRail.Trains[i].Speed);
    strResp += "&op="+ myParamRail.Trains[i].RedBlue + "&ch=" + 
(myParamRail.Trains[i].Channel - 1) + "')\" value=\"<\"></TD>";
    strResp += "<TD><INPUT type=\"button\" 
onClick=\"btnclicked(document.getElementById('train" + i + "'),'pw=8";
    strResp += "&op=" + myParamRail.Trains[i].RedBlue + "&ch=" + 
(myParamRail.Trains[i].Channel - 1) + "')\" value=\"Stop\"></TD>";
    strResp += "<TD><INPUT type=\"button\" 
onClick=\"btnclicked(document.getElementById('train" + i + "'),
'pw=" + myParamRail.Trains[i].Speed;
    strResp += "&op=" + myParamRail.Trains[i].RedBlue + "&ch=" + 
(myParamRail.Trains[i].Channel - 1) + "')\" value=\">\"></TD>";
    strResp += "<TD><span id='train" + i + "'></span></FORM></TD></TR>"; 
    strResp = WebServer.OutPutStream(response, strResp);
}
strResp += "</TABLE><br><a href='all.aspx?" + securityKey + 
"'>Display all page</a>";
strResp += "</body></html>";
strResp = WebServer.OutPutStream(response, strResp);

The code to generate the HMTL page is here. As you see it is manually generated. The table which contains the name of the train, the backward, stop and forward button is created totally dynamically. Each train may have a different speed and use different channels so the URL is generated dynamically.

All this takes time to generate and to output in the Stream. So it’s much better to do it only 1 time and then call a simple and small function which will return just a bit of text.

Last part, on the server header, you have to make sure you add “Cache-Control: no-cache” in the response header. If you don’t do it, only the first request will be send to the netduino board back. XMLHttpRequest will consider that the page will never expire. So I’ve modified the header code of my HTTP Server like this:

string header = "HTTP/1.1 200 OK\r\nContent-Type: text/html; 
charset=utf-8\r\nCache-Control: no-cache\r\nConnection: 
close\r\n\r\n";
connection.Send(Encoding.UTF8.GetBytes(header), header.Length, 
SocketFlags.None);

What is interesting there is that I can now pilot up to 8 Lego trains using this very simple interface and without having to refresh the page.

And the excellent news is that it is working from my Windows Phone so it’s even cool to pilot your Lego train from your Windows Phone. I haven’t tested from an Android or iPhone but I’m quite sure it will work the same way. Remember that all the code is sitting in a very small hardware with no OS, just .NET Microframework! As always, do not hesitate to send me your comments

Creating an efficient HTTP Web Server for .NET Microframework (NETMF)

Laurelle — Tue, 29 May 2012 16:36:53 GMT

That’s not the first post I’m doing on incorporating a Web Server in .NET Microframework (NETMF). In some of my previous posts, I’ve explain how to do it using the existing .NET classes for this. And it is working very well!

The main concerns I have is that I’m using a netduino board. This board is great, I love it. But there is a very limited amount of memory available and limited amount of space to store the programs. Total storage is 64Kb and what is left when the code is in is about 48K… So very little amount of memory. And the http .NET classes are great and use stream but they are intense in terms of memory and also the main http class is huge…

So I had to find a solution and it was to redevelop a web server like IIS or Apache. OK, I can’t compare I just want a web server which handle GET answers and respond a simple web page. The other challenge I have is to be able to reuse the code I4ve already written for my Sprinkler, to pilot my Lego city and my Lego infrared receiver like my Lego trains…

So I was searching for code to reuse on the Internet and found some code. So I did a mix of existing code and spend some time testing various solutions Most of the existing code is not really robust. It does fail if there is a network problem, if 2 requests arrive at the same time, etc. I’m not saying my code is perfect but it is working and working well for the last month with no problem at all.

A web server is simple, it’s just a connection on a socket and a protocol of communication which is HTTP. It is also very simple as it is text based. What is interesting is to see all what you can do with such a simple protocol and such a simple markup language like HTML and some javascript.

OK, so let start with what is necessary: a thread that will run all the time and handle socket requests. So we need also a socket. And a way to stop the thread.

private bool cancel = false;
private Thread serverThread = null;

public WebServer(int port, int timeout)
{
    this.Timeout = timeout;
    this.Port = port;
    this.serverThread = new Thread(StartServer);
    Debug.Print("Web server started on port " + port.ToString());
}

As you can see, it is quite simple, the WebServer object is initialize with a specific port and a timeout. By default, the http port is 80 but it can be anything. There is no limitation. And as it’s easy to implement, let make the code generic enough to be able to be use with different ports. And a new Thread is created to point on function StartServer. I will detail it later. I will explain also why we need a timeout later.

Now we have this object initialize, let start the Webserver:

public bool Start()
{
    bool bStarted = true;
    // start server           
    try
    {
        cancel = false;
        serverThread.Start();
        Debug.Print("Started server in thread " + serverThread.GetHashCode().ToString());
    }
    catch
    {   //if there is a problem, maybe due to the fact we did not wait engouth
        cancel = true;
        bStarted = false;
    }
    return bStarted;
}

That is where the fun being! We start listening and initialize a variable we will use later to stop the server if needed. The catch can contain something to retry to start, here, it just return if it is started or not. At this stage, it should work with no problem as it is only a thread starting. But who knows

private void StartServer()
{
    using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
    {
        //set a receive Timeout to avoid too long connection 
        server.ReceiveTimeout = this.Timeout;
        server.Bind(new IPEndPoint(IPAddress.Any, this.Port));
        server.Listen(int.MaxValue);
        while (!cancel)
        {
            try
            {

                using (Socket connection = server.Accept())
                {
                    if (connection.Poll(-1, SelectMode.SelectRead))
                    {
                        // Create buffer and receive raw bytes.
                        byte[] bytes = new byte[connection.Available];
                        int count = connection.Receive(bytes);
                        Debug.Print("Request received from " 
+ connection.RemoteEndPoint.ToString() + " at " + DateTime.Now.ToString("dd MMM yyyy HH:mm:ss"));
                        //stup some time for send timeout as 10s.
                        //necessary to avoid any problem when multiple requests are done the same time.
                        connection.SendTimeout = this.Timeout; ;
                        // Convert to string, will include HTTP headers.
                        string rawData = new string(Encoding.UTF8.GetChars(bytes));
                        string mURI;

                        // Remove GET + Space
                        // pull out uri and remove the first /
                        if (rawData.Length > 5)
                        {
                            int uriStart = rawData.IndexOf(' ') + 2;
                            mURI = rawData.Substring(uriStart, rawData.IndexOf(' ', uriStart) - uriStart);
                        }
                        else
                            mURI = "";
                        // return a simple header
                        string header = "HTTP/1.1 200 OK\r\nContent-Type: text/html
; charset=utf-8\r\nConnection: close\r\n\r\n";
                        connection.Send(Encoding.UTF8.GetBytes(header), header.Length, SocketFlags.None);
                        if (CommandReceived != null)
                            CommandReceived(this, new WebServerEventArgs(connection, mURI));
                    }
                }
            }
            catch (Exception e)
            {
                //this may be due to a bad IP address
                Debug.Print(e.Message);
            }
        }
    }
}

This function will run all the time in a thread. It’s in an infinite loop which can be break by the cancel variable. First, we need to initialize the Socket. We will use IPv4 with a stream and the TCP protocol. No timeout to receive the request. The, you’ll have to bind this socket to a physical IP address. In our case, we will use all IP address on the port initialized before. Any IP address mean all addresses and in our case only 1 IP address as we do have only 1 Ethernet interface. We are using '”using” to make sure the server Socket will be closed and cleaned properly after usage.

The way it is working is not too complicated. Remember that we’ve open a Socket named Server, setup it to listen to port 80. This is running in a separate thread in this thread. So in order to analyze the information returned when a connection is accepted (so when a Browser ask for a page), we need to create another Socket pointing to the same Socket, here “using (Socket connection = server.Accept())”. In this case “using” allow the code to clean in the “proper way” when the thread will be finished or then the loop end or when it goes back to the initial loop. It’s thread in thread and if you don’t close things correctly, it can quickly let lots of objects in the memory, objects which will be seen as alive by the garbage collector.

When there are bytes ready to read with connection.Poll, we just read them. The request is transformed into a string. An http request look like “GET /folder/name.ext?param1=foo&param2=bar HTTP/1.1”. Areal life example looks more like this: "GET /folder/name.ext?param1=foo&param2=bar HTTP/1.1\r\nAccept: text/html, application/xhtml+xml, */*\r\nAccept-Language: fr-FR,fr;q=0.8,en-US;q=0.5,en;q=0.3\r\nUser-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)\r\nAccept-Encoding: gzip, deflate, peerdist\r\nHost: localhost:81\r\nConnection: Keep-Alive\r\nX-P2P-PeerDist: Version=1.1\r\nX-P2P-PeerDistEx: MinContentInformation=1.0, MaxContentInformation=1.0\r\n\r\n"

For a normal, full web server like IIS or Apache, you’ll analyze all those parameters, and there are lots, see the W3C protocol here. For our usage, the only thing that interest us is the full URL. And it is located between the 2 first spaces. And we will extract the URL, remove the first ‘/’ as I will not use it in the rest of the code.

Now, the next step is to start answering the request. When someone ask you something, it’s polite to answer Like for the request, the response need to have couple of header information. And as my usage is extremely simple, I will always consider that it is OK, I’m only delivering text content and that the connection can be closed. By the way, whatever you put there, HTTP is a disconnected protocol, so you should never consider that you are always connected! It’s an error and can drive you to very bad behaviors.

connection.Send return the first part of the message and then I call an event to tell the creator of the WebServer object that something happened. I send of course the connection object so that the caller will be able to create an HTML page and answer and also the URL so that it can analyze it.

Last but not least, the try and catch is extremely important. With Sockets a problem can quickly arrive due to a network problem. And I’ve seen it happening on the netduino for no reason. Just capturing the problem and not doing anything makes the web server working for months! Even if you loose the network, the catch will capture the problem and the server will continue to work up to the point the network will work again. The other reason to use it is because of the timeout. If something happen between the client and our webserver, after the timeout, you’ll get in this catch and you’ll start a new socket and the process will go back to something normal. It can happen and happened to me with very long HTML pages I was generating. When I was interrupting the creation and ask for a new page, the socket went into a kind of infinite loop waiting for a request. There should be a smart way to check is something goes well or not but it’s an easy way.

public delegate void GetRequestHandler(object obj, WebServerEventArgs e);
public class WebServerEventArgs: EventArgs
{
    public WebServerEventArgs(Socket mresponse, string mrawURL)
    {
        this.response = mresponse;
        this.rawURL = mrawURL;
    }
    public Socket response { get; protected set;  }
    public string rawURL { get; protected set; }

}

public event GetRequestHandler CommandReceived;

Right after the header is sent back, an event is raised. The arguments are simple here, we do send the Socket object and the URL. If you want to enrich the web server, you can add other elements like the header element rather than sending them right away, the browser requesting the page, the IP address or whatever you want! Again, simple and efficient there.

Last but not least if you need to stop the Server, you’ll need a function to this and also to clean the code at the end:

private bool Restart()
{
    Stop();
    return Start();
}
public void Stop()
{
    cancel = true;
    Thread.Sleep(100);
    serverThread.Suspend();
    Debug.Print("Stoped server in thread ");
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    if (disposing)
    {
        serverThread = null;
    }
}

Nothing too complex there, it’s just about pausing the thread (remember, there are other tread attached in it), closing the other thread leaving in the Server object and cleaning everything. I hope it’s the good code to let it clean But at the end of the day, my only interest is to let this server running all the time. So I don not really care if it will stop correctly!

Now, to use the server, easy:

private static WebServer server;

// Start the HTTP Server
WebServer server = new WebServer(80, 10000);
server.CommandReceived += new WebServer.GetRequestHandler(ProcessClientGetRequest);
// Start the server.
server.Start();

Declare a static WebServer if you want it to be unique. Technically, you can have multiple servers running on different port. In my case, no need for this. Then, it’s about creating the object, adding an event and starting the server!

private static void ProcessClientGetRequest(object obj, WebServer.WebServerEventArgs e)

And you are ready to do some treatment into this function. To return part of the answer, just use e.response.Send as for the header part and you’re done!

To simplify the process, as it’s a function which you’ll have to call often, I’ve created a function to do this:

public static string OutPutStream(Socket response, string strResponse)
{
    byte[] messageBody = Encoding.UTF8.GetBytes(strResponse);
    response.Send(messageBody, 0, messageBody.Length, SocketFlags.None);
    //allow time to physically send the bits
    Thread.Sleep(10);
    return "";
}

This can be a function you add in your main code or can add in the Web Server code.

Now you have a fully functional simple Web Server. You can read the previous article on how to handle parameters and analyzing them. The code to manage the parameter is now in the WebServer class.

I’ll post the code in CodePlex so anyone will be able to use it as a helper.

Enjoy this code Again, I’m just a marketing director doing some code. And it’s the code running in my sprinkler management system for the last month without any problem!

Using a SPI device with netduino and .NET micro framework

Laurelle — Tue, 22 May 2012 18:27:04 GMT

After playing with I2C, with various IO, I’ve decided to play a bit with SPI The real project behind using a SPI device is to be able to use it a a multiplexer/demultipler of IO.

I want to pilot lights for my Lego train. The idea is to have the ability to switch a signal light to green or red. I want to be able to have 16 lights. The netduino board have only 14 digital IO and 6 analogic. And I’m already using some to pilot the Lego train thru infrared. See previous article.

So I have to find a multiplexing solution. And one is used by most of the netduino fan: SPI. In terms of electronic it’s simple, it is a serial to parallel (and vice versa as you can read also). The component the most used for this is 74HC595. There are couple of basics explanations on the netduino wiki and also good examples as always on Mario Vernari blog.

Each 74HC595 can have 8 output and they can be chained. Which mean that you can use 2 component to have 16 output. And you basically put them in series. One output of one 74HC595 to the input of the others.

I spend quite a bit of time to understand how to plug the 74HC595 to the netduino. So here is what to do:

Pin 8 is ground
Pin 16 is VCC (+5V recommended)
Pin 14 to netduino pin D11 (called MOSI) for the first 74HC595 of the chain. For the next one it has to be linked to the Pin 9 of the previous 74HC595
Pin 13 to ground (used to activate or not the 8 output)
Pin 12 to one output port you’ll choose on the netduino. Let say pin D10. This one is used to select the 74HC595 when you have multiple 74HC595 used in parallel for different purposes (called SS)
Pin 11 to netduino pin D13 (called SCLK)
Pin 10 to +VSS (this one is used to reset if needed)
Pin 15, 1, 2, 3, 4, 5, 6, 7 are the output pin
Pin 9 has to be linked to the next 74HC595 of the chain if there are more than 1.

And that’s it for the basics! Now what I want to do with the output is to be able to light one led green or switch it to red. So I’ll use the output of the 74HC595. When it will be 1, I’ll light the green one, when it will be 0, I’ll light the red one. Here is the hardware to schematic:

When the signal will be 1, the current will go thru the green light light. And when it will be 0, the inverter will switch to 1 and the red light will light. It just need 3 cables per light and the current can be transported on long distance. The RS resistor can be adapted with a lower resistor to 100 or something like this in order to send a more intense current in the cable as there will be some loss if it is very long. by the way I recommend to read the excellent article on the length of cable and impact on signal noise from Mario.

Now, in terms of software, It’s not so difficult. In my project, I’m using the SPI for multiple purpose. So I need to use it in a smart way. SPI can be shared and the only thing to do is to change the configuration and write (and read) right after. So I’m using the MultiSPI class from the NETMF Toolbox. It’s an impressive toolbox containing lots of helpers. It goes from hardware to HTTP web client. There is a 74HC595 also but I found it more complex to use that just directly using the MultiSPI class.

Here the example of class to switch to green (1) or red (0) a specific output of the 2 74HC595:

public class Signal
{
    private byte mNumberSignal;
    private bool[] mSignalStatus;
    public const byte NUMBER_SIGNAL_MAX = 16;
    private MultiSPI MySignal;

    public Signal(byte NumberOfSignal)
    {
        mNumberSignal = NumberOfSignal;
        if ((mNumberSignal <= 0) && (mNumberSignal > NUMBER_SIGNAL_MAX))
            new Exception("Not correct number of Signals");
        mSignalStatus = new bool[mNumberSignal];
        // open a SPI
        MySignal = new MultiSPI(new SPI.Configuration(
            Pins.GPIO_PIN_D10, // SS-pin
            false,             // SS-pin active state
            0,                 // The setup time for the SS port
            0,                 // The hold time for the SS port
            false,              // The idle state of the clock
            true,             // The sampling clock edge
            1000,              // The SPI clock rate in KHz
            SPI_Devices.SPI1));   // The used SPI bus (refers to a MOSI MISO and SCLK pinset)

        //initialise all signals to "false"
        for (byte i = 0; i < mNumberSignal; i++)
            ChangeSignal(i, true);
    }

    public byte NumberOfSignals
    { get { return mNumberSignal; } }

    public void ChangeSignal(byte NumSignal, bool value)
    {
        if ((NumSignal <= 0) && (NumSignal > mNumberSignal))
            new Exception("Not correct number of Signals");
        //need to convert to select the right Signal
        mSignalStatus[NumSignal] = value;
        // fill the buffer to be sent
        ushort[] mySign = new ushort[1] { 0 };
        for (ushort i = 0; i < mNumberSignal; i++)
            if (mSignalStatus[i])
                mySign[0] = (ushort)(mySign[0] | (ushort)(1 << i));
        //send the bytes
        MySignal.Write(mySign);
        

    }

    public bool GetSignal(byte NumSignal)
    {
        if ((NumSignal <= 0) && (NumSignal > mNumberSignal))
            new Exception("Not correct number of Signals");
        return mSignalStatus[NumSignal];
    }
}

I just need to declare a MultiSPI. The SPI Configuration contains the necessary information to setup the 74HC595. The SS pin is set to D10. So I can use the SPI for other purposed to pilot my Lego infrared modules. And in the Lego module, I’ll have also to declare the SPI as MultiSPI.

What the MultiSPI class is doing is very simple. It has a static SPI in its private variables. And a SPI.Configuration which is not static.

/// <summary>Reference to the SPI Device. All MultiSPI 
devices use the same SPI class from the NETMF, so this reference is static</summary>
private static SPI _SPIDevice;
/// <summary>SPI Configuration. Different for each device, so not a static reference</summary>
private SPI.Configuration _Configuration;

// Store the configuration file for each MultiSPI instance
Sets the configuration in a local value
this._Configuration = config;

// If no SPI Device exists yet, we create it's first instance
if (_SPIDevice == null)
{
    // Creates the SPI Device only 1 time as it is a static!
    _SPIDevice = new SPI(this._Configuration);
}

public void Write(byte[] WriteBuffer)
{
    _SPIDevice.Config = this._Configuration;
    _SPIDevice.Write(WriteBuffer);
}

So each time a program want to write in a SPI, the right configuration is selected and the write command is send. It’s working like this to read. The full class is a bit more complex but the main principle is there.

The rest of my code is very simple and I’m sure I would have been to write it in a better way. I’m just storing the state of a signal and then output all the buffer to the SPI.

So bottom line, it is very easy to use SPI as a multiplexer/demultipler for IO. That was what I needed. I did not tested yet how to read the data but it should be as simple!

Managing my Sprinklers from the Cloud

Laurelle — Mon, 07 May 2012 06:32:50 GMT

I’ve started a project to pilot my sprinklers remotely and make them smart almost 9 months ago. The idea is to be able to remotely open and close my sprinklers but also be able to launch automatic sprinkling cycles.

After some software and hardware development, I now have a fully working solution:

You can see the netduino .NET Microframework board where all the smart is happening. I wrote couple of articles already to show how to implement a web server, launch timers, create calendars, get the date and time. I’ve also wrote couple of articles on hardware.

Recently, I’ve met with Alain, a Lego fan like me and I show him the way I can control any Lego Power Function element using .NET Microframework. And we discussed about my sprinkler project. I was about to implement the final solution with my existing 9V Gardena electro valves. And he challenged ma on this telling me that I will never know the status of the electro valve if I hacked the Gardena system. And he tell me to go for a 24V DC electro valve. The big advantage is that when you switch on the current, it open the valve, when it’s off, it close. So no unknown state like with the bistable valve from Gardena. So I bought 3 24V DC electro valve for 22€ each plus couple of cents for the diode (never forget to add a return current diode on a solenoid ).

And the display screen with the button you see is a Crouzet automate. It’s a gift from Alain and it’s really cool to have it. For my project, it can be replaced by 3 buttons, 3 leds and 3 transistors but it’s just more cool The netduino enter in the DC input section and when the voltage is higher than 2V (normal high level is 3.3V), it just switch on an electro valve. So nothing complicated there.

What has been long is to bring electricity when I wanted this box to be plus networking plus bring cables to all the places where I have electro valves. And as I have in front and rear of the house, I have lots of cables to install nicely in the basement. And just this took 1 full day with a friend who helped me. Thanks Thomas by the way

And now from my Windows Phone or a PC or any other device which support HTML, I can open, close and program my sprinklers:

I’m an happy geek And as there are always some improvement to do, next step is to add a I2C temperature sensor to get information on the temperature outside and implement automatic rules.

Stay tune!