Example #1
0
        public void SyncPDU(LogicChannel channelData, ReceivedData result)
        {
            var length     = 4;
            var offset     = 0;
            var systemCode = TetraUtils.BitsToInt32(channelData.Ptr, offset, length);

            offset += length;

            result.SetValue(GlobalNames.SystemCode, systemCode);

            switch (systemCode)
            {
            case 12:
            case 13:
                length = 2;
                var pduType = TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
                offset += length;
                result.SetValue(GlobalNames.SYNC_PDU_type, pduType);

                switch (pduType)
                {
                case 0:
                    //Dmac-Sync
                    Debug.Write(" DMAC-Sync");
                    offset = Global.ParseParams(channelData, offset, _dmacSyncInfoRulesDMO, result);
                    break;

                case 1:
                    //DPRES-SYNC
                    Debug.Write(" Dpres-Sync");
                    offset = Global.ParseParams(channelData, offset, _dpresSyncInfoRules, result);
                    break;

                default:
                    //Reserved;
                    Debug.Write(" Unknow_DMO_SyncPdu_type");
                    result.SetValue(GlobalNames.UnknowData, 1);
                    break;
                }
                break;

            default:
                Global.ParseParams(channelData, offset, _syncInfoRulesTMO, result);
                break;
            }
        }
Example #2
0
        public void SyncPDUHalfSlot(LogicChannel channelData, ReceivedData result)
        {
            var pduType = -1;
            var offset  = 0;

            if (result.TryGetValue(GlobalNames.SYNC_PDU_type, ref pduType))
            {
                switch (pduType)
                {
                case 0:
                    offset = Global.ParseParams(channelData, offset, _dmacSyncInfoHalfSlotRules, result);

                    var realLength = channelData.Length - offset;

                    if (result.Value(GlobalNames.Fill_bit) != 0)
                    {
                        realLength = CalcRealLength(channelData.Ptr, offset, realLength);
                    }


                    if (result.Value(GlobalNames.Fragmentation_flag) == 1)
                    {
                        Debug.Write(" Start_fragmented_PDU");
                        CreateFraqmentsBuffer(channelData, offset, realLength, result);
                    }

                    //Debug.Write(" " + (DMAC_Message_Type)result[GlobalNames.Message_type]);
                    break;

                case 1:
                    Global.ParseParams(channelData, 0, _dpresSyncInfoHalfSlotRules, result);
                    break;

                default:
                    Debug.Write(" Unknow_DMO_SyncPdu_type");
                    result.SetValue(GlobalNames.UnknowData, 1);
                    break;
                }
            }
        }
Example #3
0
        public int SysInfoPDU(LogicChannel channelData, int offset, ReceivedData result)
        {
            var subType = TetraUtils.BitsToByte(channelData.Ptr, offset, 2);

            result.SetValue(GlobalNames.MAC_Broadcast_Type, subType);
            offset += 2;

            switch (subType)
            {
            case 1:
                //Debug.Write(" AcсessDef_PDU");
                offset = Global.ParseParams(channelData, offset, _accessDefineRules, result);
                break;

            case 0:
                //Debug.Write(" Broadcast_PDU");
                offset = Global.ParseParams(channelData, offset, _sysInfoRules, result);
                break;
            }

            return(offset);
        }
Example #4
0
        public static int ParseParams(LogicChannel channelData, int offset, Rules[] rules, ReceivedData result)
        {
            var skipRules = 0;

            for (int i = 0; i < rules.Length; i++)
            {
                if (offset >= channelData.Length)
                {
                    if (!result.Contains(GlobalNames.OutOfBuffer))
                    {
                        result.SetValue(GlobalNames.OutOfBuffer, 1);
                    }
                    return(offset);
                }

                if (skipRules > 0)
                {
                    skipRules--;
                    continue;
                }

                var param = rules[i];
                var value = TetraUtils.BitsToInt32(channelData.Ptr, offset, param.Length);

                switch (param.Type)
                {
                case RulesType.Direct:
                    if (param.GlobalName != GlobalNames.Reserved)
                    {
                        result.SetValue(param.GlobalName, value);
                    }
                    offset += param.Length;
                    continue;

                case RulesType.Options_bit:
                    offset += param.Length;
                    if (value == 0)
                    {
                        return(offset);
                    }
                    break;

                case RulesType.Presence_bit:
                    if (value == 0)
                    {
                        skipRules = param.Ext1;
                    }
                    offset += param.Length;
                    break;

                case RulesType.More_bit:
                    offset += param.Length;
                    return(offset);

                case RulesType.Switch:
                    if (result.Value((GlobalNames)rules[i].Ext1) == rules[i].Ext2)
                    {
                        if (param.GlobalName != GlobalNames.Reserved)
                        {
                            result.SetValue(param.GlobalName, value);
                        }
                        offset += param.Length;
                    }
                    break;

                case RulesType.SwitchNot:
                    if (result.Value((GlobalNames)rules[i].Ext1) != rules[i].Ext2)
                    {
                        if (param.GlobalName != GlobalNames.Reserved)
                        {
                            result.SetValue(param.GlobalName, value);
                        }
                        offset += param.Length;
                    }
                    break;

                case RulesType.Jamp:
                    if (result.Value((GlobalNames)rules[i].Ext1) == rules[i].Ext2)
                    {
                        skipRules = param.Ext3;
                    }
                    break;

                case RulesType.JampNot:
                    if (result.Value((GlobalNames)rules[i].Ext1) != rules[i].Ext2)
                    {
                        skipRules = param.Ext3;
                    }
                    break;

                case RulesType.Reserved:
                {
                    offset += param.Length;
                }
                break;
                }
            }

            return(offset);
        }