dataframe.cs

来自「zwave 无线通讯协议 PC controller 控制器源码」· CS 代码 · 共 656 行 · 第 1/2 页

//////////////////////////////////////////////////////////////////////////////////////////////// 
//
//          #######
//          #   ##    ####   #####    #####  ##  ##   #####
//             ##    ##  ##  ##  ##  ##      ##  ##  ##
//            ##  #  ######  ##  ##   ####   ##  ##   ####
//           ##  ##  ##      ##  ##      ##   #####      ##
//          #######   ####   ##  ##  #####       ##  #####
//                                           #####
//          Z-Wave, the wireless language.
//
//          Copyright Zensys A/S, 2005
//
//          All Rights Reserved
//
//          Description:   
//
//          Author:   Morten Damsgaard, Linkage A/S
//
//          Last Changed By:  $Author: heh $
//          Revision:         $Revision: 1.7 $
//          Last Changed:     $Date: 2007/02/26 08:17:36 $
//
//////////////////////////////////////////////////////////////////////////////////////////////
#region Using directives

using System;
using System.Text;

#endregion

namespace Zensys.ZWave.Communication
{
    /// <summary>
    /// DataFrame
    /// </summary>
    public class DataFrame
    {
        /// <summary>
        /// If true ToString() returns DataFrame command as the defined Enum
        /// If false the numerical value is returned
        /// </summary>
        public bool ToStringShowCmdAsEnum = true;
        private const int BUFFER_SIZE = 100;
        /// <summary>
        /// DataFrame()
        /// </summary>
        public DataFrame()
        {
            this.timestamp = DateTime.Now;
            this.payloadBuffer = new byte[BUFFER_SIZE];
        }

        /// <summary>
        /// DataFrame(byte payloadSize)
        /// </summary>
        /// <param name="payloadSize"></param>
        public DataFrame(byte payloadSize)
        {
            this.timestamp = DateTime.Now;
            this.payloadBuffer = new byte[payloadSize];
        }

        /// <summary>
        /// AddPayload(byte data)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public bool AddPayload(byte data)
        {
            if (payloadIdx > payloadBuffer.Length - 1)
                return false;
            payloadBuffer[payloadIdx++] = data;
            return true;
        }

        /// <summary>
        /// AddPayload(byte[] data)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public bool AddPayload(byte[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if ((payloadIdx + data.Length) > payloadBuffer.Length-1)
                return false;
            data.CopyTo(payloadBuffer, payloadIdx);
            payloadIdx += (byte)data.Length;
            return true;
        }

        /// <summary>
        /// GetPayloadBuffer()
        /// </summary>
        /// <returns></returns>
        public byte[] GetPayloadBuffer()
        {
            return payloadBuffer;
        }

        /// <summary>
        /// Command
        /// </summary>
        public CommandType Command
        {
            set
            {
                this.cmd = value;
            }
            get
            {
                return cmd;
            }
        }

        /// <summary>
        /// Type
        /// </summary>
        public FrameType Type
        {
            set
            {
                this.type = value;
            }
            get
            {
                return type;
            }
        }

        /// <summary>
        ///  isPayloadFull()
        /// </summary>
        /// <returns></returns>
        public bool IsPayloadFull()
        {
            return payloadIdx > payloadBuffer.Length-1;
        }

        /// <summary>
        /// isChecksumValid(byte checksum)
        /// </summary>
        /// <param name="checksum"></param>
        /// <returns></returns>
        public bool IsChecksumValid(byte checksum)
        {
            return calculateChecksum() == checksum;
        }

        /// <summary>
        /// String
        /// </summary>
        /// <returns></returns>
        public override String ToString()
        {
            StringBuilder sb = new StringBuilder(100);

            // Header...
            sb.Append((byte)HeaderType.StartOfFrame);
            sb.Append(' ');

            // Length...
            sb.Append((byte)(payloadIdx+3));
            sb.Append(' ');

            // Type...
            sb.Append((byte)type);
            sb.Append(' ');

            // Command...
            if (ToStringShowCmdAsEnum)
            {
                sb.Append(cmd.ToString());
            }
            else
            {
                sb.Append((byte)cmd);
            }
            sb.Append(' ');

            // Data payload...
            for (int i = 0; i < payloadIdx; i++)
            {
                sb.Append(payloadBuffer[i]);
                sb.Append(' ');
            }

            // Checksum...
            sb.Append(calculateChecksum());

            return sb.ToString();
        }

        /// <summary>
        /// GetFrameBuffer()
        /// </summary>
        /// <returns></returns>
        public byte[] GetFrameBuffer()
        {
            byte[] buffer = new byte[payloadIdx + 5];
            buffer[IDX_HEADER]  = (byte)HeaderType.StartOfFrame;
            buffer[IDX_LENGTH]  = (byte)(payloadIdx+3);
            buffer[IDX_TYPE]    = (byte)type;
            buffer[IDX_CMD]     = (byte)cmd;
            Array.Copy(payloadBuffer, 0, buffer, IDX_DATA, payloadIdx);
            buffer[buffer.Length - 1] = calculateChecksum();
            return buffer;
        }

        private byte calculateChecksum()
        {
            byte calcChksum = 0xFF;
            calcChksum ^= (byte)(payloadIdx+3); // Length
            calcChksum ^= (byte)type;     // Type
            calcChksum ^= (byte)cmd;      // Command
            for (int i = 0; i < payloadIdx; i++)
                calcChksum ^= payloadBuffer[i];      // Data
            return calcChksum;
        }

        /// <summary>
        /// TimeStamp
        /// </summary>
        public DateTime Timestamp
        {
            get
            {
                return timestamp;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="df1"></param>
        /// <param name="df2"></param>
        /// <returns></returns>
        public static bool operator==(DataFrame df1, DataFrame df2)
        {
            if (!(df1 is DataFrame) || !(df2 is DataFrame))
                return false;
            if (df1.Type != df2.Type)
                return false;
            if (df1.Command != df2.Command)
                return false;
            if (df1.payloadIdx != df2.payloadIdx)
                return false;
            for (int i = 0; i < df1.payloadIdx; i++)
                if (df1.payloadBuffer[i] != df2.payloadBuffer[i])
                    return false;
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="df1"></param>
        /// <param name="df2"></param>
        /// <returns></returns>
        public static bool operator!=(DataFrame df1, DataFrame df2)
        {
            return !(df1 == df2);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (!(obj is DataFrame))
                return false;
            return (this == (DataFrame)obj);
        }


        /// <summary>
        /// GetHashCode()
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        private byte[] payloadBuffer;
        private byte payloadIdx;
        private DateTime timestamp;
        private FrameType type;
        private CommandType cmd;

        /// <summary>
        /// HeaderType
        /// </summary>
        public enum HeaderType
        {
            /// <summary>
            /// 
            /// </summary>
            Unknown=0x00,
            /// <summary>
            /// HEADER_SOF
            /// </summary>
            StartOfFrame=0x01,
            /// <summary>
            /// HEADER_ACK
            /// </summary>
            Acknowledge=0x06,
            /// <summary>
            /// HEADER_NAK
            /// </summary>
            NotAcknowledged=0x15,
            /// <summary>
            /// HEADER_CAN
            /// </summary>
            Can=0x18
        }

        private const int IDX_HEADER  = 0;
        private const int IDX_LENGTH  = 1;
        private const int IDX_TYPE    = 2;
        private const int IDX_CMD     = 3;
        private const int IDX_DATA    = 4;