예제 #1
0
        void InValidFingerPrintShouldFail()
        {
            string        nodeId = "4816d758dd37833a3a5551001dac8a5fa737a342";
            PayloadSigner signer = new PayloadSigner(nodeId, new FileKeyStore("./"));

            signer.Init();

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

            telemetryToSend.Add("abc 1");
            telemetryToSend.Add("abc 2");
            telemetryToSend.Add("abc 3");

            TelemetryPacket pkt = new TelemetryPacket
            {
                NodeId    = nodeId,
                Payload   = telemetryToSend,
                Signature = signer.SignPayload(string.Join(string.Empty, telemetryToSend))
            };

            string jsonPayload = JsonConvert.SerializeObject(pkt);

            FtpManager fm       = new FtpManager(_userName, _password, _ftpHost, _ftpPort, "38:32:36:8e:ad:ac:8c:31:57:b4:80:ba:2d:e4:88:9d", "/upload/dropzone/");
            string     fileName = string.Format("{0}-{1}.json", nodeId, DateTime.UtcNow.ToString("yyyy-MM-dd_HH:mm:ss"));
            //Assert.True(!fm.transferData(jsonPayload, fileName));
        }
예제 #2
0
파일: Form1.cs 프로젝트: trv/F1Speed
        private void timer1_Tick(object sender, EventArgs e)
        {
            var packet      = new TelemetryPacket();
            var byteMessage = PacketUtilities.ConvertPacketToByteArray(packet);

            udpClient.Send(byteMessage, byteMessage.Length);
        }
예제 #3
0
        public void Returning_to_pits_does_not_set_previous_lap_as_fastest()
        {
            // set outlap
            var manager = new TelemetryLapManager();

            foreach (var packet in TelemetryLapHelper.CreateOutLap().Packets)
            {
                manager.ProcessIncomingPacket(packet);
            }

            // Add nearly all of a lap
            var firstLap = TelemetryLapHelper.CreatePopulatedLap(lapNumber: 1f, completeLap: true);

            for (var i = 0; i < firstLap.Packets.Count - 2; i++)
            {
                manager.ProcessIncomingPacket(firstLap.Packets[i]);
            }

            Assert.IsNull(manager.FastestLap);

            var garagePacket = new TelemetryPacket {
                Lap = 0f, Speed = 0f, LapDistance = -0.001f
            };

            Assert.IsTrue(garagePacket.IsSittingInPits);
            manager.ProcessIncomingPacket(garagePacket);

            Assert.IsNull(manager.FastestLap);
        }
예제 #4
0
        public void SpeedInKmPerHour_is_correct()
        {
            var packet = new TelemetryPacket {
                Speed = 100f
            };

            Assert.AreEqual(360, packet.SpeedInKmPerHour);
        }
예제 #5
0
        public void GetPacketClosestTo_returns_packet_closest_to_supplied_packet()
        {
            var tLap = new TelemetryLap(Circuit.NullCircuit, "LapType");

            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 0.529f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 1.875f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 3.221f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 4.567f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 5.931f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 7.262f
            });                                                            // should be closest to this
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 8.611f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 9.961f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 11.311f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 12.661f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 14.013f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 15.365f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 16.715f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 18.067f
            });
            tLap.AddPacket(new TelemetryPacket {
                LapDistance = 19.419f
            });

            var tPacketCompare = new TelemetryPacket {
                LapDistance = 7.811f
            };

            var foundPacket = tLap.GetPacketClosestTo(tPacketCompare);

            Assert.AreEqual(7.262f, foundPacket.LapDistance);
        }
예제 #6
0
        public static byte[] ConvertPacketToByteArray(TelemetryPacket packet)
        {
            int size = Marshal.SizeOf(packet);
            byte[] arr = new byte[size];
            IntPtr ptr = Marshal.AllocHGlobal(size);

            Marshal.StructureToPtr(packet, ptr, true);
            Marshal.Copy(ptr, arr, 0, size);
            Marshal.FreeHGlobal(ptr);

            return arr;
        }
예제 #7
0
        public TelemetryPacketGenerator(int lowerRange, int upperRange)
        {
            _packetNumber = 0;

            _lowerRange      = lowerRange;
            _upperRange      = upperRange;
            _randomGenerator = new Random();
            _current         = new TelemetryPacket
            {
                Time = ElapsedTime
            };
        }
예제 #8
0
        public TelemetryPacket GetPacket()
        {
            // inspect each property and fill with crap
            var       packet = new TelemetryPacket();
            ValueType vThis  = packet;
            var       fields = packet.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);

            for (var i = 0; i < fields.Count(); i++)
            {
                fields[i].SetValue(vThis, 10);
            }

            return((TelemetryPacket)vThis);
        }
예제 #9
0
        public void HasStartLinePacket_is_false_when_first_packet_time_is_greater_than_one_sixtieth_of_second()
        {
            const float cutoff = (1000 / 60000f) + 0.001f;

            // Samples are taken every 0.017 seconds, so first sample must be < 0.018 into the lap.
            // time differs slightly because last sample of last lap might have been nearly 0.017 before end of that lap.
            var tPacket = new TelemetryPacket()
            {
                LapTime = cutoff * 1.1f
            };
            var tLap = new TelemetryLap(Circuit.NullCircuit, "LapType");

            tLap.AddPacket(tPacket);

            Assert.IsFalse(tLap.IsFirstPacketStartLine);
        }
예제 #10
0
        public void ShouldDeseializeFromJson()
        {
            string json = "{ \"nodeid\":\"validator-1\",\"payload\": [ \"payload-line-1\",\"payload-line-2\" ],\"signature\":\"a-signature\"}";

            TelemetryPacket tp = JsonConvert.DeserializeObject <TelemetryPacket>(json);

            tp.NodeId.Should().Be("validator-1");
            tp.Signature.Should().Be("a-signature");
            tp.Payload.Should()
            .HaveCount(2)
            .And
            .BeEquivalentTo(new[]
            {
                "payload-line-1",
                "payload-line-2"
            });
        }
예제 #11
0
        // This method runs continously in the data collection thread.  It
        // waits to receive UDP packets from the game, converts them and writes
        // them to the shared struct variable.
        private void FetchData()
        {
            while (true)
            {
                // Get the data (this will block until we get a packet)
                Byte[] receiveBytes = udpSocket.Receive(ref senderIP);

                // Lock access to the shared struct
                syncMutex.WaitOne();

                TransmissionLabel.BackColor = Color.Green;

                // Convert the bytes received to the shared struct
                latestData = PacketUtilities.ConvertToPacket(receiveBytes);
                manager.ProcessIncomingPacket(latestData);

                //TransmissionLabel.BackColor = Color.Red;

                // Release the lock again
                syncMutex.ReleaseMutex();
            }
        }
예제 #12
0
        protected override void start()
        {
            //if(manager == null)
            //    manager = new TelemetryLapManager();
            // Set up the socket for collecting game telemetry
            try
            {
                //remoteIP = F1SpeedSettings.AllowConnectionsFromOtherMachines ? new IPEndPoint(IPAddress.Any, PORTNUM) : new IPEndPoint(IPAddress.Parse(IP), PORTNUM);
                //remoteIP = new IPEndPoint(IPAddress.Parse(IP), PORTNUM);
                udpSocket = new UdpClient(PORTNUM);
                //udpSocket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                //udpSocket.ExclusiveAddressUse = false;
                //udpSocket.Client.Bind(remoteIP);
                NotifyStatusMessage("Connected to F1 Codemaster. " + IP + ":" + PORTNUM.ToString());
                while (!CancellationPending)
                {
                    if (udpSocket.Available > 0)
                    {
                        // Get the data (this will block until we get a packet)
                        Byte[] receiveBytes = udpSocket.Receive(ref senderIP);

                        // Lock access to the shared struct
                        //syncMutex.WaitOne();

                        // Convert the bytes received to the shared struct
                        latestData = PacketUtilities.ConvertToPacket(receiveBytes);
                        //manager.ProcessIncomingPacket(latestData);

                        // Release the lock again
                        //syncMutex.ReleaseMutex();

                        /*currentRpm = float.Parse(manager.GetCurrentData("EngineRevs"));
                         * firstRpm = 1.10f * float.Parse(manager.GetCurrentData("IdleRpm"));
                         * lastRpm = 0.90f * float.Parse(manager.GetCurrentData("MaxRpm"));*/

                        currentRpm = latestData.EngineRevs;
                        firstRpm   = 1.10f * latestData.IdleRpm;
                        lastRpm    = 0.90f * latestData.MaxRpm;

                        sendRPMShiftMsg(currentRpm, firstRpm, lastRpm, flag);

                        foreach (SerialManager serialManager in sm)
                        {
                            if (serialManager.deviceContains7Segments())
                            {
                                send7SegmentMsg();
                            }
                        }

                        lastTimeConnected = Utils.getCurrentTimeMillis();
                    }
                    else
                    {
                        if (Utils.getCurrentTimeMillis() - lastTimeConnected > 1000)
                        {
                            foreach (SerialManager serialManager in sm)
                            {
                                if (serialManager.deviceContains7Segments())
                                {
                                    serialManager.enqueueCommand(Utils.getDisconnectedMsgCmd(), false);
                                    serialManager.enqueueCommand(Utils.getBlackRPMCmd(), false);
                                }
                            }

                            //race session hasn't started or game paused
                            lastTimeConnected = 0;
                        }
                    }

                    Thread.Sleep(TIMERINTERVAL);
                }
            }
            catch (Exception e)
            {
                logger.LogMessageToFile(e.ToString(), true);
                // throw;
            }
        }
예제 #13
0
        /// <summary>
        /// Sends data to Ingress restful end point
        /// </summary>
        /// <param name="state">Object state</param>
        private static void FlushToIngress(object state)
        {
            // Flush to ingress if more than 10 telemetry recordings -or- last flush older that 1 minute
            if (_globalQueue.Count <= 10 && DateTime.UtcNow - _lastFlush <= new TimeSpan(0, 1, 0))
            {
                Console.WriteLine($"Not flushing: {_globalQueue.Count} Queued - {(DateTime.UtcNow - _lastFlush).TotalSeconds} seconds since flush");
                return;
            }

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

            while (telemetryToSend.Count < 50 && _globalQueue.TryDequeue(out string lineFromQueue))
            {
                telemetryToSend.Add(lineFromQueue);
            }

            Console.WriteLine($"Flushing {telemetryToSend.Count} to ingress. {_globalQueue.Count} still in queue." + (_flushHighspeed ? " [HighSpeed]" : ""));

            TelemetryPacket pkt = new TelemetryPacket
            {
                NodeId    = _configuration.NodeId,
                Payload   = telemetryToSend,
                Signature = _signer.SignPayload(string.Join(string.Empty, telemetryToSend))
            };

            string jsonPayload = JsonConvert.SerializeObject(pkt);

            // Send data
            TalkToIngress tti         = new TalkToIngress(_configuration.IngressHost + "/api/ingress/influx", _configuration.IngressFingerprint);
            bool          sendSuccess = tti.SendRequest(jsonPayload).Result;

            if (!sendSuccess)
            {
                if (DateTime.UtcNow - _lastFlush > TimeSpan.FromMinutes(5))
                {
                    // unable to send to ingress for 5 minutes - send by second channel
                    Console.WriteLine("ERROR: Unable to send to ingress for more then 5 minutes. Sending queue on second channel.");
                    string fileName = $"{_configuration.NodeId}-{DateTime.UtcNow:yyyy-MM-dd_HH:mm:ss}.json";
                    try
                    {
                        if (!_ftpMgr.TransferData(jsonPayload, fileName))
                        {
                            Console.WriteLine("ERROR: Unable to send data on second channel. Data File {0}", fileName);

                            // second channel also not available - requeue
                            Console.WriteLine("Unable to flush to second channel - re queueing");
                            telemetryToSend.ForEach(_globalQueue.Enqueue);
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("ERROR: Unable to send data on second channel. Error Details {0}", ex);

                        // second channel also not available - requeue
                        Console.WriteLine("Unable to flush to second channel - re queueing");
                        telemetryToSend.ForEach(_globalQueue.Enqueue);
                    }
                }
                else
                {
                    // 5min second channel delay not reached -> re-queue
                    Console.WriteLine("Unable to flush. Re-queuing...");
                    telemetryToSend.ForEach(_globalQueue.Enqueue);
                }
            }
            else
            {
                if (_globalQueue.Count > 250 && !_flushHighspeed)
                {
                    // increase processing speed to 2 seconds
                    Console.WriteLine("Increasing push speed due to queue size");
                    _flushTimer.Change(2000, 2000);
                    _flushHighspeed = true;
                }
                else if (_globalQueue.Count < 250 && _flushHighspeed) // queue is small enough to get processed. back to normal speed
                {
                    Console.WriteLine("Decreasing push speed due to queue size");
                    _flushTimer.Change(10000, 10000);
                    _flushHighspeed = false;
                }
                _lastFlush = DateTime.UtcNow;
            }
        }
예제 #14
0
        private void ReadWorker(object n)
        {
            lock (this.Data)
            {
                _DataPointer = 0;
                _ReadStage   = 1;

                for (int i = 0; i < data.Length - 8; i++)
                {
                    if (data[i] == '$' && data[i + 1] == '#')
                    {
                        ushort PacketID   = BitConverter.ToUInt16(data, i + 2);
                        ushort Type       = BitConverter.ToUInt16(data, i + 4);
                        ushort InstanceID = BitConverter.ToUInt16(data, i + 6);
                        ushort PacketSize = BitConverter.ToUInt16(data, i + 8);
                        byte[] PacketData = new byte[PacketSize];
                        ByteMethods.memcpy(PacketData, data, PacketSize, 0, i + 10);

                        TelemetryPacket packet = new TelemetryPacket
                        {
                            Data       = PacketData,
                            ID         = PacketID,
                            Type       = (TelemetryLogPacket)Type,
                            InstanceID = InstanceID,
                            Size       = PacketSize
                        };
                        Packets.Add(packet);
                        _DataPointer = i + PacketSize;
                        i           += PacketSize;
                    }
                }
                _DataPointer = data.Length;
                _ReadStage   = 2;

                // parse packets
                TelemetrySample Sample = new TelemetrySample();
                Instances  = new Dictionary <int, string>();
                Properties = new Dictionary <string, Dictionary <int, string> >();
                Types      = new Dictionary <string, Dictionary <int, int> >();

                string last_type    = "";
                int    last_type_id = 0;
                bool   first_packet = true;
                double time         = -1.0;
                foreach (TelemetryPacket packet in Packets)
                {
                    _PacketPointer++;
                    switch (packet.Type)
                    {
                    case TelemetryLogPacket.InstanceName:
                        last_type    = ASCIIEncoding.ASCII.GetString(packet.Data).Replace('\0', ' ').Trim();
                        last_type_id = packet.InstanceID;
                        Instances.Add(last_type_id, last_type);
                        Types.Add(last_type, new Dictionary <int, int>());
                        Properties.Add(last_type, new Dictionary <int, string>());
                        break;

                    case TelemetryLogPacket.InstanceMember:
                        int id = BitConverter.ToInt16(packet.Data, 2);

                        if (!Sample.Data.ContainsKey(last_type_id))
                        {
                            Sample.Data.Add(last_type_id, new Dictionary <int, object>());
                        }
                        if (Sample.Data[last_type_id].ContainsKey(id) == false)
                        {
                            Sample.Data[last_type_id].Add(id, 0);
                        }


                        int type_id = BitConverter.ToInt16(packet.Data, 0);

                        if (Types[last_type].ContainsKey(id) == false)
                        {
                            Types[last_type].Add(id, type_id);

                            byte[] member_name = new byte[packet.Data.Length - 4];
                            ByteMethods.memcpy(member_name, packet.Data, packet.Data.Length - 4, 0, 4);

                            string key = ASCIIEncoding.ASCII.GetString(member_name).Replace('\0', ' ').Trim();
                            Properties[last_type].Add(id, key);
                        }

                        break;

                    case TelemetryLogPacket.Data:

                        int instance_id = BitConverter.ToInt16(packet.Data, 0);
                        int last_typeid = 0;
                        for (int i = 2; i < packet.Data.Length;)
                        {
                            int    id_type = BitConverter.ToInt32(packet.Data, i);
                            object v       = 0;
                            Dictionary <int, int> TypeArray = Types[Instances[instance_id]];
                            i += 4;
                            if (TypeArray.ContainsKey(id_type))
                            {
                                switch (TypeArray[id_type])
                                {
                                case 0:         //double
                                    v  = BitConverter.ToDouble(packet.Data, i);
                                    i += 8;
                                    break;

                                case 1:         //float
                                    v  = BitConverter.ToSingle(packet.Data, i);
                                    i += 4;
                                    break;

                                case 2:         // int32
                                    v  = BitConverter.ToInt32(packet.Data, i);
                                    i += 4;
                                    break;

                                case 3:         // int16
                                    v  = BitConverter.ToInt16(packet.Data, i);
                                    i += 2;
                                    break;

                                case 4:         // int8
                                    v  = packet.Data[i];
                                    i += 1;
                                    break;

                                case 5:         // uint32
                                    v  = BitConverter.ToUInt32(packet.Data, i);
                                    i += 4;
                                    break;

                                case 6:         // uint16
                                    v  = BitConverter.ToUInt16(packet.Data, i);
                                    i += 2;
                                    break;

                                case 7:         // uint8
                                    v  = packet.Data[i];
                                    i += 1;
                                    break;

                                case 8:         // string
                                    int k = i;
                                    for (; k < packet.Data.Length; k++)
                                    {
                                        if (packet.Data[k] == 0)
                                        {
                                            break;
                                        }
                                    }
                                    v = ASCIIEncoding.ASCII.GetString(packet.Data, i, k - i);
                                    i = k + 1;
                                    break;

                                case 9:         // bool
                                    v  = ((packet.Data[i] == 1) ? true : false);
                                    i += 1;
                                    break;

                                default:
                                    v = 0;
                                    break;
                                }

                                Sample.Data[instance_id][id_type] = (object)v;
                                last_typeid = id_type;
                            }
                        }
                        break;

                    case TelemetryLogPacket.Time:

                        // Store previous samples.
                        if (time != -1.0 && this.Data.ContainsKey(time) == false)
                        {
                            this.Data.Add(time, Sample.Clone());
                            this.Data[time].Time = time;
                        }
                        time = BitConverter.ToDouble(packet.Data, 0);
                        break;
                    }
                }


                // Store last sample.
                if (time != -1.0 && this.Data.ContainsKey(time) == false)
                {
                    this.Data.Add(time, Sample.Clone());
                    this.Data[time].Time = time;
                }

                _ReadStage = 3;

                // Set the telemetry track.
                if (Telemetry.m.Active_Session)
                {
                    return;
                }
                else if (Telemetry.m.Sims != null)
                {
                    // TODO: Urgent; add simulator type to log file.
                    Telemetry.m.Track_Load(Telemetry.m.Sims.Get("rfactor"), GetString(time, "Session.CircuitName"));
                }
            }
        }