Decode() public static method

public static Decode ( string encodedData ) : byte[]
encodedData string
return byte[]
コード例 #1
0
        public L_Message(String RAW_Message, House _theHouse, Dictionary <String, IMAXDevice> OutputDeviceList)
        {
            DevicesInThisMessage = new List <IMAXDevice>();

            if (RAW_Message.Length < 2)
            {
                throw new MAXException("Unable to process the RAW Message.");
            }

            if (!RAW_Message.StartsWith("L:"))
            {
                throw new MAXException("Unable to process the RAW Message. Not a L Message.");
            }

            RawMessageDecoded = Base64.Decode(RAW_Message.Remove(0, 2));

            // Tokenize RAW Message
            List <byte[]> Tokenized = TokenizeMessage.Tokenize(RawMessageDecoded);

            foreach (byte[] array in Tokenized)
            {
                StringBuilder sb = new StringBuilder();

                for (int i = 0; i <= 2; i++)
                {
                    sb.Append(string.Format("{0:x}", array[i]).PadLeft(2, '0'));
                }
                // get data 1 and data 2 out
                // on position 5,6
                byte Data1 = array[4];
                byte Data2 = array[5];

                String binValueData1 = Convert.ToString(Data1, 2);
                binValueData1 = binValueData1.PadLeft(8, '0');
                String binValueData2 = Convert.ToString(Data2, 2);
                binValueData2 = binValueData2.PadLeft(8, '0');

                Int32 Cursor = 7;                       // the current position, skipping ?1,

                String RFAddress = sb.ToString();

                #region look for this RF Adress in the House's device list
                List <IMAXDevice> AllDevices  = _theHouse.GetAllDevices();
                IMAXDevice        foundDevice = null;
                foreach (IMAXDevice _device in AllDevices)
                {
                    if (_device.RFAddress == RFAddress)
                    {
                        if (_device.Type == DeviceTypes.HeatingThermostat)
                        {
                            foundDevice = new HeatingThermostat();
                            foundDevice.AssociatedRoom = _device.AssociatedRoom;
                            foundDevice.Name           = _device.Name;
                            foundDevice.RFAddress      = _device.RFAddress;
                            foundDevice.SerialNumber   = _device.SerialNumber;
                        }
                        if (_device.Type == DeviceTypes.ShutterContact)
                        {
                            foundDevice = new ShutterContact();
                            foundDevice.AssociatedRoom = _device.AssociatedRoom;
                            foundDevice.Name           = _device.Name;
                            foundDevice.RFAddress      = _device.RFAddress;
                            foundDevice.SerialNumber   = _device.SerialNumber;
                        }

                        break;
                    }
                }
                #endregion

                if (foundDevice != null)
                {
                    // remove the device from the house to add it later again...
                    DevicesInThisMessage.Add(foundDevice);

                    #region HeatingThermostat
                    if (foundDevice.Type == DeviceTypes.HeatingThermostat)
                    {
                        HeatingThermostat KnownDevice = (HeatingThermostat)foundDevice;

                        #region get all those flags out of Data1 and Data2

                        #region Valid
                        if (binValueData1[3] == '1')
                        {
                            KnownDevice.Valid = true;
                        }
                        else
                        {
                            KnownDevice.Valid = false;
                        }
                        #endregion

                        #region Error
                        if (binValueData1[4] == '1')
                        {
                            KnownDevice.Error = true;
                        }
                        else
                        {
                            KnownDevice.Error = false;
                        }
                        #endregion

                        #region IsAnswer
                        if (binValueData1[5] == '1')
                        {
                            KnownDevice.IsAnswer = true;
                        }
                        else
                        {
                            KnownDevice.IsAnswer = false;
                        }
                        #endregion

                        #region LowBattery
                        if (binValueData2[0] == '1')
                        {
                            KnownDevice.LowBattery = true;
                        }
                        else
                        {
                            KnownDevice.LowBattery = false;
                        }
                        #endregion

                        #region LinkError
                        if (binValueData2[1] == '1')
                        {
                            KnownDevice.LinkError = true;
                        }
                        else
                        {
                            KnownDevice.LinkError = false;
                        }
                        #endregion

                        #region PanelLock
                        if (binValueData2[2] == '1')
                        {
                            KnownDevice.PanelLock = true;
                        }
                        else
                        {
                            KnownDevice.PanelLock = false;
                        }
                        #endregion

                        #region GatewayOK
                        if (binValueData2[3] == '1')
                        {
                            KnownDevice.GatewayOK = true;
                        }
                        else
                        {
                            KnownDevice.GatewayOK = false;
                        }
                        #endregion

                        #region Mode
                        String ModeValue = binValueData2[6] + "" + binValueData2[7];

                        switch (ModeValue)
                        {
                        case "00":
                            KnownDevice.Mode = ThermostatModes.automatic;
                            break;

                        case "01":
                            KnownDevice.Mode = ThermostatModes.manual;
                            break;

                        case "10":
                            KnownDevice.Mode = ThermostatModes.vacation;
                            break;

                        case "11":
                            KnownDevice.Mode = ThermostatModes.boost;
                            break;

                        default:
                            break;
                        }
                        #endregion

                        #endregion

                        // hurray, we've got a device we know how to handle B-)
                        ((HeatingThermostat)foundDevice).Temperature = (double)array[Cursor] / 2;
                        Cursor++;

                        OutputDeviceList.Add(KnownDevice.SerialNumber, KnownDevice);
                    }
                    #endregion

                    #region ShutterContact
                    if (foundDevice.Type == DeviceTypes.ShutterContact)
                    {
                        ShutterContact KnownDevice = (ShutterContact)foundDevice;

                        #region get all those flags out of Data1 and Data2

                        #region Valid
                        if (binValueData1[3] == '1')
                        {
                            KnownDevice.Valid = true;
                        }
                        else
                        {
                            KnownDevice.Valid = false;
                        }
                        #endregion

                        #region Error
                        if (binValueData1[4] == '1')
                        {
                            KnownDevice.Error = true;
                        }
                        else
                        {
                            KnownDevice.Error = false;
                        }
                        #endregion

                        #region IsAnswer
                        if (binValueData1[5] == '1')
                        {
                            KnownDevice.IsAnswer = true;
                        }
                        else
                        {
                            KnownDevice.IsAnswer = false;
                        }
                        #endregion

                        #region LowBattery
                        if (binValueData2[0] == '1')
                        {
                            KnownDevice.LowBattery = true;
                        }
                        else
                        {
                            KnownDevice.LowBattery = false;
                        }
                        #endregion

                        #region LinkError
                        if (binValueData2[1] == '1')
                        {
                            KnownDevice.LinkError = true;
                        }
                        else
                        {
                            KnownDevice.LinkError = false;
                        }
                        #endregion

                        #region PanelLock
                        if (binValueData2[2] == '1')
                        {
                            KnownDevice.PanelLock = true;
                        }
                        else
                        {
                            KnownDevice.PanelLock = false;
                        }
                        #endregion

                        #region GatewayOK
                        if (binValueData2[3] == '1')
                        {
                            KnownDevice.GatewayOK = true;
                        }
                        else
                        {
                            KnownDevice.GatewayOK = false;
                        }
                        #endregion

                        #region Mode
                        String ModeValue = binValueData2[6] + "" + binValueData2[7];

                        switch (ModeValue)
                        {
                        case "00":
                            KnownDevice.ShutterState = ShutterContactModes.closed;
                            break;

                        case "10":
                            KnownDevice.ShutterState = ShutterContactModes.open;
                            break;

                        default:
                            break;
                        }
                        #endregion

                        #endregion

                        OutputDeviceList.Add(KnownDevice.SerialNumber, KnownDevice);
                    }
                    #endregion
                }
            }
        }
コード例 #2
0
        // initializes this class and processes the given Input Message and fills the Message Fields
        public M_Message(String RAW_Message, House _House)
        {
            thisHouse = _House;
            if (RAW_Message.Length < 2)
            {
                throw new MAXException("Unable to process the RAW Message.");
            }

            if (!RAW_Message.StartsWith("M:"))
            {
                throw new MAXException("Unable to process the RAW Message. Not a M Message.");
            }

            String[] SplittedRAWMessage = RAW_Message.Remove(0, 2).Split(new char[1] {
                ','
            });

            if (SplittedRAWMessage.Length >= 3)
            {
                Index             = Int32.Parse(SplittedRAWMessage[0], System.Globalization.NumberStyles.HexNumber);
                Count             = Int32.Parse(SplittedRAWMessage[1], System.Globalization.NumberStyles.HexNumber);
                RawMessageDecoded = Base64.Decode(SplittedRAWMessage[2]);

//				System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
//				Console.WriteLine(enc.GetString (RawMessageDecoded));
//				StringBuilder hexlist = new StringBuilder();
//
//				foreach(Byte _byte in RawMessageDecoded)
//				{
//					hexlist.Append(_byte.ToString()+" ");
//				}

                Int32 Cursor = 2;

                // now go deeper
                Byte RoomCount = RawMessageDecoded[Cursor];
                Cursor++;

                #region Rooms
                // go through every room
                for (byte roomnumber = 1; roomnumber <= RoomCount; roomnumber++)
                {
                    Room newRoom = new Room(thisHouse);

                    newRoom.RoomID = RawMessageDecoded[Cursor];
                    Cursor++;

                    Byte RoomNameLength = RawMessageDecoded[Cursor];
                    Cursor++;

                    byte[] RoomName = new byte[RoomNameLength];

                    for (Byte j = 0; j <= RoomNameLength - 1; j++)
                    {
                        //RoomName.Append((char)RawMessageDecoded[Cursor]);
                        RoomName[j] = RawMessageDecoded[Cursor];
                        Cursor++;
                    }
                    newRoom.RoomName = System.Text.Encoding.UTF8.GetString(RoomName);

                    StringBuilder RFAddress_Buffer = new StringBuilder();
                    for (Byte j = 0; j <= 3 - 1; j++)
                    {
                        RFAddress_Buffer.Append(RawMessageDecoded[Cursor]);
                        Cursor++;
                    }
                    newRoom.RFAddress = RFAddress_Buffer.ToString();                    //Int32.Parse(RFAddress_Buffer.ToString(),System.Globalization.NumberStyles.HexNumber);

                    _House.Rooms.Add(newRoom);
                }

                #region Devices
                //newRoom.RFAddress = Int32.Parse(RFAddress.ToString(),System.Globalization.NumberStyles.HexNumber);
                Byte DeviceCount = RawMessageDecoded[Cursor];
                Cursor++;
                // go through all the devices in here
                for (byte devicenumber = 1; devicenumber <= DeviceCount; devicenumber++)
                {
                    // read in the device
                    IMAXDevice newDevice = new UnknownDevice();

                    #region Determine DeviceType
                    Byte DevType = RawMessageDecoded[Cursor];
                    Cursor++;

                    switch (DevType)
                    {
                    case 1:
                        newDevice = new HeatingThermostat();
                        break;

                    case 2:
                        newDevice = new HeatingThermostatPlus();
                        break;

                    case 3:
                        newDevice = new WallMountedThermostat();
                        break;

                    case 4:
                        newDevice = new ShutterContact();
                        break;

                    case 5:
                        newDevice = new PushButton();
                        break;

                    default:
                        break;
                    }
                    #endregion

                    StringBuilder DeviceRFAddress = new StringBuilder();
                    for (Byte j = 0; j <= 3 - 1; j++)
                    {
                        DeviceRFAddress.Append(string.Format("{0:x}", RawMessageDecoded[Cursor]).PadLeft(2, '0'));
                        //DeviceRFAddress.Append(RawMessageDecoded[Cursor]);
                        Cursor++;
                    }
                    newDevice.RFAddress = DeviceRFAddress.ToString();                    //Int32.Parse(DeviceRFAddress.ToString(),System.Globalization.NumberStyles.HexNumber);

                    StringBuilder DeviceSerialNumber = new StringBuilder();
                    for (Byte j = 0; j <= 10 - 1; j++)
                    {
                        DeviceSerialNumber.Append((char)RawMessageDecoded[Cursor]);
                        Cursor++;
                    }
                    newDevice.SerialNumber = DeviceSerialNumber.ToString();

                    Byte DeviceNameLength = RawMessageDecoded[Cursor];
                    Cursor++;

                    byte[] DeviceName = new byte[DeviceNameLength];

                    for (Byte j = 0; j <= DeviceNameLength - 1; j++)
                    {
                        DeviceName[j] = RawMessageDecoded[Cursor];
                        Cursor++;
                    }
                    newDevice.Name = System.Text.Encoding.UTF8.GetString(DeviceName);

                    Byte RoomID = RawMessageDecoded[Cursor];
                    Cursor++;

                    // add the device to the room
                    foreach (Room newRoom in _House.Rooms)
                    {
                        if (newRoom.RoomID == RoomID)
                        {
                            newDevice.AssociatedRoom = newRoom;
                            newRoom.Devices.Add(newDevice.SerialNumber, newDevice);
                            break;
                        }
                    }
                }
                #endregion
                // add this Room to the M_Message-Structure
                #endregion
            }
            else
            {
                throw new MAXException("Unable to process M Message. Not enough content.");
            }
        }