NETMF Zigbee Source File


using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using GHIElectronics.NETMF.FEZ;
using GHIElectronics.NETMF.Hardware;
using System.IO.Ports;
using System.Text;


namespace NETMF_Zigbee
{
    /// <summary>
    /// Simple Zigbee communication
    /// </summary>
    public class Program
    {
        // Xbee serial port connection
        public static SerialPort xbee;


        /// <summary>
        /// Main method of the program
        /// </summary>
        public static void Main()
        {
            // Initialize the network: we use a zigbee connection
            InitializeXbee();

            // The button
            InputPort button = new InputPort((Cpu.Pin)FEZ_Pin.Digital.Di7, true, Port.ResistorMode.PullUp);

            // Configure pin 12 as output ot control the LED
            OutputPort led = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di13, true);

            // Incoming data from xbee
            string receivedData;

            // The current status of the button
            bool statusButton = false;





            // Main processing loop
            while (true)
            {
                // Sleep for 500 milliseconds
                Thread.Sleep(50);

                // Read the status of the button
                bool status = !button.Read();


                // If button pressed or released, send name and button status to desktop computer
                if (statusButton != status)
                {
                    statusButton = status;
                    SendXbeeMessage("Nic: " + statusButton);
                }



                // Check if there is incoming message from xbee
                if (xbee.BytesToRead > 0)
                {
                    receivedData = ReadTo("\n");

                    if (receivedData == "on")
                    {
                        Debug.Print("Command on");

                        // Set the led status
                        led.Write(true);
                    }
                    else if (receivedData == "off")
                    {
                        Debug.Print("Command off");

                        // Set the led status
                        led.Write(false);
                    }
                }
            }
        }



        /// <summary>
        /// Initialize the zigbee communication
        /// </summary>
        public static void InitializeXbee()
        {
            // Open a COM port for the Zigbee connection
            xbee = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            xbee.Handshake = Handshake.None;
            xbee.Open();
        }



        /// <summary>
        /// Send a message through xbee
        /// </summary>
        /// <param name="message"></param>
        public static void SendXbeeMessage(string message)
        {
            // Convert message to bytes
            byte[] messageInBytes = Encoding.UTF8.GetBytes(message + "\n");

            // Send message
            xbee.Write(messageInBytes, 0, messageInBytes.Length);
        }






        // --------------------------------------------------------------------
        // Xbee serial port reading
        // Read incoming message until terminal character
        // --------------------------------------------------------------------

        public static string textArrived;
        public static byte[] byteValue;
        public static int byteValueLen;
        public static byte[] buffer;
        public static bool flag;
        public static int bytesRead;
        public static int bufferIndex;
        public static char[] charData;


        /// <summary>
        /// Reads a string up to the specified value in the input buffer.
        /// </summary>
        /// <param name="value">A value that indicates where the read operation stops.</param>
        /// <returns>The contents of the input buffer up to the specified value.</returns>
        public static string ReadTo(string value)
        {
            textArrived = string.Empty;

            // Arguments check
            if (value == null)
                throw new ArgumentNullException();

            if (value.Length == 0)
                throw new ArgumentException();

            // This is for speed performance
            byteValue = Encoding.UTF8.GetBytes(value);
            byteValueLen = byteValue.Length;

            flag = false;
            // +1 because of two byte characters
            buffer = new byte[byteValueLen + 1];

            // Read until pattern or timeout
            do
            {
                bufferIndex = 0;
                Array.Clear(buffer, 0, buffer.Length);

                // Read data until the buffer size is less then pattern.Length
                // or last char in pattern is received
                do
                {
                    bytesRead = xbee.Read(buffer, bufferIndex, 1);
                    bufferIndex += bytesRead;

                    // if nothing was read (timeout), we will return null
                    if (bytesRead <= 0)
                    {
                        return null;
                    }

                }
                while ((bufferIndex < byteValueLen + 1)
                        && (buffer[bufferIndex - 1] != byteValue[byteValueLen - 1]));

                // Decode received bytes into chars and then into string
                charData = Encoding.UTF8.GetChars(buffer);

                for (int i = 0; i < charData.Length; i++)
                    textArrived += charData[i];


                flag = true;

                // This is important. Bytes received can be zero-length string.
                // For example 0x00, 0x65, 0x66, 0x67, 0x0A will be decoded as empty string.
                if (textArrived.Length > 0)
                {
                    // check whether the end pattern is at the end
                    for (int i = 1; i <= value.Length; i++)
                    {
                        if (value[value.Length - i] != textArrived[textArrived.Length - i])
                        {
                            flag = false;
                            break;
                        }
                    }
                }

            } while (!flag);

            if (textArrived.Length >= value.Length)
                textArrived = textArrived.Substring(0, textArrived.Length - value.Length);

            return textArrived.Trim();
        }   

    }
}