private void CommandReceiverOnCommandReceived(object sender, CommandEventArgs eventArgs)
{
switch (eventArgs.Command)
{
case "takeoff":
_client.Takeoff();
break;
case "land":
_client.Land();
break;
case "hover":
_client.Hover();
break;
case "up":
_client.Progress(FlightMode.Progressive, gaz: 0.25f);
break;
case "turnleft":
_client.Progress(FlightMode.Progressive, yaw: 0.25f);
break;
case "forward":
_client.Progress(FlightMode.Progressive, pitch: -0.05f);
break;
case "turnright":
_client.Progress(FlightMode.Progressive, yaw: -0.25f);
break;
case "down":
_client.Progress(FlightMode.Progressive, gaz: -0.25f);
break;
case "lLeft":
_client.Progress(FlightMode.Progressive, yaw: 0.25f);
break;
case "right":
_client.Progress(FlightMode.Progressive, roll: 0.05f);
break;
case "back":
_client.Progress(FlightMode.Progressive, pitch: 0.05f);
break;
default:
Debug.WriteLine("Unknown Command: " + eventArgs.Command);
break;
}
}
private void Joystick_InputReceived(object sender, JoystickEventArgs e)
{
if (e.Button == 0 && e.IsPressed) // Front button
{
drone.Hover();
}
else if (e.Button == 1 && e.IsPressed) // Pad-2 button
{
drone.Emergency();
}
else if (e.Button == 2 && e.IsPressed) // Pad-3 button
{
drone.Takeoff();
}
else if (e.Button == 4 && e.IsPressed) // Pad-5 button
{
drone.Land();
}
else if (e.Button == 9 && e.IsPressed) // Throttle-10 button
{
heightMaintainer.TargetHeight += 0.25f; // meter
}
else if (e.Button == 10 && e.IsPressed) // Throttle-11 button
{
heightMaintainer.TargetHeight -= 0.25f; // meter
}
}
static void Main(string[] args)
{
var droneClient = new DroneClient("192.168.1.1");
SleepAndPaint(droneClient);
droneClient.Start();
SleepAndPaint(droneClient);
droneClient.Takeoff();
SleepAndPaint(droneClient);
droneClient.Progress(FlightMode.Progressive, yaw: -0.05f);
System.Console.WriteLine("Yaw -0.05");
SleepAndPaint(droneClient);
droneClient.Hover();
SleepAndPaint(droneClient);
droneClient.Land();
SleepAndPaint(droneClient);
droneClient.Stop();
SleepAndPaint(droneClient);
System.Console.ReadLine();
droneClient.Dispose();
}
/// <summary>--
/// This method will takeoff the drone.
/// The parameter time is the Threading time for wait.
/// </summary>
/// <param name="time"></param>
public void Takeoff(int time = 15000)
{
Console.WriteLine("Takeoff");
_droneClient.Takeoff();
System.Threading.Thread.Sleep(time);
setNorth();
}
private void DroneTakeOff()
{
droneClient.FlatTrim();//before take off send this command
headPositionStart = OculusClient.GetOrientation();
if (lastCommandSent != CommandType.TakeOff)
{
droneClient.Takeoff();
lastCommandSent = CommandType.TakeOff;
}
}
/// <summary>
/// Take off mechanism
/// </summary>
/// <returns>Boolean Value whether the command works properly</returns>
public bool TakeOff()
{
try
{
_client.Takeoff();
return(true);
}
catch (Exception)
{
return(false);
}
}
private void DroneControls_KeyDown(object sender, KeyEventArgs e)
{
System.Diagnostics.Debug.WriteLine(e.Key);
switch (e.Key)
{
case Key.Left:
droneClient.Progress(FlightMode.Progressive, roll: -0.05f);
break;
case Key.Up:
droneClient.Progress(FlightMode.Progressive, gaz: 0.25f);
break;
case Key.Right:
droneClient.Progress(FlightMode.Progressive, roll: 0.05f);
break;
case Key.Down:
droneClient.Progress(FlightMode.Progressive, gaz: -0.25f);
break;
case Key.A:
droneClient.Progress(FlightMode.Progressive, yaw: 0.25f);
break;
case Key.D:
droneClient.Progress(FlightMode.Progressive, yaw: -0.25f);
break;
case Key.S:
droneClient.Progress(FlightMode.Progressive, pitch: 0.05f);
break;
case Key.W:
droneClient.Progress(FlightMode.Progressive, pitch: -0.05f);
break;
case Key.I:
droneClient.Takeoff();
break;
case Key.O:
droneClient.Land();
break;
default:
break;
}
}
/// <summary>
/// Sends the command with its parameters to a provided DroneClient
/// </summary>
/// <param name="aDroneClient">Drone client to the the command to</param>
public void Send(DroneClient aDroneClient)
{
switch (Command)
{
case Type.Progress: aDroneClient.Progress(ProgressMode, roll: Roll, pitch: Pitch, yaw: Yaw, gaz: Gaz); break;
case Type.Takeoff: aDroneClient.Takeoff(); break;
case Type.Hover: aDroneClient.Hover(); break;
case Type.Land: aDroneClient.Land(); break;
case Type.Emergency: aDroneClient.Emergency(); break;
case Type.ResetEmergency: aDroneClient.ResetEmergency(); break;
case Type.FlatTrim: aDroneClient.FlatTrim(); break;
}
}
void GestureDetection_LeftHandUpDownChanged(object sender, HandPositionChangedArgs args)
{
switch (args.Position)
{
case HandPosition.Up:
_client.Takeoff();
DroneCommandChanged(_client, new DroneCommandChangedEventArgs {
CommandText = "Taking Off"
});
break;
case HandPosition.Center:
break;
case HandPosition.Down:
_client.Land();
DroneCommandChanged(_client, new DroneCommandChangedEventArgs {
CommandText = "Landing"
});
break;
}
}
// Update is called once per frame
void Update()
{
convertCameraData();
updateGamepadState();
moveStick();
// Start or land the drone
if (state.Buttons.Start.Equals(ButtonState.Pressed) && !startButtonPressed)
{
if (isLanded)
{
droneClient.Takeoff();
}
else
{
droneClient.Land();
}
isLanded = !isLanded;
startButtonPressed = true;
}
if (!state.Buttons.Start.Equals(ButtonState.Pressed))
{
startButtonPressed = false;
}
// exit application
if (Input.GetKey("escape") || state.Buttons.Back.Equals(ButtonState.Pressed))
{
Application.Quit();
}
// Move the drone
var pitch = -state.ThumbSticks.Left.Y;
var roll = state.ThumbSticks.Left.X;
var gaz = state.Triggers.Right - state.Triggers.Left;
var yaw = state.ThumbSticks.Right.X;
droneClient.Progress(AR.Drone.Client.Command.FlightMode.Progressive, pitch: pitch, roll: roll, gaz: gaz, yaw: yaw);
// Switch drone camera
if (CameraForSwitchCheck.rotation.x >= SwitchRotation)
{
if (SecondaryRenderer.material.mainTexture != cameraTexture)
{
MainRenderer.material.mainTexture = blackTexture;
SecondaryRenderer.material.mainTexture = cameraTexture;
switchDroneCamera(AR.Drone.Client.Configuration.VideoChannelType.Vertical);
}
}
else
{
if (MainRenderer.material.mainTexture != cameraTexture)
{
SecondaryRenderer.material.mainTexture = blackTexture;
MainRenderer.material.mainTexture = cameraTexture;
switchDroneCamera(AR.Drone.Client.Configuration.VideoChannelType.Horizontal);
}
}
// set status text
if (navigationData != null)
{
StatusText.text = string.Format("Battery: {0} % \nYaw: {1:f} \nPitch: {2:f} \nRoll: {3:f} \nAltitude: {4} m",
navigationData.Battery.Percentage, navigationData.Yaw, navigationData.Pitch,
navigationData.Roll, navigationData.Altitude);
}
// determine wifi strength
determineWifiStrength();
}
private void button2_Click(object sender, EventArgs e)
{
_droneClient.Takeoff();
}
public void TakeOff()
{
_client.Takeoff();
}
public void Takeoff()
{
_droneClient.Takeoff();
}
public void Start()
{
droneClient.Start();
droneClient.Takeoff();
}
void DroneControl(object sender)
{
int expiration = Properties.Settings.Default.AutoPilotExpiration;
bool useQ = Properties.Settings.Default.UseAutoPilot;
_autopilot.Active = useQ;
float _lrfb = Properties.Settings.Default.DefaultLRFBSpeed;
float _yaw = Properties.Settings.Default.DefaultYawSpeed;
float _gaz = Properties.Settings.Default.DefaultGazSpeed;
#region // engine
if (sender == "v")
{
_droneClient.FlatTrim();
_autopilot.ClearObjectives();
_droneClient.Takeoff();
}
;
if (sender == "n")
{
_autopilot.ClearObjectives();
_droneClient.Emergency();
}
;
if (sender == "m")
{
_droneClient.ResetEmergency();
}
;
if (sender == "b")
{
_autopilot.ClearObjectives();
_droneClient.Land();
}
;
#endregion
_autopilot.Active = true;
// navigation
#region left right up down and hover
//if (sender == btnLeft || sender == btnRight)
//{
// if (useQ)
// {
// _autopilot.EnqueueObjective(Objective.Create(expiration, new SetRoll(
// (sender == btnLeft ? -_lrfb : _lrfb)
// )));
// }
// else
// {
// _droneClient.Progress(FlightMode.Progressive,
// roll: (sender == btnLeft ? -_lrfb : _lrfb)
// );
// }
//}
if (sender == "a")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetRoll(-_lrfb)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, roll: -_lrfb);
}
}
;
if (sender == "d")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetRoll(_lrfb)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, roll: _lrfb);
}
}
;
if (sender == "w")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetPitch(-_lrfb)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, pitch: -_lrfb);
}
}
;
if (sender == "s")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetPitch(_lrfb)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, pitch: _lrfb);
}
}
;
if (sender == "x")
{
if (useQ)
{
_autopilot.EnqueueObjective(
Objective.Create(expiration,
new VelocityX(0.0f),
new VelocityY(0.0f),
new Altitude(1.0f)
));
}
else
{
_droneClient.Hover();
}
}
#endregion
#region yaw left and right
if (sender == "j")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetYaw(-_yaw)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, yaw: -_yaw);
}
}
;
if (sender == "l")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetYaw(_yaw)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, yaw: _yaw);
}
}
;
#endregion
#region gaz up and down
if (sender == "i")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetGaz(_gaz)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, gaz: _gaz);
}
//_droneClient.Hover();
}
;
if (sender == "k")
{
if (useQ)
{
_autopilot.EnqueueObjective(Objective.Create(expiration, new SetGaz(-_gaz)));
}
else
{
_droneClient.Progress(FlightMode.Progressive, gaz: -_gaz);
}
}
;
#endregion
}
static void FlyDroneBuffer(string heightEvtType)
{
ConnectBufferBCI();
bool flying = false;
bool running = true;
float targetHeight = 1, targetVelocity = 2;
float maxHeight = 3, minHeight = 0.1f;
float gaz, roll, pitch, yaw;
gaz = roll = pitch = yaw = 0;
// Thread to read events from the buffer.
new Thread(
() =>
{
while (running)
{
var sec = bci_client.WaitForEvents(lastEvent, 5000);
if (sec.NumEvents > lastEvent)
{
var events = bci_client.GetEvents(lastEvent, sec.NumEvents - 1);
lastEvent = sec.NumEvents;
foreach (var evt in events)
{
string evttype = evt.Type.ToString();
Console.WriteLine("{0}: {1}", evttype, evt.Value);
// BCI event type.
if (evttype == heightEvtType)
{
var val = double.Parse(evt.Value.ToString());
if (val > 0 && targetHeight < maxHeight)
{
targetHeight += 0.1f;
}
else if (val < 0 && targetHeight < minHeight)
{
targetHeight -= 0.1f;
}
}
// Joystick
else if (evttype == "joystick")
{
var raw_val = evt.Value.ToString();
if (raw_val == "Button0")
{
if (flying)
{
drone.Land();
}
else
{
drone.Takeoff();
}
flying = !flying;
}
}
// exit
else if (evttype == "exit")
{
running = false;
}
}
}
}
}
).Start();
// Event handler (probably called from another thread) to receive navigation data from the drone.
drone.NavigationDataAcquired +=
navData =>
{
// Correction for height.
if (navData.Altitude < targetHeight - 0.1)
{
gaz = Math.Min(targetHeight - drone.NavigationData.Altitude, 1.0f);
}
else if (navData.Altitude > targetHeight + 0.1)
{
gaz = -Math.Min(drone.NavigationData.Altitude - targetHeight, 1.0f);
}
else
{
gaz = 0;
}
// Correction for velocity.
if (navData.Velocity.X > targetVelocity + 0.5)
{
pitch = navData.Pitch - 0.025f;
}
else if (navData.Velocity.X < targetHeight - 0.5)
{
pitch = navData.Pitch + 0.025f;
}
else
{
pitch = navData.Pitch;
}
};
// Infinite loop to send data to the drone.
while (running)
{
if (flying)
{
drone.Progress(FlightMode.Hover, roll, pitch, yaw, gaz);
}
Thread.Sleep(250);
}
// Land when done, if required.
if (flying)
{
drone.Land();
}
}
void flyToObjective()
{
if (calculator == null)
{
calculator = new ControllerCalculations(analyzer.FovSize);
}
bool flight = true;
var state = droneClient.NavigationData.State;
if (state.HasFlag(NavigationState.Emergency))
{
return;
}
if (flight && state.HasFlag(NavigationState.Landed))
{
analyzer.ResultingCommand = "takeof";
analyzer.Navigation.SetMovement(Movements.TakeOff);
droneClient.Takeoff();
return;
}
if (analyzer.Detected)
{
if (droneClient.NavigationData.Altitude > 0.6 || !flight)
{
var width = analyzer.FovSize.Width / 2f;
var change = width - analyzer.Center.X;
var distance = calculator.GetDistance(new System.Drawing.Size(analyzer.Width, analyzer.Height));
analyzer.Distance = distance;
analyzer.Change = change;
var diff = calculator.GetDiff(distance); // (analyzer.Distance / analyzer.FovSize.Width) * 7.5f;
var yaw = config.SpaceConfig.TurnSpeed * 2f / 3f;
var roll = config.SpaceConfig.TurnSpeed / 3f;
if (change > diff)
{
if (flight)
{
droneClient.Progress(FlightMode.Progressive, roll: 0 - roll, yaw: 0 - yaw);
}
analyzer.ResultingCommand = $"left {change} {diff}";
analyzer.Navigation.SetMovement(Movements.Left);
}
else if (change < (0 - diff))
{
if (flight)
{
droneClient.Progress(FlightMode.Progressive, roll: roll, yaw: yaw);
}
analyzer.ResultingCommand = $"right {change} {diff}";
analyzer.Navigation.SetMovement(Movements.Right);
}
else
{
if (distance > config.SpaceConfig.MaxDistance)
{
analyzer.ResultingCommand = $"pitch {change}";
analyzer.Navigation.SetMovement(Movements.Ahead);
if (flight)
{
droneClient.Progress(FlightMode.Progressive, pitch: -0.05f);
}
}
else
{
analyzer.ResultingCommand = "hover";
analyzer.Navigation.SetMovement(Movements.Hover);
step = 1;
Logger.LogInfo("Step 1");
}
}
}
else
{
analyzer.Navigation.SetMovement(Movements.Up);
droneClient.Progress(FlightMode.Progressive, gaz: 0.25f);
analyzer.ResultingCommand = $"altitude {droneClient.NavigationData.Altitude}";
}
}
else
{
analyzer.ResultingCommand = "seek";
if (flight)
{
droneClient.Progress(FlightMode.Progressive, yaw: 0.10f);
}
}
}
