private void BleBikeHandler_SubscriptionValueChanged(Avans.TI.BLE.BLESubscriptionValueChangedEventArgs args)
        {
            pageConversion = new PageConversion();
            pageConversion.Page10Received += (e) =>
            {
                if (started)
                {
                    travelledDistanceStartingValue = args.Data[7];
                    started = false;
                }

                int t = args.Data[7] - travelledDistanceRawPrev;
                if (t < 0)
                {
                    t += 256;
                }
                travelledDistance       += t;
                travelledDistanceRawPrev = (byte)travelledDistance;
                this.currDistance        = travelledDistance - travelledDistanceStartingValue;
            };
            pageConversion.Page19Received += (e) =>
            {
                int lsb   = e.Data[4];
                int msb   = e.Data[5];
                int work1 = lsb + (msb << 8);

                this.currSpeed = (int)Math.Round((double)(work1 / 1000), 0);
            };
            this.currBikeData = args.Data;
            pageConversion.RegisterData(args.Data.SubArray(4, args.Data.Length - 4));
        }
Esempio n. 2
0
        private void RegisterBleBikeEvents()
        {
            pageConversion = new PageConversion();
            pageConversion.Page10Received += (args) =>
            {
                if (started)
                {
                    travelledDistanceStartingValue = args.Data[3];
                    started = false;
                }

                int t = args.Data[3] - travelledDistanceRawPrev;
                if (t < 0)
                {
                    t += 256;
                }
                travelledDistance       += t;
                travelledDistanceRawPrev = (byte)travelledDistance;

                //              pageConversion.Page19Received += (args) =>
                //          {
                //
                //          };
                //
                //              pageConversion.Page50Received += (args) =>
                //              {
                //
                //              };
            };
        }
Esempio n. 3
0
        private static void RegisterBleBikeEvents()
        {
            pageConversion = new PageConversion();
            pageConversion.Page10Received += (args) =>
            {
                if (started)
                {
                    travelledDistanceStartingValue = args.Data[3];
                    started = false;
                }

                int t = args.Data[3] - travelledDistanceRawPrev;
                if (t < 0)
                {
                    t += 256;
                }
                travelledDistance       += t;
                travelledDistanceRawPrev = (byte)travelledDistance;

                Console.Clear();
                Console.WriteLine($"Received value:                 {args.Data[3]}");
                Console.WriteLine($"Previous Value:                 {travelledDistanceRawPrev}");
                Console.WriteLine($"Travelled starting value:       {travelledDistanceStartingValue}");
                Console.WriteLine($"Travelled distance:             {travelledDistance - travelledDistanceStartingValue}");
            };

            pageConversion.Page19Received += (args) =>
            {
            };

            pageConversion.Page50Received += (args) =>
            {
            };
        }
Esempio n. 4
0
        private void ClientServerWorker_SyncDataReceived(SyncDataArgs args)
        {
            pageConversion = new PageConversion();
            pageConversion.Page10Received += (e) =>
            {
                byte[] internalBikeData = args.BikeData.ParseRepString();

                if (started)
                {
                    travelledDistanceStartingValue = internalBikeData[7];
                    started = false;
                }

                int t = internalBikeData[7] - travelledDistanceRawPrev;
                if (t < 0)
                {
                    t += 256;
                }
                travelledDistance       += t;
                travelledDistanceRawPrev = (byte)travelledDistance;

                this.Invoke((MethodInvoker) delegate
                {
                    lblDistance.Text = $"Distance: {travelledDistance - travelledDistanceStartingValue}m";
                });
            };
            pageConversion.Page19Received += (e) =>
            {
                int lsb   = e.Data[4];
                int msb   = e.Data[5];
                int work1 = lsb + (msb << 8);

                int currSpeed = (int)Math.Round((double)(work1 / 1000), 0);
                DrawSpeedOnChart(chrtSpeedIndexCounter, currSpeed);
            };

            byte[] bikeData  = args.BikeData.ParseRepString();
            byte[] heartData = args.HeartData.ParseRepString();

            if (bikeData.Length > 0)
            {
                pageConversion.RegisterData(bikeData.SubArray(4, bikeData.Length - 4));
            }

            if (heartData.Length > 0)
            {
                DrawHeartRateOnChart(chrtBpmIndexCounter, heartData[1]);
            }
            else
            {
                DrawHeartRateOnChart(chrtBpmIndexCounter, 0);
            }

            this.historyBikeData.Add(bikeData);
            this.historyHeartData.Add(heartData);

            chrtBpmIndexCounter++;
            chrtSpeedIndexCounter++;
        }
        public ClientScreen(string name, string id, ServerConnectionVR serverConnectionVR, ServerConnection serverConnection, string currentSessionId, BleHeartHandler bleHeartHandler, BleBikeHandler bleBikeHandler)
        {
            InitializeComponent();

            this.name = name;
            this.id   = id;

            this.serverConnectionVR = serverConnectionVR;
            this.jsonPacketBuilder  = new JsonPacketBuilder();
            this.serverConnection   = serverConnection;

            this.pageConversion  = new PageConversion();
            this.bleHeartHandler = bleHeartHandler;
            this.bleBikeHandler  = bleBikeHandler;

            this.runningVrData = new VRData();
            this.runningVrData.currentSessionId = currentSessionId;

            InitializeDefaultEvents();
            ToggleControls(false);
            StartWorker();
        }
Esempio n. 6
0
        private void RegisterBleBikeEvents()
        {
            pageConversion = new PageConversion();
            pageConversion.Page10Received += (args) =>
            {
                if (started)
                {
                    travelledDistanceStartingValue = args.Data[3];
                    started = false;
                }

                int t = args.Data[3] - travelledDistanceRawPrev;
                if (t < 0)
                {
                    t += 256;
                }
                travelledDistance       += t;
                travelledDistanceRawPrev = (byte)travelledDistance;
                writeFiets(travelledDistance.ToString());

                try
                {
                    this.Invoke((MethodInvoker) delegate
                    {
                        //  lblDistance.Text = $"{travelledDistance - travelledDistanceStartingValue}m";
                    });
                }
                catch (ObjectDisposedException) { }
            };

            pageConversion.Page19Received += (args) =>
            {
            };

            pageConversion.Page50Received += (args) =>
            {
            };
        }
        private async void DateTimePicker1_ValueChanged(object sender, EventArgs e)
        {
            string rawResponse = await this.serverConnection.SendWithResponse($"Doctor/GetClientHistory\r\n{this.patientId}\r\n{dateTimePicker1.Value.ToString()}");

            Tuple <string[], PacketType> response = packetHandler.HandlePacket(rawResponse);

            if (response.Item1.Length == 3)
            {
                string rawJson = response.Item1[2];
                currClientData = JsonConvert.DeserializeObject <ClientData>(rawJson);

                int travelledDistance = 0;
                for (int i = 0; i < currClientData.bikeData.Count; i++)
                {
                    byte[] internalBikeData = currClientData.bikeData[i];

                    if (internalBikeData.Length > 0)
                    {
                        pageConversion = new PageConversion();
                        pageConversion.Page10Received += (args) =>
                        {
                            if (started)
                            {
                                travelledDistanceStartingValue = internalBikeData[7];
                                started = false;
                            }

                            int t = internalBikeData[7] - travelledDistanceRawPrev;
                            if (t < 0)
                            {
                                t += 256;
                            }
                            travelledDistance       += t;
                            travelledDistanceRawPrev = (byte)travelledDistance;

                            travelledDistance = travelledDistance - travelledDistanceStartingValue;
                        };
                        pageConversion.Page19Received += (args) =>
                        {
                            int lsb   = internalBikeData[4];
                            int msb   = internalBikeData[5];
                            int work1 = lsb + (msb << 8);

                            int currSpeed = (int)Math.Round((double)(work1 / 1000), 0);
                            DrawSpeedOnChart(chrtSpeedIndexCounter, currSpeed);
                        };

                        pageConversion.RegisterData(internalBikeData.SubArray(4, internalBikeData.Length - 4));
                        chrtSpeedIndexCounter++;
                    }
                    else
                    {
                        DrawSpeedOnChart(chrtSpeedIndexCounter, 0);
                    }
                }

                for (int i = 0; i < currClientData.heartRateData.Count; i++)
                {
                    byte[] internalHeartData = currClientData.bikeData[i];

                    if (internalHeartData.Length > 0)
                    {
                        DrawHeartRateOnChart(chrtBpmIndexCounter, internalHeartData[1]);
                    }
                    else
                    {
                        DrawHeartRateOnChart(chrtBpmIndexCounter, 0);
                    }

                    chrtBpmIndexCounter++;
                }
            }
        }