Пример #1
0
        /// <summary>
        /// 设置相位方向 表
        /// </summary>
        /// <param name="lptd"></param>
        /// <returns></returns>
        public static Message SetPhaseToDirec(List<PhaseToDirec> lptd)
        {
            TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
            Message msg = new Message();
            //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
            byte[] hex = new byte[Define.PHASE_DIREC_BYTE_SIZE * Define.PHASE_DIREC_RESULT_LEN + Define.SET_PHASE_DIREC_RESPONSE.Length+1];
            Stream s = new MemoryStream();
            s.Write(Define.SET_PHASE_DIREC_RESPONSE, 0, Define.SET_PHASE_DIREC_RESPONSE.Length);
            s.WriteByte(Convert.ToByte(Define.PHASE_DIREC_RESULT_LEN));
            foreach (PhaseToDirec ptd in lptd)
            {
                byte id = ptd.ucId;
                s.WriteByte(id);
                byte phase = ptd.ucPhase;
                s.WriteByte(phase);
                byte op = ptd.ucOverlapPhase;
                s.WriteByte(op);
                byte rc = ptd.ucRoadCnt;
                s.WriteByte(rc);
            }
            s.Position = 0;
            int count = s.Read(hex, 0, hex.Length);
            if (count > 0)
            {
                bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
                if (b)
                {
                    msg.flag = true;
                    msg.msg = "设置方向属性成功!";
                    msg.obj = "PhaseToDirec";
                }
                else
                {
                    msg.flag = false;
                    msg.msg = "设置方向属性失败!";
                    msg.obj = "PhaseToDirec";
                }
            }

            return msg;
        }
Пример #2
0
        /// <summary>
        /// 检测器第二块板 9- 16通道设置方法
        /// </summary>
        /// <param name="se"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public static Message SetSensitivityAdv22(byte[] se, Node n)
        {
            Message m = new Message();

            byte[] hex = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            Stream s = new MemoryStream();
            bool b = false;
            s.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            s.WriteByte(se[0]);
            s.WriteByte(se[1]);
            s.WriteByte(se[2]);
            s.WriteByte(se[3]);
            s.Position = 0;
            int count = s.Read(hex, 0, hex.Length);
            if (count > 0)
            {
                hex[3] = 0x0c;
                hex[4] = 0x01;
                b = Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
            }
            if (b == true)
            {
                m.flag = true;
                m.msg = "检测器1板1-8通道灵敏度设置成功";
                m.obj = "Detecotr";
            }
            else
            {
                m.flag = false;
                m.msg = "检测器1板1-8通道灵敏度设置失败";
                m.obj = "Detecotr";
            }
            return m;
        }
Пример #3
0
        /// <summary>
        /// 设置检测器灵敏 度
        /// </summary>
        /// <param name="borad"></param>
        /// <param name="se"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public static Message SetSensitivityAdv(byte[] se, Node n)
        {
            Message m = new Message();

            byte[] hex11 = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            byte[] hex12 = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            byte[] hex21 = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            byte[] hex22 = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            Stream s11 = new MemoryStream();
            s11.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            

            s11.WriteByte(se[0]);
            s11.WriteByte(se[1]);
            s11.WriteByte(se[2]);
            s11.WriteByte(se[3]);
            s11.Position = 0;
            int count11 = s11.Read(hex11, 0, hex11.Length);
            if (count11 > 0)
            {
                    hex11[3] = 0x0b;
                    hex11[4] = 0x00;
                    Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex11);
            }
            Stream s12 = new MemoryStream();
            s12.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            s12.WriteByte(se[4]);
            s12.WriteByte(se[5]);
            s12.WriteByte(se[6]);
            s12.WriteByte(se[7]);
            s12.Position = 0;

            int count12 = s12.Read(hex12, 0, hex12.Length);
            if(count12>0)
            {
                hex12[3] = 0x0c;
                hex12[4] = 0x00;
                Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex12);
            }

            Stream s21 = new MemoryStream();
            s21.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            s21.WriteByte(se[8]);
            s21.WriteByte(se[9]);
            s21.WriteByte(se[10]);
            s21.WriteByte(se[11]);
            s21.Position = 0;

            int count21 = s21.Read(hex21, 0, hex21.Length);
            if (count21 > 0)
            {
                hex21[3] = 0x0b;
                hex21[4] = 0x01;
                Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex21);
            }

            Stream s22 = new MemoryStream();
            s22.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            s22.WriteByte(se[12]);
            s22.WriteByte(se[13]);
            s22.WriteByte(se[14]);
            s22.WriteByte(se[15]);
            s22.Position = 0;

            int count22 = s22.Read(hex22, 0, hex22.Length);
            if (count22 > 0)
            {
                hex22[3] = 0x0c;
                hex22[4] = 0x01;
                Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex22);
            }
            return m;
        }
Пример #4
0
 /// <summary>
 /// 检测器灵敏度数值第二块板15-16通道
 /// </summary>
 /// <param name="b"></param>
 /// <param name="n"></param>
 /// <returns></returns>
 public static Message SetSensityvityDig6(byte[] b, Node n)
 {
     Message m = new Message();
     byte[] hex = new byte[Define.SET_DETECTOR_SENSITYVITY_DIG_2_15_16.Length + 7];
     Stream s = new MemoryStream();
     s.Write(Define.SET_DETECTOR_SENSITYVITY_DIG_2_15_16, 0, Define.SET_DETECTOR_SENSITYVITY_DIG_2_15_16.Length);
     s.Write(b, 0, b.Length);
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     bool bl = false;
     if (count > 0)
     {
         bl = Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
     }
     if (bl == true)
     {
         m.obj = "Detector";
         m.flag = true;
         m.msg = "检测器数值保存成功";
     }
     else
     {
         m.obj = "Detector";
         m.flag = false;
         m.msg = "检测器数值保存失败";
     }
     return m;
 }
Пример #5
0
        /// <summary>
        /// 设置检测器灵敏 度
        /// </summary>
        /// <param name="borad"></param>
        /// <param name="se"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public static Message SetSensitivity(int borad, byte se,Node n)
        {
            Message m = new Message();

            byte[] hex = new byte[Define.DETECTOR_SENSITIVITY.Length + 4];
            Stream s = new MemoryStream();
            s.Write(Define.DETECTOR_SENSITIVITY, 0, Define.DETECTOR_SENSITIVITY.Length);
            byte sen = se;
            sen = (byte)(sen | se << 4);

            s.WriteByte(sen);
            s.WriteByte(sen);
            s.WriteByte(sen);
            s.WriteByte(sen);
            s.Position = 0;
            int count = s.Read(hex, 0, hex.Length);
            if(count > 0)
            {
                if (borad == 1)
                {
                    hex[3] = 0x0b;
                    hex[4] = 0x00;
                    Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
                    hex[3] = 0x0c;
                    hex[4] = 0x00;
                    Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
                }
                if (borad == 2)
                {
                    hex[3] = 0x0b;
                    hex[4] = 0x01;
                    Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
                    hex[3] = 0x0c;
                    hex[4] = 0x01;
                    Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
                    // Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
                }
            }
            
            return m;
        }
Пример #6
0
 public static Message SetTiming(DateTime dt)
 {
     Message m = new Message();
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     double idt = Utils.Utils.ConvertDateTimeInt(dt);
     DateTime dttt = Utils.Utils.ConvertIntDateTime(idt);
     byte[] ba = System.BitConverter.GetBytes(idt);
     byte[] bb = ba.Reverse().ToArray<byte>();
     byte[] hex = new byte[Define.TSC_DEV_TIMING.Length + 4];
     Stream s = new MemoryStream();
     s.Write(Define.TSC_DEV_TIMING, 0, Define.TSC_DEV_TIMING.Length);
     s.Write(bb, 0, bb.Length);
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     bool b = false;
     if(count >0)
     {
        b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
     }
    if(b == true)
    {
        m.flag = true;
        m.msg = "校时成功!";
        m.obj = "Timing";
    }
    else
    {
        m.flag = true;
        m.msg = "校时失败!";
        m.obj = "Timing";
    }
     return m;
 }
Пример #7
0
 /// <summary>
 /// 设置震荡频率
 /// </summary>
 /// <param name="sf"></param>
 /// <param name="n"></param>
 /// <returns></returns>
 public static Message SetOscillatorFrequency(byte sf ,Node n)
 {
     Message m = new Message();
     byte[] hex = new byte[Define.DETECTOR_OSCILLATOR_FREQUENCY.Length + 4];
     Stream s = new MemoryStream();
     s.Write(Define.DETECTOR_OSCILLATOR_FREQUENCY, 0, Define.DETECTOR_OSCILLATOR_FREQUENCY.Length);
     byte sfc = sf;
     sfc = (byte)(sf | sfc << 2);
     sfc = (byte)(sf | sfc << 2);
     sfc = (byte)(sf | sfc << 2);
     s.WriteByte(sfc);
     s.WriteByte(sfc);
     s.WriteByte(sfc);
     s.WriteByte(sfc);
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if(count>0)
     {
         
             Udp.sendUdpNoReciveData(n.sIpAddress, n.iPort, hex);
       
     }
     return m;
 }
Пример #8
0
 public static Message SetStagePattern16(List<StagePattern> lsp)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message m = new Message();
     ////字节 长度,需要加2 ,因为。数据长度需要2个字段表示,二维数组。
     byte[] hex = new byte[Define.STAGE_PATTERN_BYTE_SIZE_16 * (Define.STAGEPATTERN_RESULT_LEN * Define.STAGE_RESULT_LEN) + Define.SET_STAGEPATTERN_RESPONSE.Length + 2];
     Stream s = new MemoryStream();
     s.Write(Define.SET_STAGEPATTERN_RESPONSE, 0, Define.SET_STAGEPATTERN_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(Define.STAGEPATTERN_RESULT_LEN));
     s.WriteByte(Convert.ToByte(Define.STAGE_RESULT_LEN));
     foreach (StagePattern sp in lsp)
     {
         byte id = sp.ucStagePatternId;
         s.WriteByte(id);
         byte stageno = sp.ucStageNo;
         s.WriteByte(stageno);
         byte[] ap = System.BitConverter.GetBytes(sp.usAllowPhase);
         ap = ap.Reverse().ToArray();
         s.Write(ap, 0, ap.Length);
         byte green = sp.ucGreenTime;
         s.WriteByte(green);
         byte yellow = sp.ucYellowTime;
         s.WriteByte(yellow);
         byte red = sp.ucRedTime;
         s.WriteByte(red);
         byte opt = sp.ucOption;
         s.WriteByte(opt);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存阶段配时方案数据成功!";
             m.obj = "Pattern";
         }
         else
         {
             m.flag = false;
             m.msg = "保存阶段配时方案数据失败!";
             m.obj = "Pattern";
         }
     }
     return m;
 }
Пример #9
0
 /// <summary>
 /// 设置跟随相位
 /// </summary>
 /// <param name="lop"></param>
 /// <returns></returns>
 public static Message SetOverlapPhase(List<OverlapPhase> lop)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message m = new Message();
     //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
     byte[] hex = new byte[Define.OVERLAPPHASE_BYTE_SIZE * Define.OVERLAPPHASE_RESULT_LEN + Define.SET_OVERLAPPHASE_RESPONSE.Length+ 1];
     Stream s = new MemoryStream();
     s.Write(Define.SET_OVERLAPPHASE_RESPONSE, 0, Define.SET_OVERLAPPHASE_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(lop.Count));
     foreach (OverlapPhase op in lop)
     {
         byte id = op.ucId;
         s.WriteByte(id);
         byte ot = op.ucOperateType;
         s.WriteByte(ot);
        
         byte ipl = op.ucIncludePhaseLen;
         s.WriteByte(ipl);
         byte[] ip = op.ucIncludePhase;
         s.Write(ip, 0, ip.Length);
         byte cpl = op.ucCorrectPhaseLen;
         s.WriteByte(cpl);
         byte[] cp = op.ucCorrectPhase;
         s.Write(cp, 0, cp.Length);
         byte green = op.ucTailGreen;
         s.WriteByte(green);
         byte yellow = op.ucTailYellow;
         s.WriteByte(yellow);
         byte red = op.ucTailRed;
         s.WriteByte(red);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存跟随相位数据成功!";
             m.obj = "Pattern";
         }
         else
         {
             m.flag = false;
             m.msg = "保存跟随相位数据失败!";
             m.obj = "Pattern";
         }
     }
     return m;
 }
Пример #10
0
 public static Message SetChannel(List<Channel> lc)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message m = new Message();
     //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
     byte[] hex = new byte[Define.CHANNEL_BYTE_SIZE*Define.CHANNEL_RESULT_LEN+Define.SET_CHANNEL_RESPONSE.Length + 1];
     Stream s = new MemoryStream();
     s.Write(Define.SET_CHANNEL_RESPONSE, 0, Define.SET_CHANNEL_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(Define.CHANNEL_RESULT_LEN));
     foreach (Channel c in lc)
     {
         byte id = c.ucId;
         s.WriteByte(id);
         byte sp = c.ucSourcePhase;
         s.WriteByte(sp);
         byte af = c.ucFlashAuto;
         s.WriteByte(af);
         byte type = c.ucType;
         s.WriteByte(type);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存通道数据成功!";
             m.obj = "Channel";
         }
         else
         {
             m.flag = false;
             m.msg = "保存通道数据失败!";
             m.obj = "Channel";
         }
     }
     
     return m;
 }
Пример #11
0
 public static Message SetPattern(List<Pattern> lp)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message m = new Message();
     //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
     byte[] hex = new byte[Define.PATTERN_BYTE_SIZE * lp.Count + Define.SET_PATTERN_RESPONSE.Length + 1 ];
     Stream s = new MemoryStream();
     s.Write(Define.SET_PATTERN_RESPONSE, 0, Define.SET_PATTERN_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(lp.Count));
     foreach(Pattern p in lp)
     {
         byte id = p.ucPatternId;
         s.WriteByte(id);
         byte cyc = p.ucCycleTime;
         s.WriteByte(cyc);
         byte r = p.ucOffset;
         s.WriteByte(r);
         byte coor = p.ucCoorPhase;
         s.WriteByte(coor);
         byte stageid = p.ucStagePatternId;
         s.WriteByte(stageid);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存配时方案数据成功!";
             m.obj = "Pattern";
         }
         else
         {
             m.flag = false;
             m.msg = "保存配时方案数据失败!";
             m.obj = "Pattern";
         }
     }
     return m;
 }
Пример #12
0
 public static Message SetSchedule(List<Schedule> ls)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message m = new Message();
     //字节 长度,需要加2 ,因为。数据长度需要2个字段表示。
     byte[] hex = new byte[Define.SCHEDULE_BYTE_SIZE * (Define.SCHEDULE_RESULT_LEN*Define.SCHEDULE_EVENT_RESULT_LEN) + Define.SET_SCHEDULE_RESPONSE.Length + 2];
     Stream s = new MemoryStream();
     s.Write(Define.SET_SCHEDULE_RESPONSE, 0, Define.SET_SCHEDULE_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(Define.SCHEDULE_RESULT_LEN));
     s.WriteByte(Convert.ToByte(Define.SCHEDULE_EVENT_RESULT_LEN));
     foreach (Schedule sc in ls)
     {
         byte id = sc.ucId;
         s.WriteByte(id);
         byte eventid = sc.ucEventId;
         s.WriteByte(eventid);
         byte hour = sc.ucHour;
         s.WriteByte(hour);
         byte min = sc.ucMin;
         s.WriteByte(min);
         byte ctrl = sc.ucCtrl;
         s.WriteByte(ctrl);
         byte patterntime = sc.ucTimePatternId;
         s.WriteByte(patterntime);
         byte opt = sc.ucAuxOut;
         s.WriteByte(opt);
         byte sp = sc.ucSpecialOut;
         s.WriteByte(sp);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存时段数据成功!";
             m.obj = "Schedule";
         }
         else
         {
             m.flag = false;
             m.msg = "保存时段数据失败!";
             m.obj = "Schedule";
         }
     }
     
     return m;
 }
Пример #13
0
 public static Message SetPlanByCalendar(List<Plan> lp)
  {
      Message m = new Message();
      TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
      byte[] hex = new byte[Define.PLAN_BYTE_SIZE * lp.Count + Define.SET_PLAN_RESPONSE.Length + 1];
      Stream s = new MemoryStream();
      s.Write(Define.SET_PLAN_RESPONSE, 0, Define.SET_PLAN_RESPONSE.Length);
      s.WriteByte(Convert.ToByte(lp.Count));
     foreach (Plan p in lp)
     {
         byte id = p.ucId;
         s.WriteByte(id);
         byte[] month = System.BitConverter.GetBytes(p.usMonthFlag);
         month = month.Reverse().ToArray();
         s.Write(month, 0, month.Length);
         byte week = p.ucWeekFlag;
         s.WriteByte(week);
         byte[] day = System.BitConverter.GetBytes(p.ulDayFlag);
         day = day.Reverse().ToArray();
         s.Write(day, 0, day.Length);
         byte schedule = p.ucScheduleId;
         s.WriteByte(schedule);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             m.flag = true;
             m.msg = "保存时基数据成功!";
             m.obj = "Plan";
         }
         else
         {
             m.flag = false;
             m.msg = "保存时基数据失败!";
             m.obj = "Plan";
         }
     }
      return m;
  }
Пример #14
0
 public static Message SetDetector(List<Detector> ld)
 {
     Message msg = new Message();
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
     byte[] hex = new byte[Define.DETECTOR_BYTE_SIZE*Define.DETECTOR_RESULT_LEN + Define.SET_DETECTOR_RESPONSE.Length +1];
     Stream s = new MemoryStream();
     s.Write(Define.SET_DETECTOR_RESPONSE,0,Define.SET_DETECTOR_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(ld.Count));
     foreach (Detector d in ld)
     {
         byte id = d.ucDetectorId;
         s.WriteByte(id);
         byte phaseid = d.ucPhaseId;
         s.WriteByte(phaseid);
         byte type = d.ucDetFlag;
         s.WriteByte(type);
         byte dirc = d.ucDirect;
         s.WriteByte(dirc);
         byte time = d.ucValidTime;
         s.WriteByte(time);
         byte opt = d.ucOptionFlag;
         s.WriteByte(opt);
         byte[] flow = System.BitConverter.GetBytes(d.usSaturationFlow);
         flow = flow.Reverse().ToArray();
         s.Write(flow, 0, flow.Length);
         byte occupy = d.ucSaturationOccupy;
         s.WriteByte(occupy);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0)
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             msg.flag = true;
             msg.msg = "发送检测器数据成功!";
             msg.obj = "Detector";
         }
         else
         {
             msg.flag = false;
             msg.msg = "发送检测器数据失败!";
             msg.obj = "Detector";
         }
     }
     
     return msg;
 }
Пример #15
0
 public static Message SetCollision(List<Collision> lc)
 {
     TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
     Message msg = new Message();
     //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
     byte[] hex = new byte[Define.COLLISION_BYTE_SIZE*Define.COLLISION_RESULT_LENGTH+Define.SET_COLLISION_RESPONSE.Length + 1];
     Stream s = new MemoryStream();
     s.Write(Define.SET_COLLISION_RESPONSE,0,Define.SET_COLLISION_RESPONSE.Length);
     s.WriteByte(Convert.ToByte(Define.COLLISION_RESULT_LENGTH));
     foreach (Collision c in lc)
     {
         byte id = c.ucPhaseId;
         s.WriteByte(id);
         byte[] flag = System.BitConverter.GetBytes(c.ucCollisionFlag);
         flag = flag.Reverse().ToArray();
         s.Write(flag, 0, flag.Length);
     }
     s.Position = 0;
     int count = s.Read(hex, 0, hex.Length);
     if (count > 0 )
     {
         bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
         if (b)
         {
             msg.flag = true;
             msg.msg = "设置相位冲突属性成功!";
             msg.obj = "Collision";
         }
         else
         {
             msg.flag = false;
             msg.msg = "设置相位冲突属性失败!";
             msg.obj = "Collision";
         }
     }
     
     return msg;
 }
Пример #16
0
        public static Message SetPhase(List<Phase> lp)
        {
            TscData t = Utils.Utils.GetTscDataByApplicationCurrentProperties();
            Message msg = new Message();
            //字节 长度,需要加1 ,因为。数据长度需要一个字段表示。
            byte[] hex = new byte[Define.PHASE_BYTE_SIZE * Define.PHASE_RESULT_LEN + Define.SET_PHASE_RESPONSE.Length + 1];
            Stream s = new MemoryStream();
            s.Write(Define.SET_PHASE_RESPONSE, 0, Define.SET_PHASE_RESPONSE.Length);
            s.WriteByte(Convert.ToByte(Define.PHASE_RESULT_LEN));
            foreach (Phase ptd in lp)
            {
                byte id = ptd.ucId;
                s.WriteByte(id);
                byte pg = ptd.ucPedestrianGreen;
                s.WriteByte(pg);
                byte pc = ptd.ucPedestrianClear;
                s.WriteByte(pc);
                byte mg = ptd.ucMinGreen;
                s.WriteByte(mg);
                byte gdu = ptd.ucGreenDelayUnit;
                s.WriteByte(gdu);
                byte mg1 = ptd.ucMaxGreen1;
                s.WriteByte(mg1);
                byte mg2 = ptd.ucMaxGreen2;
                s.WriteByte(mg2);
                byte fg = ptd.ucFixedGreen;
                s.WriteByte(fg);
                byte gf = ptd.ucGreenFlash;
                s.WriteByte(gf);
                byte type = ptd.ucType;
                s.WriteByte(type);
                byte opt = ptd.ucOption;
                s.WriteByte(opt);
                byte ext = ptd.ucExtend;
                s.WriteByte(ext);
            }
            s.Position = 0;
            int count = s.Read(hex, 0, hex.Length);
            if (count > 0)
            {
                bool b = Udp.sendUdpNoReciveData(t.Node.sIpAddress, t.Node.iPort, hex);
                if (b)
                {
                    msg.flag = true;
                    msg.msg = "设置相位属性成功!";
                    msg.obj = "Phase";
                }
                else
                {
                    msg.flag = false;
                    msg.msg = "设置相位属性失败!";
                    msg.obj = "Phase";
                }
            }

            return msg;
        }