Example #1
0
        public void _clear_socket_packets(int id)
        {
            var i = 0;
            var p = _packets[i];

            while (p != null)
            {
                if (p.id == id || id == ESP32_ALL_SOCKET_IDS)
                {
                    var q = p;

                    if (_packets_end == p.next)
                    {
                        _packets_end = p;                         // Set last packet next field/_packets
                    }

                    p = p.next;
                }
                else
                {
                    // Point to last packet next field
                    p = p.next;
                }
            }
        }
Example #2
0
        private void Soglia_intervento_Click(object sender, EventArgs e)
        {
            soglia_intervento = Convert.ToUInt16(this.textBox1.Text);

            if (Serial_port_open == true)
            {
                if (Start_acquisition == false)
                {
                    pkt           = new packet();
                    packet_length = Marshal.SizeOf(pkt);
                    buffer        = new byte[packet_length];
                    pkt.cmd       = Command.CMD_WRITE;
                    pkt.STX       = Command.STX_CONST;
                    pkt.ETX       = Command.ETX_CONST;
                    pkt.sub_cmd   = Sub_Command.SET_SOGLIA;


                    pkt.payload    = new byte[PL_LENGTH];
                    pkt.payload[0] = (byte)soglia_intervento;
                    pkt.payload[1] = (byte)(soglia_intervento >> 8);

                    serialPort1.Write(getBytes(pkt), 0, packet_length);
                }
            }
        }
Example #3
0
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            int  Gain_index = Gain_selector.SelectedIndex + 1;
            byte Gain_value = Convert.ToByte(Gain_index);

            if ((serialPort1.IsOpen == true) && (Start_acquisition == false))
            {
                pkt           = new packet();
                packet_length = Marshal.SizeOf(pkt);
                buffer        = new byte[packet_length];
                pkt.cmd       = Command.CMD_WRITE;
                pkt.STX       = Command.STX_CONST;
                pkt.ETX       = Command.ETX_CONST;
                pkt.sub_cmd   = Sub_Command.SET_GAIN_1;


                pkt.payload    = new byte[PL_LENGTH];
                pkt.payload[0] = Gain_value;

                serialPort1.Write(getBytes(pkt), 0, packet_length);
            }
            else
            {
            }
        }
Example #4
0
        private void Threshold_Limit_Scroll(object sender, ScrollEventArgs e)
        {
            UInt16 Threshold_limit = (UInt16)(Threshold_Limit.Maximum - Threshold_Limit.Value);

            threshold_value.Text = Threshold_limit.ToString();
            if ((serialPort1.IsOpen == true) &&
                (Start_acquisition == false) &&
                (threshold_cmd_sem == true))
            {
                pkt           = new packet();
                packet_length = Marshal.SizeOf(pkt);
                buffer        = new byte[packet_length];
                pkt.cmd       = Command.CMD_WRITE;
                pkt.STX       = Command.STX_CONST;
                pkt.ETX       = Command.ETX_CONST;
                pkt.sub_cmd   = Sub_Command.SET_THSD;


                pkt.payload    = new byte[PL_LENGTH];
                pkt.payload[0] = (byte)Threshold_limit;
                pkt.payload[1] = (byte)(Threshold_limit >> 8);

                serialPort1.Write(getBytes(pkt), 0, packet_length);
            }
            else
            {
                Threshold_Limit.Value = Old_threshold;
            }
        }
Example #5
0
        private void Set_nSample_Click(object sender, EventArgs e)
        {
            nSampleValue = Convert.ToUInt16(this.nSample_Value.Text);

            if (Serial_port_open == true)
            {
                if (Start_acquisition == false)
                {
                    pkt           = new packet();
                    packet_length = Marshal.SizeOf(pkt);
                    buffer        = new byte[packet_length];
                    pkt.cmd       = Command.CMD_WRITE;
                    pkt.STX       = Command.STX_CONST;
                    pkt.ETX       = Command.ETX_CONST;
                    pkt.sub_cmd   = Sub_Command.SET_NCAMP;


                    pkt.payload    = new byte[PL_LENGTH];
                    pkt.payload[0] = (byte)nSampleValue;
                    pkt.payload[1] = (byte)(nSampleValue >> 8);

                    serialPort1.Write(getBytes(pkt), 0, packet_length);
                }
            }
        }
Example #6
0
        private void START_Click(object sender, EventArgs e)
        {
            if (Serial_port_open == true)
            {
                STOP.Visible              = true;
                START.Visible             = false;
                Start_acquisition         = true;
                Threshold_Limit.Enabled   = false;
                Set_nSample.Enabled       = false;
                Gain_selector.Enabled     = false;
                Soglia_intervento.Enabled = false;
                SAVE_PARAM.Visible        = true;
                SAVE_PARAM.Enabled        = false;


                pkt           = new packet();
                packet_length = Marshal.SizeOf(pkt);
                buffer        = new byte[packet_length];
                pkt.cmd       = Command.CMD_READ;
                pkt.sub_cmd   = Sub_Command.READ_SENSOR;
                pkt.STX       = Command.STX_CONST;
                pkt.ETX       = Command.ETX_CONST;
                serialPort1.Write(getBytes(pkt), 0, packet_length);
            }
            else
            {
                //
            }
        }
Example #7
0
        static void Main(string[] args)
        {
            ASCIIEncoding enc = new ASCIIEncoding();

            byte[] data   = null;
            byte[] pack   = null;
            byte[] unpack = null;
            packet obj    = new packet();
            packet res    = new packet();

            obj.phoneval                = new packet.phone[1];
            obj.phoneval[0]             = new packet.phone();
            obj.phoneval[0].fooval      = new packet.foo();
            obj.phoneval[0].fooval.bar1 = 3.99f;
            obj.address     = enc.GetBytes("hello");
            obj.luck        = new long[1];
            obj.luck[0]     = 1122334455;
            obj.address1    = new byte[1][];
            obj.address1[0] = enc.GetBytes("world");
            obj.fooval      = new foo2();
            obj.fooval.bar2 = 3.3f;
            obj._serialize(out data);
            Console.WriteLine("encode: {0}", BitConverter.ToString(data));
            obj._pack(data, data.Length, out pack);
            Console.WriteLine("pack: {0}", BitConverter.ToString(pack));
            obj._unpack(pack, pack.Length, out unpack);
            Console.WriteLine("unpack: {0}", BitConverter.ToString(unpack));
            res._parse(unpack, unpack.Length);
            Console.WriteLine("world: {0} {1} {2} {3} {4}",
                              UTF8Encoding.UTF8.GetString(res.address),
                              res.phoneval.Length,
                              res.luck[0],
                              UTF8Encoding.UTF8.GetString(res.address1[0]),
                              res.address1.Length);
        }
Example #8
0
        private ResponsePacketType ExecuteWebEequest(packet input)
        {
            var message  = SerializeObject(input);
            var response = SendHttpRequest(message);

            return(DeserializeObject(response));
        }
Example #9
0
        public ResponsePacketType GetMailAccounts(int siteId)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.mail };
            packet.Items            = new MailTypeRequest[]
            {
                new MailTypeRequest()
                {
                    Items = new MailTypeRequestGet_info[]
                    {
                        new MailTypeRequestGet_info()
                        {
                            filter = new GetInfoAdvancedFilter()
                            {
                                siteid = siteId.ToString()
                            },
                            mailboxusage = new Plesk.Schemas.Input.NoneType(),
                            mailbox      = new Plesk.Schemas.Input.NoneType()
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #10
0
        static void Main(string[] args)
        {
            byte[] data   = null;
            byte[] pack   = null;
            byte[] unpack = null;
            packet obj    = new packet();
            packet res    = new packet();

            obj.phoneval                 = new packet.phone[1];
            obj.phoneval[0]              = new packet.phone();
            obj.phoneval[0].home         = 3389;
            obj.phoneval[0].work         = 3389.1f;
            obj.phoneval[0].main         = true;
            obj.phoneval[0].fooval       = new packet.foo();
            obj.phoneval[0].fooval.bar1  = 3.99f;
            obj.phoneval[0].fooval.int8  = 127;
            obj.phoneval[0].fooval.int16 = 256;
            obj.address     = enc.GetBytes("hello");
            obj.luck        = new long[1];
            obj.luck[0]     = 1122334455;
            obj.address1    = new string[1];
            obj.address1[0] = "world";
            obj.fooval      = new foo2();
            obj.fooval.bar2 = 3.3f;
            obj._serialize(out data);
            Console.WriteLine("encode: {0}", BitConverter.ToString(data));
            obj._pack(data, data.Length, out pack);
            Console.WriteLine("pack: {0}", BitConverter.ToString(pack));
            obj._unpack(pack, pack.Length, out unpack);
            Console.WriteLine("unpack: {0}", BitConverter.ToString(unpack));
            res._parse(unpack, unpack.Length);
            assert_packet(res, obj);
        }
Example #11
0
        public ResponsePacketType DeleteWebspace(int id)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.webspace };
            packet.Items            = new Plesk.Schemas.Input.DomainTypeRequest[]
            {
                new Plesk.Schemas.Input.DomainTypeRequest
                {
                    ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType13[] { Plesk.Schemas.Input.ItemsChoiceType13.del },

                    Items = new Plesk.Schemas.Input.DomainTypeRequestDel[]
                    {
                        new Plesk.Schemas.Input.DomainTypeRequestDel
                        {
                            filter = new Plesk.Schemas.Input.domainFilterType
                            {
                                ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType11[] { Plesk.Schemas.Input.ItemsChoiceType11.id },
                                Items            = new string[] { id.ToString() }
                            }
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #12
0
        public ResponsePacketType GetDomain(string name)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.site };
            packet.Items            = new SiteTypeRequest[]
            {
                new SiteTypeRequest()
                {
                    Items = new SiteTypeRequestGet[]
                    {
                        new SiteTypeRequestGet()
                        {
                            filter = new Plesk.Schemas.Input.siteFilterType()
                            {
                                ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType63[] { Plesk.Schemas.Input.ItemsChoiceType63.name },
                                Items            = new string[] { name }
                            },
                            dataset = new Plesk.Schemas.Input.siteDatasetType()
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #13
0
        public ResponsePacketType GetWebspaces(string name)
        {
            packet packet = new packet();

            packet.ItemsElementName = new ItemsChoiceType76[] { ItemsChoiceType76.webspace };
            packet.Items            = new Plesk.Schemas.Input.DomainTypeRequest[]
            {
                new Plesk.Schemas.Input.DomainTypeRequest()
                {
                    ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType13[] { Plesk.Schemas.Input.ItemsChoiceType13.get },
                    Items            = new Plesk.Schemas.Input.DomainTypeRequestGet[]
                    {
                        new Plesk.Schemas.Input.DomainTypeRequestGet()
                        {
                            filter = new Plesk.Schemas.Input.domainFilterType()
                            {
                                ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType11[] { Plesk.Schemas.Input.ItemsChoiceType11.name },
                                Items            = new string[] { name }
                            },

                            dataset = new Plesk.Schemas.Input.domainDatasetType()
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #14
0
        public ResponsePacketType CreateWebspace(string name, string ip)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.webspace };
            packet.Items            = new Plesk.Schemas.Input.DomainTypeRequest[]
            {
                new Plesk.Schemas.Input.DomainTypeRequest
                {
                    ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType13[] { Plesk.Schemas.Input.ItemsChoiceType13.add },

                    Items = new Plesk.Schemas.Input.DomainTypeRequestAdd[]
                    {
                        new Plesk.Schemas.Input.DomainTypeRequestAdd
                        {
                            gen_setup = new Plesk.Schemas.Input.DomainTypeRequestAddGen_setup
                            {
                                ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType12[]
                                {
                                    Plesk.Schemas.Input.ItemsChoiceType12.name,
                                    Plesk.Schemas.Input.ItemsChoiceType12.ip_address
                                },
                                Items = new string[]
                                {
                                    name,
                                    ip
                                }
                            }
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #15
0
    // 将数据打包成2进制
    public void Send <T>(int cmd, T message) where T : ProtoBuf.IExtensible
    {
        byte[] data;
        var    ms1 = new MemoryStream();
        var    ms2 = new MemoryStream();

        ProtoBuf.Serializer.Serialize <T>(ms1, message);

        var pack = new packet();

        pack.cmd     = cmd;
        pack.payload = ms1.ToArray();

        ProtoBuf.Serializer.Serialize <packet>(ms2, pack);
        data = ms2.ToArray();

        if (status == SocketState.Closed)
        {
            return;
        }

        var bytebuf = new ByteBuf(data.Length + 4);

        bytebuf.WriteInt(data.Length);
        bytebuf.WriteBytes(data);

        Debug.Log("Send:" + data.Length + "_" + bytebuf.GetRaw().Length);

        clientSocket.BeginSend(bytebuf.GetRaw(), 0, bytebuf.GetRaw().Length,
                               SocketFlags.None,
                               null, clientSocket);
    }
Example #16
0
        public ResponsePacketType DeleteMailAccount(int siteId, string name)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.mail };
            packet.Items            = new MailTypeRequest[]
            {
                new MailTypeRequest()
                {
                    Items = new MailTypeRequestRemove[]
                    {
                        new MailTypeRequestRemove()
                        {
                            filter = new GetInfoAdvancedFilter()
                            {
                                siteid = siteId.ToString(),
                                name   = new string[] { name }
                            }
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #17
0
    bool send_cmd_and_wait_response(byte cmd, String str, ref packet pk, int micro_seconds)
    {
        vesal_socket sock   = new vesal_socket();
        bool         result = sock.connect("127.0.0.1", port);

        if (!result)
        {
            vesal_log.vesal_write_log("cant conn");
            return(false);
        }

        byte[] data = packet.create_output_from_string(cmd, str);
        sock.send_data(data);

        long cur = DateTime.Now.Ticks / 10000;
        bool ret = false;

        while (true)
        {
            System.Threading.Thread.Sleep(1);
            ArrayList sockList = new ArrayList();
            sockList.Add(sock._sock);
            Socket.Select(sockList, null, null, 1);
            if (sockList.Count > 0)
            {
                try
                {
                    ret = sock.recv_packet(ref pk);
                }
                catch
                {
                    vesal_log.vesal_write_log("recv failed!!!");
                    return(false);
                }
            }

            if (ret)
            {
                vesal_log.vesal_write_log("get response");
                break;
            }

            long cur2 = DateTime.Now.Ticks / 10000;
            if (cur2 >= cur + micro_seconds)
            {
                vesal_log.vesal_write_log("time out");
                break;
            }
        }

        sock.close();
        return(ret);
    }
Example #18
0
    // Returns a packet list of the first occurance of each unique ipSource
    static List <packet> uniqueSourceIPs(List <packet> pktLst)
    {
        List <packet> uniqueIPList = new List <packet>();

        while (pktLst.Count != 0)
        {
            packet p = pktLst.First();
            Console.WriteLine(p.ipSource);
            pktLst = pktLst.Where(x => !x.ipSource.Trim().Contains(p.ipSource.Trim())).ToList();
            uniqueIPList.Add(p);
        }
        return(uniqueIPList);
    }
Example #19
0
    static List <string> uniqueIpSrcStrings(List <packet> pktLst)
    {
        List <string> uniqueIPList = new List <string>();

        while (pktLst.Count != 0)
        {
            packet p = pktLst.First();

            pktLst = pktLst.Where(x => !x.ipSource.Trim().Contains(p.ipSource.Trim())).ToList();
            uniqueIPList.Add(p.ipSource);
        }
        return(uniqueIPList);
    }
Example #20
0
    public static List <string> uniqueProtocols(List <packet> pktLst)
    {
        List <string> protocolLst = new List <string>();

        while (pktLst.Count != 0)
        {
            packet p = pktLst.First();

            pktLst = pktLst.Where(x => !x.protocol.Trim().Equals(p.protocol.Trim())).ToList();
            protocolLst.Add(p.protocol);
        }
        return(protocolLst);
    }
Example #21
0
        bool parse(string line, int filedIdLength, int packetNumLength, out string fileId, out packet packet)
        {
            fileId = "";
            packet = null;

            if (string.IsNullOrEmpty(line))
            {
                return(false);
            }

            try
            {
                Match m = Regex.Match(line, RegexData);
                if (m == null || !m.Success)
                {
                    return(false);
                }

                string dom;
                string data = m.Value.Trim();
                StringHelper.Split(data, '.', out data, out dom);

                if (filedIdLength > 0)
                {
                    fileId = data.Substring(0, filedIdLength);
                    if (string.IsNullOrEmpty(fileId))
                    {
                        return(false);
                    }
                }

                int packetNum = 0;
                if (packetNumLength > 0)
                {
                    packetNum = BitConverterHelper.ToInt32(HexHelper.FromHexString(data.Substring(filedIdLength, packetNumLength)), 0);
                }

                packet = new packet()
                {
                    Data = HexHelper.FromHexString(data.Remove(0, filedIdLength + packetNumLength)), Order = packetNum
                };
                return(true);
            }
            catch
            {
                return(false);
            }
        }
    private void FixedUpdate()
    {
        try
        {
            ArrayList clientList = new ArrayList();
            clientList.Add(_conn_sock._sock);
            Socket.Select(clientList, null, null, 1);
            if (clientList.Count > 0)
            {
                try
                {
                    packet pk         = new packet();
                    bool   get_packet = _conn_sock.recv_packet(ref pk);
                    //UnityEngine.Debug.Log(get_packet);
                    if (get_packet)
                    {
                        byte[] buff = new byte[pk._data_len];

                        for (int j = 0; j < pk._data_len; j++)
                        {
                            buff[j] = pk._data[j];
                        }
                        //接收
                        string str = System.Text.Encoding.UTF8.GetString(buff);
                        UnityEngine.Debug.Log(pk._cmd_code == (byte)VESAL_CMD_CODE.MSG_CMD);
                        //vesal_log.vesal_write_log("sub"+pk._cmd_code+"  "+str);
                        UnityEngine.Debug.Log(pk._cmd_code);
                        UnityEngine.Debug.Log((byte)VESAL_CMD_CODE.MSG_CMD);
                        //
                        if (pk._cmd_code == (byte)VESAL_CMD_CODE.MSG_CMD)
                        {
                            UnityEngine.Debug.Log("realMessage:" + str);
                            vesal_log.vesal_write_log("realMessage:" + str);
                            GetMessage(str);
                        }
                    }
                }
                catch (Exception e)
                {
                    //UnityEngine.Debug.Log(e.Message);
                }
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.Log(e.Message);
        }
    }
Example #23
0
        public ResponsePacketType UpdateMailAccount(int siteId, string name, string password, long quota = 0)
        {
            packet packet = new packet();

            packet.ItemsElementName = new Plesk.Schemas.Input.ItemsChoiceType76[] { Plesk.Schemas.Input.ItemsChoiceType76.mail };
            packet.Items            = new MailTypeRequest[]
            {
                new MailTypeRequest()
                {
                    Items = new MailTypeRequestUpdate[]
                    {
                        new MailTypeRequestUpdate()
                        {
                            Item = new MailTypeRequestUpdateSet
                            {
                                filter = new mailnameFilterType()
                                {
                                    mailname = new Plesk.Schemas.Input.mailnameUpdateType[]
                                    {
                                        new Plesk.Schemas.Input.mailnameUpdateType()
                                        {
                                            name    = name,
                                            mailbox = quota > 0 ? new Plesk.Schemas.Input.mailnameUpdateTypeMailbox()
                                            {
                                                enabled = true, quota = quota, quotaSpecified = true
                                            } : null,
                                            Item = new Plesk.Schemas.Input.mailnameUpdateTypePassword()
                                            {
                                                type          = Plesk.Schemas.Input.passwdType.plain,
                                                value         = password,
                                                typeSpecified = true
                                            }
                                        }
                                    },

                                    siteid = siteId.ToString()
                                }
                            }
                        }
                    }
                }
            };

            return(ExecuteWebEequest(packet));
        }
Example #24
0
        static void Main(string[] args)
        {
            byte[] data = null;
            packet obj  = new packet();
            packet res  = new packet();

            obj.phoneval    = new packet.phone[1];
            obj.phoneval[0] = new packet.phone();
            obj.address     = "hello";
            obj.luck        = new int[1];
            obj.luck[0]     = 3;
            obj.address1    = new string[1];
            obj.address1[0] = "world";
            obj._serialize(out data);
            Console.WriteLine("hello: {0}", BitConverter.ToString(data));
            res._parse(data);
            Console.WriteLine("world: {0} {1} {2} {3} {4}", res.address, res.phoneval.Length, res.luck[0], res.address, res.address1[0], res.address1.Length);
        }
        bool parse(string line, out string fileId, out packet packet)
        {
            fileId = "";
            packet = null;

            if (string.IsNullOrEmpty(line)) return false;

            Match m = Regex.Match(line, RegexData);
            if (m == null || !m.Success) return false;

            string dom;
            string data = m.Value.Trim();
            StringHelper.Split(data, '.', out data, out dom);
            fileId = data.Substring(0, FileIdLength);

            if (string.IsNullOrEmpty(fileId)) return false;
            int packetNum = BitConverterHelper.ToInt32(HexHelper.FromHexString(data.Substring(FileIdLength, 8)), 0);

            packet = new packet() { Data = HexHelper.FromHexString(data.Remove(0, FileIdLength + 8)), Order = packetNum };

            return true;
        }
Example #26
0
        public void _packet_handler(object sender, EventArgs e)
        {
            var result = new List <string>();
            int id;
            int amount;
            int tmp_timeout;

            // parse out the packet
            if (!_parser.recv(@",([0-9]+),([0-9]+):", result))
            {
                return;
            }
            id     = Int32.Parse(result[0]);
            amount = Int32.Parse(result[1]);

            var packet = new packet(amount);

            if (packet == null)
            {
                return;
            }

            packet.id    = id;
            packet.len   = amount;
            packet.next  = null;
            packet.index = 0;

            tmp_timeout = last_timeout_ms;
            setTimeout(500);
            if (_parser.read(packet.data, 0, amount) == 0)
            {
                setTimeout(tmp_timeout);
                return;
            }

            // append to packet list
            _packets.Add(packet);
        }
Example #27
0
    public void init(packet packet, Transform src, Transform dst)
    {
        this.packet = packet;
        this.dst    = dst;

        transform.localScale *= (int.Parse(packet.length) / 100);

        string protocol = packet.protocol;

        if (protocol.Trim().Contains("MDNS"))
        {
            GetComponent <Renderer>().material = red;
        }
        else if (protocol.Trim().Contains("UDP"))
        {
            GetComponent <Renderer>().material = blue;
        }
        else if (protocol.Trim().Contains("BJNP"))
        {
            GetComponent <Renderer>().material = green;
        }
        else if (protocol.Trim().Contains("DHCP"))
        {
            GetComponent <Renderer>().material = yellow;
        }
        else if (protocol.Trim().Contains("SSDP"))
        {
            GetComponent <Renderer>().material = purple;
        }
        else
        {
            GetComponent <Renderer>().material = pink;
        }

        gameObject.transform.position = src.position;

        playSound();
    }
Example #28
0
        private void SAVE_PARAM_Click(object sender, EventArgs e)
        {
            if (Serial_port_open == true)
            {
                if (Start_acquisition == false)
                {
                    pkt           = new packet();
                    packet_length = Marshal.SizeOf(pkt);
                    buffer        = new byte[packet_length];
                    pkt.cmd       = Command.CMD_WRITE;
                    pkt.STX       = Command.STX_CONST;
                    pkt.ETX       = Command.ETX_CONST;
                    pkt.sub_cmd   = Sub_Command.SAVE_PAR;


                    pkt.payload    = new byte[PL_LENGTH];
                    pkt.payload[0] = (byte)0x00;
                    pkt.payload[1] = (byte)0x00;

                    serialPort1.Write(getBytes(pkt), 0, packet_length);
                }
            }
        }
Example #29
0
    void Update()
    {
        if (!GameState.isPaused())
        {
            timer += Time.deltaTime;
            if (timer >= timeStep)
            {
                timer = 0;
                if (queued.Count > 0)
                {
                    packet current = queued[0];
                    if (current != null)
                    {
                        Transform src = getPortFromIP(current.ipSource);
                        Transform dst = getPortFromIP(current.ipDest);
                        if (src != null)
                        {
                            GameObject packetInstance = Instantiate(visualPacket);
                            packetInstance.GetComponent <PacketAttributes>().init(current, src, dst);
                            active.Add(packetInstance);
                        }
                    }
                    logged.Add(current);
                    queued.Remove(current);
                }
            }
        }

        if (resetTimer >= resetTimeStep)
        {
            addPackets();
        }
        else
        {
            resetTimer += Time.deltaTime;
        }
    }
Example #30
0
        private void vScrollBar1_Scroll(object sender, ScrollEventArgs e)
        {
            UInt16 gain_limit = (UInt16)(gainScrollBar.Maximum - gainScrollBar.Value);

            if ((serialPort1.IsOpen == true) &&
                (Start_acquisition == false) &&
                (threshold_cmd_sem == true))
            {
                pkt           = new packet();
                packet_length = Marshal.SizeOf(pkt);
                buffer        = new byte[packet_length];
                pkt.cmd       = Command.CMD_WRITE;
                pkt.STX       = Command.STX_CONST;
                pkt.ETX       = Command.ETX_CONST;
                pkt.sub_cmd   = Sub_Command.SET_GAIN_2;


                pkt.payload    = new byte[PL_LENGTH];
                pkt.payload[0] = (byte)gain_limit;
                pkt.payload[1] = (byte)0x00;

                serialPort1.Write(getBytes(pkt), 0, packet_length);
            }
        }
Example #31
0
    void send(packet pck)
    {
        //print("sending " + pck.generateRawPacketData().Count + "bytes");
        try
        {
            //m_socket.Send(pck.generateRawPacketData().ToArray());
            byte[] pckData = pck.generateRawPacketData().ToArray();
            int sent = 0;
            int toBeSent = pckData.Length;
            while (sent < toBeSent)
                sent += m_socket.Send(pckData, sent, pckData.Length, SocketFlags.None);

        }
        catch (Exception e)
        {
            print(e.Message);
            callDisconnect();
        }
    }
Example #32
0
 void parseSocketUpdate(packet pck)
 {
     List<byte> raw = pck.generateRawPacketData();
     short sockId = (short)(raw[1] << 8 | raw[2]);
     byte newstate = raw[3];
     wallSocket sock;
     for (int i = 0; i < m_Wallsockets.Count; i++)
     {
         if (m_Wallsockets[i].id == sockId)
         {
             sock = m_Wallsockets[i];
             sock.state = (WALLSOCKET_STATE)newstate;
             try
             {
                 m_updateCallback(sock);
             }
             catch (System.Exception e)
             {
                 print(e.Message);
             }
             break;
         }
     }
 }
Example #33
0
 void parseSendXML(packet pck)
 {
     string str = pck.readString();
     try
     {
         m_xmlUpdate(str);
     }
     catch (Exception e)
     {
         print(e);
     }
 }
Example #34
0
 void parseSendPicture(packet pck)
 {
     string name = pck.readString();
     int dataLen = pck.readLong();
     print("data len" + dataLen);
     byte[] data = new byte[dataLen];
     for (int i = 0; i < dataLen; i++)
         data[i] = pck.readByte();
     loadTexture tex = new loadTexture();
     tex.loadRawPicture(data);
     try
     {
         m_picUpdate(tex, name);
     }
     catch (Exception e)
     {
         print(e);
     }
 }
Example #35
0
 public void requestPowerInformation(short socketid)
 {
     packet pck = new packet(PACKET_TYPE.C_REQUEST_SOCKET_INFO);
     pck.writeShort(socketid);
     send(pck);
     //print("request power information");
 }
Example #36
0
 void parseOnlineClientsPacket(packet pck)
 {
     List<byte> raw = pck.generateRawPacketData();
     for (int i = 3; i < raw.Count; i += 19)
     {
         //print(raw.Count);
         wallSocket wsock = new wallSocket();
         wsock.id = (short)((raw[i] << 8) | raw[i + 1]);
         wsock.state = (WALLSOCKET_STATE)raw[2 + i];
         wsock.totalUptime = toInt(raw, 3 + i);
         wsock.dailyUptime = toInt(raw, 7 + i);
         wsock.dailyDowntime = toInt(raw, 11 + i);
         wsock.watt = toInt(raw, 15 + i);
         m_Wallsockets.Add(wsock);
     }
     try
     {
         m_infocallback(m_Wallsockets);
     }
     catch (System.Exception e)
     {
         print(e.Message);
     }
 }
Example #37
0
 public void crashPck()
 {
     packet pck = new packet((PACKET_TYPE)0xFF);
     send(pck);
 }
Example #38
0
 public bool updatePowerUsage(int watt, short socketid)
 {
     for (int i = 0; i < m_Wallsockets.Count; i++)
     {
         wallSocket sock = m_Wallsockets[i];
         if (sock.id == socketid)
         {
             // this is the socket
             packet pck = new packet(PACKET_TYPE.C_SOCKET_POWER_UPDATE);
             pck.writeShort(socketid);
             pck.writeLong(watt);
             send(pck);
             //print("send updatePowerUsage watt = " + watt);
             return true;
         }
     }
     return false;
 }
Example #39
0
 void generatePackets()
 {
     packet pck = new packet(m_buffer);
     switch (pck.getPacketType())
     {
         case PACKET_TYPE.S_ACCEPT:
             if (m_state == state.WAIT_FOR_ACCEPT)
             {
                 m_buffer.RemoveAt(0);
                 //print("got accept!");
                 m_state = state.ONLINE;
                 sendGetOnlineSockets();
             }
             else
             {
                 print("invalid packet! recieved accept at the wrong time!");
                 callDisconnect();
             }
             break;
         case PACKET_TYPE.S_SEND_ONLINE_CLIENTS:
             if (m_state == state.ONLINE)
             {
                 parseOnlineClientsPacket(pck);
                 m_buffer.RemoveRange(0, pck.getPacketSize());
             }
             else
             {
                 print("invalid state! is not online! but got S_SEND_ONLINE_CLIENTS");
                 callDisconnect();
             }
             break;
         case PACKET_TYPE.S_SOCKET_UPDATE:
             if (m_state == state.ONLINE)
             {
                 //print("got S_SOCK_UPDATE");
                 parseSocketUpdate(pck);
                 m_buffer.RemoveRange(0, 4);
             }
             else
             {
                 print("invalid state! is not online! but got S_SOCKET_UPDATE");
                 callDisconnect();
             }
             break;
         case PACKET_TYPE.S_SOCKET_POWER_UPDATE:
             if (m_state != state.ONLINE)
             {
                 print("invalid state! is not online! but got S_SOCKET_POWER_INFO");
                 callDisconnect();
                 break;
             }
             parsePowerUpdate(pck);
             m_buffer.RemoveRange(0, 7);
             break;
         case PACKET_TYPE.S_SOCKET_POWER_INFO:
             if (m_state != state.ONLINE)
             {
                 print("invalid state! is not online! but got S_SOCKET_POWER_INFO");
                 callDisconnect();
                 break;
             }
             parsePowerInfo(pck);
             m_buffer.RemoveRange(0, 20);
             break;
         case PACKET_TYPE.SC_PING:
             if (m_state != state.ONLINE)
             {
                 print("invalid state! is not online! but got SC_PING");
                 callDisconnect();
                 break;
             }
             parsePingPacket(pck);
             m_buffer.RemoveRange(0, pck.getPacketSize());
             break;
         case PACKET_TYPE.SC_SEND_XML:
             if (m_state != state.ONLINE)
             {
                 print("invalid state! is not online! but got SC_PING");
                 callDisconnect();
                 break;
             }
             parseSendXML(pck);
             m_buffer.RemoveRange(0, pck.getPacketSize());
             break;
         case PACKET_TYPE.SC_SEND_PICTURE:
             if (m_state != state.ONLINE)
             {
                 print("invalid state! is not online! but got SC_PING");
                 callDisconnect();
                 break;
             }
             parseSendPicture(pck);
             m_buffer.RemoveRange(0, pck.getPacketSize());
             break;
         case PACKET_TYPE.ERR_NONE:
         case PACKET_TYPE.ERR_NOT_DONE:
             break;
         default:
             print("unknown packet id :" + pck.getPacketType());
             callDisconnect();
             break;
     }
 }
Example #40
0
 public void sendXML(string str)
 {
     packet pck = new packet(PACKET_TYPE.SC_SEND_XML);
     pck.writeString(str);
     send(pck);
 }
Example #41
0
 public bool sendPicture(loadTexture data, string name)
 {
     if (!data.isTextureLoaded()) return false;
     byte[] rawPicData = data.getImageData();
     packet pck = new packet(PACKET_TYPE.SC_SEND_PICTURE);
     pck.writeString(name);
     pck.writeLong(rawPicData.Length);
     for (int i = 0; i < rawPicData.Length; i++)
         pck.writeByte(rawPicData[i]);
     send(pck);
     return true;
 }
Example #42
0
 public void requestXML()
 {
     packet pck = new packet(PACKET_TYPE.C_GET_XML);
     send(pck);
 }
Example #43
0
 void sendGetOnlineSockets()
 {
     packet pck = new packet(PACKET_TYPE.C_GET_ONLINE_CLIENTS);
     send(pck);
 }
Example #44
0
 private void parsePingPacket(packet pck)
 {
     send(pck);
 }
Example #45
0
 void sendUpdateSocketState(WALLSOCKET_STATE newstate, short socketid)
 {
     packet pck = new packet(PACKET_TYPE.C_UPDATE_SOCKET_STATE);
     pck.writeShort(socketid);
     pck.writeByte((byte)newstate);
     send(pck);
 }
Example #46
0
 void parsePowerInfo(packet pck)
 {
     List<byte> raw = pck.generateRawPacketData();
     short sockId = (short)(raw[1] << 8 | raw[2]);
     byte state = raw[3];
     int totalUptime = toInt(raw, 4);
     int dailyUptime = toInt(raw, 8);
     int dailyDowntime = toInt(raw, 12);
     int watt = toInt(raw, 16);
     for (int i = 0; i < m_Wallsockets.Count; i++)
     {
         wallSocket sock = m_Wallsockets[i];
         if (sock.id == sockId)
         {
             sock.dailyDowntime = dailyDowntime;
             sock.dailyUptime = dailyUptime;
             sock.state = (WALLSOCKET_STATE)state;
             sock.totalUptime = totalUptime;
             sock.watt = watt;
             try
             {
                 m_socketInfoCallback(sock);
             }
             catch (System.Exception e)
             {
                 print(e.Message);
             }
             m_Wallsockets[i] = sock;
             break;
         }
     }
 }
 int sortPacket(packet a, packet b) { return a.Order.CompareTo(b.Order); }
Example #48
0
 void parsePowerUpdate(packet pck)
 {
     List<byte> raw = pck.generateRawPacketData();
     short sockId = (short)(raw[1] << 8 | raw[2]);
     int watt = toInt(raw, 3);
     for (int i = 0; i < m_Wallsockets.Count; i++)
     {
         wallSocket sock = m_Wallsockets[i];
         if (sock.id == sockId)
         {
             sock.watt = watt;
             m_Wallsockets[i] = sock;
             try
             {
                 m_updateWattCallback(sock);
             }
             catch (System.Exception e)
             {
                 print(e.Message);
             }
             break;
         }
     }
 }
Example #49
0
            protected override void OnMessage(MessageEventArgs Packet)
            {
                packet DataPacket = new packet();

                //Console.WriteLine("[{0}] JSON-Deserialize: '{1}'", ID, Packet.Data);

                if (TotalDisplay-- == 0)
                {
                    TotalDisplay = 1024;
                    double DiffInSeconds = (DateTime.Now - StartTime).TotalSeconds;
                    Console.WriteLine(
                        "In {0} seconds I have processed: {1} Sends and {2} Broadcasts",
                        DiffInSeconds,
                        TotalSent,
                        TotalBroadcast
                        );
                }

                try
                {
                    DataPacket = JsonConvert.DeserializeObject <packet>(Packet.Data);
                    if (
                        DataPacket == null ||
                        DataPacket.action.IsNullOrEmpty() ||
                        DataPacket.args.Length == 0
                        )
                    {
                        throw new Newtonsoft.Json.JsonSerializationException();
                    }
                }
                catch (Newtonsoft.Json.JsonSerializationException Exception)
                {
                    Console.WriteLine("[{0}] An exception was caused when deserializing '{1}', the exception raised was: '{2}'", ID, Packet.Data, Exception.Message);
                    return;
                }
                catch (Newtonsoft.Json.JsonReaderException Exception)
                {
                    Console.WriteLine("[{0}] An exception was caused when deserializing '{1}', the exception raised was: '{2}'", ID, Packet.Data, Exception.Message);
                    return;
                }

                //Console.WriteLine("[{0}] Action: {1}", ID, DataPacket.action);

                bool SkipBroadcast = false;

                Channel = DataPacket.args[0].ToUpper();

                switch (DataPacket.action.ToUpper())
                {
                case TELL:
                    /*
                     * When anything on the channel with nyan_flag is set, send a nyan cat to everyone
                     * including the person who sent it
                     */



                    if (DataPacket.args.Length < 2 || !Channels.ContainsKey(Channel))
                    {
                        packet DataStreamError = new packet();
                        DataStreamError.action = @"TELL";
                        DataStreamError.args   = new string[] { @"FAIL", @"No TELL" };

                        Send(JsonConvert.SerializeObject(DataStreamError));

                        SkipBroadcast = true;
                    }
                    else if (Channels[Channel].flag_nyan)
                    {
                        packet NyanCat = new packet();
                        NyanCat.action = @"TELL";
                        NyanCat.args   = new string[] { @"SUCCESS", nyan() };
                        Send(JsonConvert.SerializeObject(NyanCat));
                    }

                    break;

                case ECHO:
                    packet EchoPacket = new packet();
                    EchoPacket.action = @"ECHO";
                    EchoPacket.args   = new string[] { DataPacket.args[0] };

                    Send(JsonConvert.SerializeObject(EchoPacket));

                    SkipBroadcast = true;
                    break;

                case SUBSCRIBE:
                    packet SubscribeResponse = new packet();
                    SubscribeResponse.action = @"SUBSCRIBE";

                    if (!Sockets.ContainsKey(ID))
                    {
                        while (!
                               Sockets.TryAdd(
                                   ID,
                                   Context.WebSocket
                                   )
                               )
                        {
                            Thread.Sleep(1);
                        }
                    }

                    if (!Channels.ContainsKey(Channel))
                    {
                        SubscribeResponse.args = new string[] { @"FAIL", Channel, @"No such channel" };
                        Send(JsonConvert.SerializeObject(SubscribeResponse));

                        Console.WriteLine("[{0}] Cannot subscribe client to channel, channel does not exist: '{1}'", ID, Channel);
                    }
                    else if (Subscriptions[ID].ContainsKey(Channel))
                    {
                        SubscribeResponse.args = new string[] { @"FAIL", Channel, @"You are already subscribed" };
                        Send(JsonConvert.SerializeObject(SubscribeResponse));

                        Console.WriteLine("[{0}] Cannot subscribe client to channel, they are already in it: '{1}'", ID, Channel);
                    }
                    else
                    {
                        SubscribeResponse.args = new string[] { @"SUCCESS", Channel };
                        Send(JsonConvert.SerializeObject(SubscribeResponse));

                        Subscriptions[ID].Add(Channel, true);

                        //Console.WriteLine("[{0}] Client subscribed to channel: '{1}'", ID, Channel);
                    }

                    SkipBroadcast = true;
                    break;

                case UNSUBSCRIBE:
                    packet UnSubscribeResponse = new packet();
                    UnSubscribeResponse.action = @"UNSUBSCRIBE";

                    if (Subscriptions[ID].ContainsKey(Channel))
                    {
                        UnSubscribeResponse.args = new string[] { Channel, @"SUCCESS" };
                        Send(JsonConvert.SerializeObject(UnSubscribeResponse));

                        Subscriptions[ID].Remove(Channel);

                        //Console.WriteLine("[{0}] Client unsubscribed from channel: '{1}'", ID,  Channel);
                    }
                    else
                    {
                        UnSubscribeResponse.args = new string[] { Channel, @"FAIL", @"You are already subscribed" };
                        Send(JsonConvert.SerializeObject(UnSubscribeResponse));

                        Console.WriteLine("[{0}] Cannot unsubscribe client from channel, they are not in it: '{1}'", ID, Channel);
                    }
                    SkipBroadcast = true;
                    break;

                default:
                    Console.WriteLine("[{0}] Got a request for action: {1}, no idea what it is", ID, DataPacket.action.ToUpper());
                    SkipBroadcast = true;
                    break;
                }

                if (!SkipBroadcast)
                {
                    /*
                     * No idea of the efficiency of this likely not high, but selective
                     * send packets based on if someone is in a channel or not
                     *
                     * Really should dump a [WebSocket,TELL] into a FIFO queue and use a thread
                     * for processing that queue, incase a WS goes missing
                     */

                    //Thread.Sleep(1);

                    foreach (string SesssionID in Sessions.IDs)
                    {
                        //Console.WriteLine("[{0}] Target session({1})", ID,SesssionID);
                        TotalBroadcast++;
                        if (ID.Equals(SesssionID))
                        {
                            continue;
                        }
                        if (Subscriptions[SesssionID].ContainsKey(Channel))
                        {
                            //Console.WriteLine("[{0}] Send->{1}", ID, SesssionID);
                            try
                            {
                                TotalSent++;
                                Sockets[SesssionID].Send(Packet.Data);
                            }
                            catch (Exception exception)
                            {
                                Console.WriteLine("[{0}] Exception avoided in send: {1}", ID, exception.Message);
                            }
                        }
                    }
                }
            }
Example #50
0
 public void requestPicture(string name)
 {
     packet pck = new packet(PACKET_TYPE.C_GET_PICTURE);
     pck.writeString(name);
     send(pck);
 }