TMP36 Temperature Sensor

Before I got on a side-track on the MQTT project, I'd wanted to interface with a temperature sensor. The one I had originally chosen turned out to be a one-wire digital sensor.  This is probably a great sensor, but there are, as I understand now, some issues with the Netduino and one-wire sensors.  So, that sensor got sidelined until this support is fixed up and in non-beta firmware (or until I buy a FEZ Cobra - which would address several issues I'm facing - albeit with a significantly higher price tag.)

So, off I went to find a analog temperature sensor.  There are numerous options - I even briefly thought about drafting one of my MSP430's for this.  :)

But I settled for a TMP36 from Futurlec.  This (I mean 'these' - never only buy 1 of anything :) ) arrived on Friday after a trip from Hong Kong along with a bunch of random odds and ends that I'm tired of going to Radio Shack to get - 2 at a time (I'm ok with 100%+ markup to get it in town - but throw 10-20 into a bag, not 2).

Between the datasheet (http://www.analog.com/static/imported-files/data_sheets/TMP35_36_37.pdf) and some help from the AdaFruit blog (http://www.ladyada.net/learn/sensors/tmp36.html) we got it working pretty well.

The cap is actually a normal orange ceramic disk - not sure why Fritzing doesn't have those.  It was added per the datasheet (0.1uF) for RFI purposes - but, in my non-scientific testing, it didn't make any difference if it was there or not (at least in my environment - which I'd figure is a mess RFI-wise).

I have several temperature sensors that I want to play with, so we made a class to hold those:

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;

namespace Temperature_Sensors
{

    public static class TMP36
    {

        // port is analog port
        // sample is the number of samples to take
        // interval is the time (ms) to wait between samples
        // voltage is input voltage * 1000, default is 3.3v
        public static float getVoltage(AnalogInput port, int sample = 10, int interval = 100, int voltage = 3300)
        {
            int reading = 0;
            for (int i = 0; i < sample; i++)
            {
                Thread.Sleep(interval);
                // Read the value on the AIO port
                reading += port.Read();
            }
            reading /= sample;
            Debug.Print("Reading: " + reading + "");
            // Voltage at pin in milliVolts = (reading from ADC) * (3300/1024) http://www.ladyada.net/learn/sensors/tmp36.html
            return (reading * (voltage / 1024F));
        }

        public static float getCTemp(AnalogInput port, int sample = 10, int interval = 100, int voltage = 3300)
        {
            // Temp in °C = [(Vout in mV) - 500] / 10 http://www.ladyada.net/learn/sensors/tmp36.html
            return ((getVoltage(port, sample, interval, voltage) - 500F) / 10F);
        }

        public static float getFTemp(AnalogInput port, int sample = 10, int interval = 100, int voltage = 3300)
        {
            // Convert to °F 
            return ((getCTemp(port, sample, interval, voltage) * (9F / 5F)) + 32F);
        }
    }
}

And here is a program to drive this - with a timer being used to periodically collect the temperature:

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.NetduinoPlus;
using Temperature_Sensors;

namespace myTempSensor
{
    public class Program
    {
        static AnalogInput analogInput;

        static void checkTemp(object o)
        {
            float fTemp = TMP36.getFTemp(analogInput, 10, 100, 3300);
            Debug.Print("Temp: " + fTemp + "");
        }

        public static void Main()
        {

            analogInput = new AnalogInput(Pins.GPIO_PIN_A0);
            Timer tempTimer = new Timer(new TimerCallback(checkTemp), null, 1000, 10000);

            // go to sleep until the timer wakes us (saves power)
            Thread.Sleep(Timeout.Infinite);
        }
    }
}

Right now we're not doing anything with this data - but soon we'll smoosh this up against the MQTT stuff and start getting this published - probably to the test.mosquitto.org server.

<aside>
Speaking of which - we might have to take another break and write some visualization stuff - Roger of Mosquitto fame has issued a challenge (http://mosquitto.org/2012/01/challenge-web-based-mqtt-graphing/) for visualization of some energy data that is being fed to his server.  This might be fun.  I'm thinking of using the Node.js client then feeding that data into the Google charts API.
</aside>

Anyway, I haven't got this sensor to be particularly accurate yet.  Although, forcing my math to floating point math REALLY helped.  :)  I may just try a thermistor.  Not sure, I'm sure that a digital sensor is probably the right plan...  I think my main problem at this point is the accuracy of the sensor (+-2C), mixed with the stated "non-high precision" of the Netduino ADC's.  So, this combination seems to be about as accurate as that of my other "high precision" thermometer.  :)

Since the accuracy is odd - I added the ability to collect a bunch of readings and average them.  Not sure it really helped as much as I would have expected either, but it's there.

I think next up is going to be a Syslog library for the Netduino - which will require an NTP library since I don't have an RTC board handy and you need time for logs.  (FEZ Cobra has one though I think....Which might be a better approach than buying a mini-board...  I don't know...  I could do SSL with the Cobra too...)

And we'll keep working on the MQTT stuff.  Still need a couple message handlers and to redo some stuff related to the fixed headers.

Also, kind of seriously thinking about writing an MQTT-S gateway (forwarder?) and client for the Netduino Plus - then getting some sort of comm stuff to talk between a few things around here.  I'm kind of taking that "no publicly available implementation" bit as a challenge...  :)

Project updates - 16 Jan

Over the last week or so, we've had some fun and made some progress on a couple projects.

Last week we went to the Omaha Maker's Group meeting.  This was our first trip down there.  It's a nice location full of neat projects and interesting people.  We watched a fun presentation on an attempt at a high-altitude rocket build and launch.  The kids have been asking when the next one is scheduled for.  :)

Speaking of the OMG, we're going there on the 7th of Feb to demo our little robot and maybe a couple other Netduino projects (maybe HID and MQTT).

On the robot front, we got our new IR sensor in the other day.  Tonight Steven got the new sensor installed and then I added some button support (on/off) and re-calibrated the code for the new sensor (a bit more near-sighted (our choice) than the last one we used).  I then did a brief write-up on how everything works and a pin-out chart in case something happens in-route - because he's taking the robot to school to show his in-school robotics class!

On the MQTT front, I got the publishing bit all done and am now in the process of adding subscription support.  I really need to get this completed in the next couple of days, because I have a NeTV en-route to me and I know as soon as I get that - I'll be up all night fooling with that instead of MQTT.  :)

We ran to Harbor Freight this weekend and got our free screw-driver set plus picked up a $8 rotary tool and a couple bins for when my Futurlec order gets here.

Finally, we've got Valentine's Projects to get to work on as soon as the parts for them arrive.  I need to find a place in town that can do plastic work - we could use some cut plastic sheet to dress our projects up a bit...

I have so many projects going on - we'd better get some snow soon.  :)

But that's it for us, for now.

Half-Baked MQTT Publisher for Netduino Plus

UPDATE:  This has been moved to GitHub: https://github.com/danielan/NetduinoMQTT

I received a Netduino Plus for Christmas this year. So, I needed a project to put this to work. After working my way through the O'Reilly/Make book, "Getting Started with the Internet of Things" book, I decided to implement a MQTT publisher for my Netduino Plus.

Now, MQTT is a really cool protocol that can be used for all sorts of things and supports all sorts of neat features.  This isn't that sort of program.  :)

All this does, in a weak way, is connect to a message broker, publish a message without QoS and then disconnect.  This is NOT how you should do it.  This doesn't work for long topics, long messages, etc.  It doesn't retry if there is a problem, etc.

This is intended only for my use - ultimately publishing a temperature from a sensor over and over - but I'm back to work tomorrow, so this will probably be idle for some time.

I hope this helps - but don't use it expecting it to be useful without more work. 

So, enough disclaimers... :)

MQTT

I learned of MQTT from this post at AdaFruit: http://www.adafruit.com/blog/2011/11/08/ibm-open-sources-potential-internet-of-things-protocol/

And the learned more from this Series on "ReadWriteWeb":
http://www.readwriteweb.com/hack/2011/11/ibms-andy-piper-negotiating-th.php
http://www.readwriteweb.com/hack/2011/11/ibms-andy-piper-part-2-how-mqt.php
http://www.readwriteweb.com/hack/2011/11/ibms-andy-piper-part-3-the-tax.php

There's also a web site at: http://mqtt.org/

And the quite useful official specification is over here: http://public.dhe.ibm.com/software/dw/webservices/ws-mqtt/mqtt-v3r1.html

Demoing MQTT

To use MQTT you need a "Broker" - I used "Really Small Message Broker" from here: https://www.ibm.com/developerworks/community/groups/service/html/communityview?communityUuid=d5bedadd-e46f-4c97-af89-22d65ffee070

To demo this, download rsmb from there and unzip it.  Then open 4 "cmd" windows and make your working directory in the folder "windows" (assuming Windows) in the rsmb directory you just extracted.

In one cmd window run: broker.exe

In the next cmd window run: stdinpub.exe test
In another cmd window run: stdoutsub.exe test --clientid one
In the last cmd window run: stdoutsub.exe test --clientid two

"test" is the name of our topic. The client ids are necessary because, I assume, there is a bug in the windows stdoutsub.exe binary - the names are supposed to be unique by default*, but aren't.

* "Help" for stdoutsub.exe: "--clientid <clientid> (default is hostname+timestamp)"  But in reality they seem to default to "stdout-subscriber" - I'll see if I can find someone to report this to.

Now, if you type something into the stdinpub.exe window - you should see it show up in the two stdoutsub.exe windows.  This is, simplistically, what MQTT is for (lightweight publisher/subscriber model comms).

(These windows will also be useful to see if our program is working.)

The Code

There's a library available for MQTT on all sorts of languages and software, but I couldn't find anything for the Netduino Plus (although maybe the .NET one would work?)

It would probably be a good idea to read through the standard first.  I used hex for flags and numbers where they made more sense.  I started to do constants, but didn't get finished yet...

(Note - the flags are easier to decipher if you remember that for hex you use 4 bits per hex digit.)

While keeping in mind that this is not appropriate for actual use....

Here is the code for the "library".

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using Microsoft.SPOT;
using Socket = System.Net.Sockets.Socket;

namespace Netduino_MQTT_Client_Library
{
    static class Constants
    {
        public const int MQTTVERSION = 3;
    }

    public static class MQTTClient
    {
        // From Sample Code (SockClient.cs) Copyright Microsoft
        public static Socket ConnectSocket(String server, Int32 port)
        {
            // Get server's IP address.
            IPHostEntry hostEntry = Dns.GetHostEntry(server);

            // Create socket and connect to the server's IP address and port
            Socket socket = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);
            socket.Connect(new IPEndPoint(hostEntry.AddressList[0], port));
            return socket;
        }
        // End of Microsoft Copyright sample code

        public static void ConnectMQTT(Socket mySocket, String clientID)
        {

            int index=0;
            byte[] buffer = null;
            buffer = new byte[16 + clientID.Length];
            // Fixed Header (2.1)
            buffer[index++] = 0x10; // Fixed header flags
            buffer[index++] = (byte)(14 + clientID.Length); // Remaining Length
            // End Fixed Header
            // Connect (3.1) 
            // Protocol Name
            buffer[index++] = 0;       // String (MQIsdp) Length MSB
            buffer[index++] = 6;       // Length LSB
            buffer[index++] = (byte)'M';  // M
            buffer[index++] = (byte)'Q';  // Q
            buffer[index++] = (byte)'I';  // I
            buffer[index++] = (byte)'s';  // s
            buffer[index++] = (byte)'d';  // d
            buffer[index++] = (byte)'p';  // p
            // Protocol Version
            buffer[index++] = Constants.MQTTVERSION;
            // Connect Flags
            buffer[index++] = 0x02;
            //Keep alive (20 seconds)
            buffer[index++] = 0;     // Keep Alive MSB
            buffer[index++] = 20;    // Keep Alive LSB
            // ClientID
            buffer[index++] = 0;                        // Length MSB
            buffer[index++] = (byte)clientID.Length;    // Length LSB
            for (var i = 0; i < clientID.Length; i++) 
            {
                buffer[index++] = (byte)clientID[i]; 
            }
            mySocket.Send(buffer, index, 0);

        }

        public static void PublishMQTT(Socket mySocket, String topic, String message)
        {

            int index = 0;
            byte[] buffer = null;
            buffer = new byte[4 + topic.Length + message.Length];
            // Fixed header
            //      Publish (3.3) fixed header flags
            buffer[index++] = 0x30;
            //      Remaining Length (variable header + payload)
            buffer[index++] = (byte)(2 + topic.Length + message.Length);
            // End of fixed header 
            // Variable header (topic)
            buffer[index++] = 0;                   // Length MSB
            buffer[index++] = (byte)topic.Length;  // Length LSB
            // End of variable header
            for (var i = 0; i < topic.Length; i++)
            {
                buffer[index++] = (byte)topic[i];
            }
            // Message (Length is accounted for in the fixed header)
            for (var i = 0; i < message.Length; i++)
            {
                buffer[index++] = (byte)message[i];
            }
            mySocket.Send(buffer, buffer.Length, 0);
        }

        public static void DisconnectMQTT(Socket mySocket)
        {
            byte[] buffer = null;
            buffer = new byte[2];
            buffer[0] = 0xe0;
            buffer[1] = 0x00;
            mySocket.Send(buffer, buffer.Length, 0);
        }
    }
}

Here is the code to use this library (Don't forget to change to your IP (where broker.exe is running)).

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.NetduinoPlus;
using Netduino_MQTT_Client_Library;

namespace NetduinoMQTT
{
    public class Program
    {
        public static void Main()
        {
            // This is where you would do your work
            Socket mySocket = MQTTClient.ConnectSocket("192.168.1.1",1883);
            MQTTClient.ConnectMQTT(mySocket,"tester123");
            MQTTClient.PublishMQTT(mySocket, "test", "testme12");
            Thread.Sleep(1000);
            MQTTClient.DisconnectMQTT(mySocket);
        }
    }
}

Deploy this to your Netduino Plus and you should see the message, "testme12" appear in your stdoutsub.exe windows (and some connection messages in your broker.exe window).


To Do

If you wanted to use this for anything, probably at a minimum you should account for connect failures, longer topics, longer messages, maybe QoS, maybe authentication, maybe use the SSL version, etc.  Since it is a "library" it would be good to support the whole subscription thing, etc.

Conclusion

So, that's it!  VERY simplistic MQTT publishing from a Netduino Plus to RSMB.  When I get around to setting up my temperature sensor maybe I'll make this a bit more robust and re-visit this.

I hope you enjoyed this post.