Example #1
0
 public void ControllByButtons(Button buttons, Button accelerometer)
 {
     Settings.FlightSettings.droneControlMode = false;
     buttons.BackgroundColor       = Color.YellowGreen;
     accelerometer.BackgroundColor = Color.LightGray;
     Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.BUTTONS));
 }
Example #2
0
 public void ControllByAccelerometer(Button buttons, Button accelerometer)
 {
     Settings.FlightSettings.droneControlMode = true;
     buttons.BackgroundColor       = Color.LightGray;
     accelerometer.BackgroundColor = Color.YellowGreen;
     Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.ACCELEROMETER));
 }
        public void EnableCamera(Button cameraEnabled, Button startRecording, Button startStreaming)
        {
            if (Settings.CameraSettings.isCameraEnabled)
            {
                Settings.CameraSettings.isCameraEnabled     = false;
                Settings.CameraSettings.hasRecordingStarted = false;
                Settings.CameraSettings.hasStreamingStarted = false;
                cameraEnabled.BackgroundColor  = Color.LightGray;
                startRecording.BackgroundColor = Color.LightGray;
                startStreaming.BackgroundColor = Color.LightGray;

                Task.Run(() => GlobalSocket.SendCommand(Commands.Camera.DISABLE_CAMERA));

                pageService.DisplayAlert("Camera disabled.", null, "Ok");
            }
            else
            {
                Settings.CameraSettings.isCameraEnabled = true;
                cameraEnabled.BackgroundColor           = Color.YellowGreen;

                Task.Run(() => GlobalSocket.SendCommand(Commands.Camera.ENABLE_CAMERA));

                pageService.DisplayAlert("Camera enabled.", null, "Ok");
            }
        }
        private void StartStreaming(Button button)
        {
            if (Settings.CameraSettings.isCameraEnabled && Settings.CameraSettings.hasRecordingStarted)
            {
                if (Settings.CameraSettings.hasStreamingStarted)
                {
                    Settings.CameraSettings.hasStreamingStarted = false;
                    button.BackgroundColor = Color.LightGray;

                    Task.Run(() => GlobalSocket.SendCommand(Commands.Camera.STOP_STREAMING));

                    pageService.DisplayAlert("Recording has been stopped!", null, "Ok");
                }
                else
                {
                    Settings.CameraSettings.hasStreamingStarted = true;
                    button.BackgroundColor = Color.YellowGreen;

                    Task.Run(() => GlobalSocket.SendCommand(Commands.Camera.START_STREAMING));

                    pageService.DisplayAlert("Streaming has started!", null, "Ok");
                }
            }
            else
            {
                pageService.DisplayAlert("Camera or recording is disabled.", null, "Cancel");
            }
        }
        private async void Disconnect()
        {
            await Task.Run(() => GlobalSocket.SendCommand(Commands.Disconnect.DISCONNECT));

            GlobalSocket.client.Shutdown(SocketShutdown.Both);
            GlobalSocket.client.Disconnect(true);


            if (!GlobalSocket.client.Connected)
            {
                DisableAccelerometer();
                await pageService.DisplayAlert("Disconnected", null, "ok");

                await pageService.PopAsync();
            }
        }
        private void Accelerometer_ReadingChanged(object sender, AccelerometerChangedEventArgs e)
        {
            AccX = (float)Math.Round(e.Reading.Acceleration.X, 2);
            AccY = (float)Math.Round(e.Reading.Acceleration.Y, 2);
            AccZ = (float)Math.Round(e.Reading.Acceleration.Z, 2);

            if (AccY > 0.40)
            {
                currentCommand = Commands.Flight.FLY_RIGHT;
            }
            else if (AccY < -0.40)
            {
                currentCommand = Commands.Flight.FLY_LEFT;
            }
            else if ((AccY <= 0.40) && (AccY >= -0.40))
            {
                currentCommand = Commands.Flight.NONE;
            }

            if (AccX > 0.90)
            {
                currentCommand = Commands.Flight.BACKWARD;
            }
            else if (AccX < 0.10)
            {
                currentCommand = Commands.Flight.FORWARD;
            }
            else if ((AccX <= 0.20) && (AccX >= 0.70))
            {
                currentCommand = Commands.Flight.NONE;
            }

            if (previousCommand != currentCommand)
            {
                GlobalSocket.SendCommand(currentCommand);
                Debug.WriteLine(currentCommand);
            }

            previousCommand = currentCommand;

            for (int i = 0; i < 200000; i++)
            {
                ;
            }
        }
 private async void RoundRight() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.TURN_RIGHT));
 private async void TakeAPicture() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Camera.TAKE_A_PHOTO));
 private async void FlyRight() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.FLY_RIGHT));
 private async void Land() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.LAND));
 private async void Backward() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.BACKWARD));
 private async void Forward() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.FORWARD));
 private async void GetUp() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.GET_UP));
 private async void FlyLeft() => await Task.Run(() => GlobalSocket.SendCommand(Commands.Flight.FLY_LEFT));
 private async void SendLastPicture() => await Task.Run(() =>
 {
     GlobalSocket.SendCommand(Commands.Camera.SEND_LAST_PICTURE);
     JPGPicture.ImagesString.Add(GlobalSocket.ReceivePicture());
 });