private void timerTick(object sender, EventArgs e)
        {
            if (!this.isNewPacket)
            {
                return;
            }

            try
            {
                CanPacket[] canPacketListCopy = new CanPacket[canPacketList.Count];
                this.canPacketList.CopyTo(canPacketListCopy, 0);
                canPacketList.Clear();

                foreach (CanPacket cp in canPacketListCopy)
                {
                    if (dataGridView1.RowCount > 2000)
                    {
                        canPacketBindingList.Clear();
                    }
                    canPacketBindingList.Add(cp);

                    if (this.cbAutoScroll.Checked)
                    {
                        dataGridView1.FirstDisplayedScrollingRowIndex = dataGridView1.RowCount - 1;
                    }
                }

                this.isNewPacket = false;
            }
            catch
            {
                // Welcome to how to deal with concurrent threads 101
            }
        }
        private void packetRecieved(UdpRecievedEventArgs e)
        {
            if (this.isPaused)
            {
                return;
            }

            CanPacket cp = e.Message;

            if (this.filterCheckBox.Checked &&
                (cp.getCanIdBase10() < this.fromFilter ||
                 cp.getCanIdBase10() > this.toFilter))
            {
                return;
            }

            cp.packet = idCounter;
            this.canPacketList.Add(e.Message);

            this.isNewPacket = true;
            idCounter++;
            if (idCounter > 5000)
            {
                idCounter = 0;
            }
        }
Beispiel #3
0
        private void splitCanPackets(byte[] data)
        {
            Byte[] header     = data.Take(16).ToArray();
            Byte[] body       = data.Skip(16).ToArray();
            int    numPackets = body.Length / 14;

            for (int i = 0; i < numPackets; i++)
            {
                CanPacket canPacket1 = new CanPacket(header.Concat(body.Take(14).ToArray()).ToArray());
                OnUdpRecieved(new UdpRecievedEventArgs(canPacket1));
                body = body.Skip(14).ToArray();
            }
        }
        public bool SendMessage(CanPacket canPacket)
        {
            if (isConnected)
            {
                var data = canPacket.getRawBytes();
                this.udpClient.Send(data, data.Length, this.ipEndPoint);
            }
            else
            {
                return(false);
            }

            return(true);
        }
        private void button1_Click(object sender, EventArgs e)
        {
            CanPacket currentPacket = (CanPacket)dataGridView1.CurrentRow.DataBoundItem;

            if (currentPacket == null)
            {
                MessageBox.Show("Please select a CanPacket");
            }
            else
            {
                SendPacketForm sendPacketForm = new SendPacketForm(this.udpSender, currentPacket.getRawBytesString());
                sendPacketForm.MdiParent = this.MdiParent;
                sendPacketForm.Show();
            }
        }
        public SendPacketForm(UdpSender udpSender)
        {
            InitializeComponent();

            this.udpSender = udpSender;
            this.looping   = false;

            this.btnReset.Enabled   = !looping;
            this.btnLoop.Enabled    = !looping;
            this.btnSend.Enabled    = !looping;
            this.tbLoopRate.Enabled = !looping;

            this.canPacket = new CanPacket(samplePacket);

            updateInputFields();
        }
        private void btnReset_Click(object sender, EventArgs e)
        {
            this.canPacket = new CanPacket(samplePacket);

            updateInputFields();
        }
Beispiel #8
0
 public UdpRecievedEventArgs(CanPacket Messgage)
 {
     this.Message = Messgage;
 }