Example #1
0
        protected static void FormatPointCircuitInfo(TagShortCircuitInfo shortCircuitInfo, out List <string> pointList)//, out List<string> PointList)
        {
            pointList = new List <string>();

            for (var i = 0; i < shortCircuitInfo.u8_cpld_count; i++)
            {
                var srcBoardAddr = shortCircuitInfo.ary_cpld_state[i].u8_board_addr;

                for (var j = 0; j < CpldSingleLineCount; j++)
                {
                    var dstBoardAddr = shortCircuitInfo.ary_cpld_state[i].ary_short_circuit_info[j].u8_board_addr;
                    var dstIndex     = shortCircuitInfo.ary_cpld_state[i].ary_short_circuit_info[j].u8_index_on_board;

                    if (dstBoardAddr == 0xff || dstIndex == 0xff || srcBoardAddr > dstBoardAddr || j == dstIndex ||
                        dstBoardAddr != 0xfe || dstIndex != 0xfe)
                    {
                        continue;
                    }

                    var srcPoint = "";
                    if (j < 64)
                    {
                        srcPoint = "A" + ((srcBoardAddr - 1) * 64 + j + 1);
                    }
                    else
                    {
                        srcPoint = "B" + ((srcBoardAddr - 1) * 64 + j - 63);
                    }
                    pointList.Add(srcPoint);
                }
            }
        }
Example #2
0
        public static void SearchPointParse(byte[] resultData, out List <string> pointList)
        {
            TagCommandResult    commandResult    = null;
            TagShortCircuitInfo shortCircuitInfo = null;

            ParseCommandResult(resultData.Take(8).ToArray(), out commandResult);

            ParseShortCircuitInfo(resultData.Skip(8).ToArray(), out shortCircuitInfo);

            FormatPointCircuitInfo(shortCircuitInfo, out pointList);
        }
Example #3
0
        public static void SelfCheckParse(byte[] resultData, out List <List <string> > shortCircuitInfoResult, out int pointNo, out int circuitNo)
        {
            TagCommandResult    commandResult    = null;
            TagShortCircuitInfo shortCircuitInfo = null;

            shortCircuitInfoResult = new List <List <string> >();

            ParseCommandResult(resultData.Take(8).ToArray(), out commandResult);

            ParseShortCircuitInfo(resultData.Skip(8).ToArray(), out shortCircuitInfo);

            circuitNo = U8ToU16(shortCircuitInfo.u16_short_circuit_group_count[1], shortCircuitInfo.u16_short_circuit_group_count[0]);
            pointNo   = U8ToU16(shortCircuitInfo.u16_short_lines_count[1], shortCircuitInfo.u16_short_lines_count[0]);

            FormatShortCircuitInfo(shortCircuitInfo, out shortCircuitInfoResult);
        }
Example #4
0
        protected static void ParseShortCircuitInfo(byte[] resultData, out TagShortCircuitInfo shortCircuitInfo)
        {
            var resultDataQueue = new Queue();

            foreach (var t in resultData)
            {
                resultDataQueue.Enqueue(t);
            }

            var sciTmp = new TagShortCircuitInfo();

            sciTmp.u8_cpld_count = (byte)resultDataQueue.Dequeue();

            sciTmp.u8_reserved = new byte[3];
            for (var i = 0; i < 3; i++)
            {
                sciTmp.u8_reserved[i] = (byte)resultDataQueue.Dequeue();
            }

            sciTmp.u16_short_circuit_group_count = new byte[2];
            for (var i = 0; i < 2; i++)
            {
                sciTmp.u16_short_circuit_group_count[i] = (byte)resultDataQueue.Dequeue();
            }

            sciTmp.u16_short_lines_count = new byte[2];
            for (var i = 0; i < 2; i++)
            {
                sciTmp.u16_short_lines_count[i] = (byte)resultDataQueue.Dequeue();
            }

            sciTmp.ary_cpld_state = new TagBoardLinesState[32];

            for (var i = 0; i < sciTmp.u8_cpld_count; i++)          //using cpld board count
            {
                sciTmp.ary_cpld_state[i] = new TagBoardLinesState();
                sciTmp.ary_cpld_state[i].u8_board_addr = (byte)resultDataQueue.Dequeue();

                sciTmp.ary_cpld_state[i].u8_reserved = new byte[3];
                for (var j = 0; j < 3; j++)
                {
                    sciTmp.ary_cpld_state[i].u8_reserved[j] = (byte)resultDataQueue.Dequeue();
                }

                sciTmp.ary_cpld_state[i].ary_u8_checked_flag = new byte[CpldSingleLineCount / 8];
                for (var j = 0; j < CpldSingleLineCount / 8; j++)
                {
                    sciTmp.ary_cpld_state[i].ary_u8_checked_flag[j] = (byte)resultDataQueue.Dequeue();
                }

                sciTmp.ary_cpld_state[i].ary_short_circuit_info = new TagLineAddr[CpldSingleLineCount];
                for (var j = 0; j < CpldSingleLineCount; j++)
                {
                    sciTmp.ary_cpld_state[i].ary_short_circuit_info[j] =
                        new TagLineAddr
                    {
                        u8_board_addr     = (byte)resultDataQueue.Dequeue(),
                        u8_index_on_board = (byte)resultDataQueue.Dequeue()
                    };
                }
            }
            shortCircuitInfo = sciTmp;
        }
Example #5
0
        protected static void FormatShortCircuitInfo(TagShortCircuitInfo shortCircuitInfo, out List <List <string> > shortCircuitList)
        {
            var parsedDataList = new List <HashSet <string> >();

            for (var i = 0; i < shortCircuitInfo.u8_cpld_count; i++)
            {
                var srcBoardAddr = shortCircuitInfo.ary_cpld_state[i].u8_board_addr;

                for (var j = 0; j < CpldSingleLineCount; j++)
                {
                    var dstBoardAddr = shortCircuitInfo.ary_cpld_state[i].ary_short_circuit_info[j].u8_board_addr;
                    var dstIndex     = shortCircuitInfo.ary_cpld_state[i].ary_short_circuit_info[j].u8_index_on_board;

                    if (dstBoardAddr == 0xff || dstIndex == 0xff)
                    {
                        continue;
                    }

                    var srcPoint = "";
                    var dstPoint = "";

                    if (j < 64)
                    {
                        srcPoint = "A" + ((srcBoardAddr - 1) * 64 + j + 1);
                    }
                    else
                    {
                        srcPoint = "B" + ((srcBoardAddr - 1) * 64 + j - 63);
                    }

                    if (dstIndex < 64)
                    {
                        dstPoint = "A" + ((dstBoardAddr - 1) * 64 + dstIndex + 1);
                    }
                    else
                    {
                        dstPoint = "B" + ((dstBoardAddr - 1) * 64 + dstIndex - 63);
                    }

                    //Console.WriteLine(srcPoint + "->" + dstPoint);
                    //Console.WriteLine(srcBoardAddr + "," + j + "," + dstBoardAddr +","+ dstIndex);


                    var isNewShortCircuit = true;

                    foreach (var tmpHs in parsedDataList)
                    {
                        if (!tmpHs.Contains(dstPoint) && !tmpHs.Contains(srcPoint))
                        {
                            continue;
                        }
                        tmpHs.Add(srcPoint);
                        tmpHs.Add(dstPoint);
                        isNewShortCircuit = false;
                        break;
                    }
                    if (!isNewShortCircuit)
                    {
                        continue;
                    }
                    {
                        var tmpHs = new HashSet <string> {
                            srcPoint, dstPoint
                        };
                        parsedDataList.Add(tmpHs);
                    }
                }
            }

            var resultDataList = parsedDataList.Select(tmpHs => tmpHs.OrderBy(x => x).ToList()).ToList();

            shortCircuitList = resultDataList;
        }