Beispiel #1
0
        public static dynamic DecodeMessage(MessageTypeEnum msgType, byte[] msgBytes)
        {
            switch (msgType)
            {
            case MessageTypeEnum.VarList:
                return(VarTypeListModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.StatusError:
                return(ErrorStatusModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.StatusOk:
                return(OkStatusModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.StatusRequest:
                return(StatusRequestModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.MonitorStart:
                return(MonitorStartModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.MonitorStop:
                return(MonitorStopModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.VarListRequest:
                return(VarListRequestModel.DecodeByteArray(msgBytes));

            case MessageTypeEnum.VarValues:
                return(msgBytes);

            case MessageTypeEnum.BTInput:
                return(BTInputModel.DecodeByteArray(msgBytes));

            default:
                return(null);
            }
        }
Beispiel #2
0
        internal static object[] GetVarValuesFromBytes(VarTypeListModel varTypeList, byte[] msgBytes)
        {
            // output model
            List <object> ObjList = new List <object>();

            // loop through var types, parse shit
            int offset = 0;

            foreach (VarTypeModel VarType in varTypeList.VarTypes)
            {
                byte[] b;
                switch (VarType.VarType)
                {
                case VarTypeEnum.uint8:
                    ObjList.Add(msgBytes[offset]);
                    offset += 1;
                    break;

                case VarTypeEnum.uint16:
                    b       = ByteArrayHandler.GetBytesFromArray(msgBytes, offset, 2, false);
                    offset += b.Length;
                    ObjList.Add(BitConverter.ToUInt16(b, 0));
                    break;

                case VarTypeEnum.uint32:
                    b       = ByteArrayHandler.GetBytesFromArray(msgBytes, offset, 4, false);
                    offset += b.Length;
                    ObjList.Add(BitConverter.ToUInt32(b, 0));
                    break;

                case VarTypeEnum.int8:
                    ObjList.Add((sbyte)msgBytes[offset]);
                    offset += 1;
                    break;

                case VarTypeEnum.int16:
                    b = ByteArrayHandler.GetBytesFromArray(msgBytes, offset, 2, false);
                    ObjList.Add(BitConverter.ToInt16(b, 0));
                    offset += b.Length;
                    break;

                case VarTypeEnum.int32:
                    b = ByteArrayHandler.GetBytesFromArray(msgBytes, offset, 4, false);
                    ObjList.Add(BitConverter.ToInt32(b, 0));
                    offset += b.Length;
                    break;
                }
            }
            return(ObjList.ToArray());
        }
        public static VarTypeListModel GetVarTypes()
        {
            VarTypeListModel VarTypesList = new VarTypeListModel();

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "DummyVar1",
                VarType = VarTypeEnum.int16
            });

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "AnotherVar",
                VarType = VarTypeEnum.int32
            });

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "DummyVar2",
                VarType = VarTypeEnum.int8
            });

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "AnotherVar3",
                VarType = VarTypeEnum.uint16
            });

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "DummyVar4",
                VarType = VarTypeEnum.uint32
            });

            VarTypesList.VarTypes.Add(new VarTypeModel
            {
                Name    = "AnotherVar5",
                VarType = VarTypeEnum.uint8
            });

            return(VarTypesList);
        }
        public override void HandleIncomingMessageModel(MessageTypeEnum msgType, dynamic messageModel)
        {
            switch (msgType)
            {
            case MessageTypeEnum.StatusOk:
                Callback.AppendLog("Controller status: " + msgType.ToString());
                Callback.SetStatus(msgType.ToString());
                break;

            case MessageTypeEnum.StatusError:
                Callback.AppendLog("Controller ERROR status: " + ((ErrorStatusModel)messageModel).Text);
                Callback.SetStatus(msgType.ToString());
                break;

            case MessageTypeEnum.VarList:
                VarTypeListModel M = (VarTypeListModel)messageModel;
                System.Windows.Application.Current.Dispatcher.Invoke(new Action(() => {
                    // clear lists and tables
                    VarTypeList.VarTypes.Clear();
                    Callback.ClearColumns();
                    VarData.Rows.Clear();

                    foreach (VarTypeModel Model in messageModel.VarTypes)
                    {
                        // update var type list
                        VarTypeList.VarTypes.Add(Model);
                        // update vars table
                        Callback.AddColumn(Model.Name);
                    }
                }));
                Callback.AppendLog("Variable list received.");

                // log colnames
                string s = "";
                foreach (VarTypeModel Model in messageModel.VarTypes)
                {
                    s += Model.Name + " (" + Model.VarType + ");";
                }
                log.Info(s);
                break;

            case MessageTypeEnum.VarValues:
                try
                {
                    // decode bytes here:
                    Callback.AddRow(ModelDecoder.GetVarValuesFromBytes(VarTypeList, messageModel));
                }
                catch (Exception ex)
                {
                    Callback.AppendLog(ex.Message);
                }
                break;

            case MessageTypeEnum.StatusRequest:
                SendStatus();
                break;

            default:
                Callback.AppendLog("Incoming unknown message: " + msgType.ToString());
                break;
            }
        }