static void Main(string[] args)
{
uint zano;
Library.Initialise("Example-GetAltitude.1.0.0");
zano = Library.Obtain("192.168.0.1", 10001);
bool isConnected = false;
Frame frame = new Frame();
Library.Connect(zano);
while (true)
{
if (isConnected)
{
Frames.FlightAltitudeGet(zano);
}
Library.Tick();
while (Library.Receive(ref frame) == 1)
{
switch (frame.Reference)
{
case Symbols.kFlightAltitudeGet:
{
int altitude = frame.Get(Symbols.kAltitude);
Console.WriteLine(String.Format("Altitude is {0} mm", altitude));
}
break;
}
}
Library.Status status;
while ((status = Library.GetStatus()) != Library.Status.None)
{
switch (status)
{
case Library.Status.DeviceDisconnectionDisconnected:
case Library.Status.DeviceConnectionNotConnected:
case Library.Status.DeviceConnectionHeldStill:
{
isConnected = false;
Library.Connect(zano);
}
break;
case Library.Status.DeviceConnectionConnected:
{
isConnected = true;
}
break;
}
}
Thread.Sleep(10);
}
}
static void Main(string[] args)
{
uint zano;
Library.Initialise("Example-ConnectAndIdle.1.0.0");
zano = Library.Obtain("192.168.0.1", 10001);
bool isConnected = false;
Frame frame = new Frame();
Library.Connect(zano);
while (true)
{
Library.Tick();
while (Library.Receive(ref frame) == 1)
{
// ...
}
Library.Status status;
while ((status = Library.GetStatus()) != Library.Status.None)
{
switch (status)
{
case Library.Status.DeviceDisconnectionDisconnected:
case Library.Status.DeviceConnectionNotConnected:
case Library.Status.DeviceConnectionHeldStill:
{
isConnected = false;
Library.Connect(zano);
}
break;
case Library.Status.DeviceConnectionConnected:
{
isConnected = true;
}
break;
}
}
Thread.Sleep(10);
}
}
private Accelerometer()
{
OnTrigger("NULL.started", args =>
{
U.LoadRecordings();
V.Navigate("$Start");
/*
if (Z.IsConnected)
{
Move("connect");
Move("start");
}
else
{
Trigger("connect");
}*/
});
OnTrigger("NULL.start_new", args =>
{
for (int i = 0; i < 6; i++)
{
G.FilteredReadings[i] = 0;
G.FilteredComplete[i] = false;
G.FilteredValue[i] = 0;
}
});
OnTrigger("NULL.apply_new", args =>
{
G.SaveRecording = true;
Trigger("connect");
});
OnTrigger("NULL.apply_recording", args =>
{
if (args.Length != 0 && args[0] is AccelerometerRecording)
{
var recording = (AccelerometerRecording) args[0];
G.FilteredReadings[0] = K.MinReadings;
G.FilteredValue[0] = recording.Filtered0;
G.FilteredComplete[0] = true;
G.FilteredReadings[1] = K.MinReadings;
G.FilteredValue[1] = recording.Filtered1;
G.FilteredComplete[1] = true;
G.FilteredReadings[2] = K.MinReadings;
G.FilteredValue[2] = recording.Filtered2;
G.FilteredComplete[2] = true;
G.FilteredReadings[3] = K.MinReadings;
G.FilteredValue[3] = recording.Filtered3;
G.FilteredComplete[3] = true;
G.FilteredReadings[4] = K.MinReadings;
G.FilteredValue[4] = recording.Filtered4;
G.FilteredComplete[4] = true;
G.FilteredReadings[5] = K.MinReadings;
G.FilteredValue[5] = recording.Filtered5;
G.FilteredComplete[5] = true;
G.SaveRecording = false;
Trigger("connect", recording.SerialNumber);
}
});
OnTrigger("NULL.connect", args =>
{
if (Z.IsConnected == false)
{
A.Trigger("connect", args);
Move("connect");
}
else
{
Move("connect");
Trigger("connected");
}
});
OnTrigger("connect.connected", args =>
{
bool completeSet = true;
for (int i = 0; i < 6; i++)
{
if (G.FilteredComplete[i] == false)
{
completeSet = false;
}
}
if (completeSet)
{
Move("axis");
Trigger("save");
}
else
{
Move("wait_start");
}
});
OnMove("connect>wait_start", args =>
{
// Clear
G.DidSave = false;
for (int i = 0; i < 6; i++)
{
G.FilteredReadings[i] = 0;
G.FilteredComplete[i] = false;
G.FilteredValue[i] = 0;
}
V.Navigate("$Accelerometer");
});
OnTrigger("wait_start.start", args =>
{
Move("start");
});
OnMove("wait_start>start", args =>
{
// Get ZanoHandler to send gyros and raw acceleration frames this way.
Z.Listen(Symbols.kSensorsGyroGet, "receive_gyro");
Z.Listen(Symbols.kSensorsRawAccelerationGet, "receive_accelerometer");
Views.Accelerometer.Instance.Begin();
Move("axis");
});
OnTrigger("axis.retry", args =>
{
G.DidSave = false;
for (int i = 0; i < 6; i++)
{
G.FilteredReadings[i] = 0;
G.FilteredComplete[i] = false;
G.FilteredValue[i] = 0;
}
});
OnTrigger("axis.save, save.not_sent, connect.save", args =>
{
// Compile the readings into maximum and minimum readings
G.ResultsXMin = U.MinToShort(G.FilteredValue[U.AxisToIndex(1, 0, 0)], G.FilteredValue[U.AxisToIndex(-1, 0, 0)]);
G.ResultsXMax = U.MaxToShort(G.FilteredValue[U.AxisToIndex(1, 0, 0)], G.FilteredValue[U.AxisToIndex(-1, 0, 0)]);
G.ResultsYMin = U.MinToShort(G.FilteredValue[U.AxisToIndex(0, 1, 0)], G.FilteredValue[U.AxisToIndex(0, -1, 0)]);
G.ResultsYMax = U.MaxToShort(G.FilteredValue[U.AxisToIndex(0, 1, 0)], G.FilteredValue[U.AxisToIndex(0, -1, 0)]);
G.ResultsZMin = U.MinToShort(G.FilteredValue[U.AxisToIndex(0, 0, 1)], G.FilteredValue[U.AxisToIndex(0, 0, -1)]);
G.ResultsZMax = U.MaxToShort(G.FilteredValue[U.AxisToIndex(0, 0, 1)], G.FilteredValue[U.AxisToIndex(0, 0, -1)]);
G.ResultsXAvg = (short)(-1 * ((G.ResultsXMin + G.ResultsXMax) / 2));
G.ResultsYAvg = (short)(-1 * ((G.ResultsYMin + G.ResultsYMax) / 2));
G.ResultsZAvg = (short)(-1 * ((G.ResultsZMin + G.ResultsZMax) / 2));
// Copied from ConfigAccelOffsetSet
Frame sendFrame = new Frame(Z.Handle);
sendFrame.Reference = Symbols.kConfigAccelOffsetSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kX;
sendFrame.Values[0] = (int)G.ResultsXAvg;
sendFrame.Names[1] = Symbols.kY;
sendFrame.Values[1] = (int)G.ResultsYAvg;
sendFrame.Names[2] = Symbols.kZ;
sendFrame.Values[2] = (int)G.ResultsZAvg;
sendFrame.Names[3] = Symbols.kXmin;
sendFrame.Values[3] = (int)G.ResultsXMin;
sendFrame.Names[4] = Symbols.kYmin;
sendFrame.Values[4] = (int)G.ResultsYMin;
sendFrame.Names[5] = Symbols.kZmin;
sendFrame.Values[5] = (int)G.ResultsZMin;
sendFrame.Names[6] = Symbols.kXmax;
sendFrame.Values[6] = (int)G.ResultsXMax;
sendFrame.Names[7] = Symbols.kYmax;
sendFrame.Values[7] = (int)G.ResultsYMax;
sendFrame.Names[8] = Symbols.kZmax;
sendFrame.Values[8] = (int)G.ResultsZMax;
}
LibZano.Calibration.Set(ref Z.SerialNumber, ref sendFrame);
Library.Send(ref sendFrame);
Frames.ConfigSave(Z.Handle);
StringBuilder sn = new StringBuilder(16);
Library.SerialNumber serialNb = new Library.SerialNumber();
Library.GetSerialNumber(Z.Handle, ref serialNb);
for (int i = 0; i < 8; i++)
{
sn.AppendFormat("{0:x2}", serialNb.Part[i]);
}
G.ResultsSerial = sn.ToString();
StringBuilder sb = new StringBuilder();
sb.Append(G.ResultsSerial);
sb.AppendFormat(" {0:X8} 09", Symbols.kConfigAccelOffsetSet);
sb.AppendFormat(" {0:X8} {1}", Symbols.kX, U.FormatShort(G.ResultsXAvg));
sb.AppendFormat(" {0:X8} {1}", Symbols.kY, U.FormatShort(G.ResultsYAvg));
sb.AppendFormat(" {0:X8} {1}", Symbols.kZ, U.FormatShort(G.ResultsZAvg));
sb.AppendFormat(" {0:X8} {1}", Symbols.kXmin, U.FormatShort(G.ResultsXMin));
sb.AppendFormat(" {0:X8} {1}", Symbols.kYmin, U.FormatShort(G.ResultsYMin));
sb.AppendFormat(" {0:X8} {1}", Symbols.kZmin, U.FormatShort(G.ResultsZMin));
sb.AppendFormat(" {0:X8} {1}", Symbols.kXmax, U.FormatShort(G.ResultsXMax));
sb.AppendFormat(" {0:X8} {1}", Symbols.kYmax, U.FormatShort(G.ResultsYMax));
sb.AppendFormat(" {0:X8} {1}", Symbols.kZmax, U.FormatShort(G.ResultsZMax));
Console.WriteLine(sb.ToString());
File.WriteAllText(Core.U.GetApplicationDataPath() + "last_accel_results.txt", sb.ToString());
if (G.SaveRecording)
{
AccelerometerRecording reading = new AccelerometerRecording();
reading.SerialNumber = Z.CopySerialNumber(serialNb);
G.HighestRecordingId++;
reading.Id = G.HighestRecordingId;
reading.Filtered0 = (int) G.FilteredValue[0];
reading.Filtered1 = (int) G.FilteredValue[1];
reading.Filtered2 = (int) G.FilteredValue[2];
reading.Filtered3 = (int) G.FilteredValue[3];
reading.Filtered4 = (int) G.FilteredValue[4];
reading.Filtered5 = (int) G.FilteredValue[5];
G.Recordings.Add(reading);
U.SaveRecordings();
}
G.ResultsValues = sb.ToString();
//StringBuilder fc = new StringBuilder();
//var now = DateTime.Now;
//fc.AppendFormat("{0} {1}{2}", now.ToLongDateString(), now.ToLongTimeString(), Environment.NewLine);
// fc.AppendFormat("{0}", sb.)
//fc.AppendLine(DateTime.Now.)
// The Zano will automatically reboot, so we should switch state and wait for the connected event which
// is handled by libZano.
Move("save_to_zano");
V.Navigate("$SaveToZano");
});
OnTrigger("save_to_zano.disconnected", args =>
{
Console.WriteLine("Probably Saved");
Move("save_to_server");
V.Navigate("$SaveToServer");
LibZano.ServerConnectivity.ForceRefresh();
});
OnTrigger("save_to_server.no_internet", args =>
{
Console.WriteLine("Checking for Internet");
LibZano.ServerConnectivity.ForceRefresh();
});
OnTrigger("save_to_server.configuration_downloaded", args =>
{
Console.WriteLine("Got for Internet");
if (G.DidSave == false)
{
G.DidSave = true;
Console.WriteLine("Saving to server...");
LibZano.Calibration.ApplyToServer(ref Z.SerialNumber, Symbols.kConfigAccelOffsetSet);
}
});
OnTrigger("save_to_server.config_server_save_complete", args =>
{
Console.WriteLine("Saved Config");
V.Navigate("$Complete");
});
OnTrigger("save_to_server.config_server_save_failed", args =>
{
Console.WriteLine("Not Saved Config");
});
OnTrigger("axis.tick", args =>
{
Frames.SensorsGyroGet(Z.Handle);
if (G.Recording)
{
Frames.SensorsRawAccelerationGet(Z.Handle);
}
});
OnTrigger("axis.receive_gyro", args =>
{
Frame frame = (Frame)args[0];
// Get the gyro vector and calculate the magnitude
double x = frame.Get(Symbols.kX);
double y = frame.Get(Symbols.kY);
double z = frame.Get(Symbols.kZ);
double mag = Math.Sqrt(x * x + y * y + z * z);
G.GyroMagnitude = mag;
Console.WriteLine("Gyro Mag = {0}", mag);
if (mag >= K.GyroMaxThreshold)
{
// If the magnitude is over the threshold stop asking for accelerometer
G.Recording = false;
G.RecordingTime = 0;
int lastAxis = U.AxisToIndex(G.LastAxisX, G.LastAxisY, G.LastAxisZ);
if (G.FilteredReadings[lastAxis] < K.MinReadings)
{
// Was the number of readings not finished? Then reset them
G.FilteredComplete[lastAxis] = false;
G.FilteredReadings[lastAxis] = 0;
G.FilteredValue[lastAxis] = 0;
}
}
else
{
// Underneath the current threshold
if (G.Recording == false)
{
// Not recording?
// Turn it on!
G.Recording = true;
G.RecordingTime = Library.Time();
G.RecordingStarted = true;
}
}
// Refresh the view
if (Views.Accelerometer.Instance != null)
{
Views.Accelerometer.Instance.Refresh();
}
});
OnTrigger("axis.receive_accelerometer", args =>
{
Frame frame = (Frame)args[0];
// Get raw accelerometer values
double x = frame.Get(Symbols.kX);
double y = frame.Get(Symbols.kY);
double z = frame.Get(Symbols.kZ);
int xDir = 0;
int yDir = 0;
int zDir = 0;
U.GetAxisGravityVector(x, y, z, ref xDir, ref yDir, ref zDir);
/*
// Console.WriteLine("{0} {1} {2}", x, y, z);
U.Normalise(ref x, ref y, ref z);
// Calculate the best axis that the Zano is pointing up as using
// three dot products against each of the unit vectors, from that
// you have a ~unit vector that is the best direction.
int xDir = U.DotToInt(x, y, z, 1, 0, 0);
int yDir = U.DotToInt(x, y, z, 0, 1, 0);
int zDir = U.DotToInt(x, y, z, 0, 0, 1);
*/
// Store old axis and copy new one over.
G.LastAxisX = G.AxisX;
G.LastAxisY = G.AxisY;
G.LastAxisZ = G.AxisZ;
G.AxisX = xDir;
G.AxisY = yDir;
G.AxisZ = zDir;
// Now on a different axis?
if (G.AxisX != G.LastAxisX || G.AxisY != G.LastAxisY || G.AxisZ != G.LastAxisZ)
{
int lastAxis = U.AxisToIndex(G.LastAxisX, G.LastAxisY, G.LastAxisZ);
if (G.FilteredReadings[lastAxis] >= K.MinReadings)
{
// Did all readings?
// Mark old axis as complete
G.FilteredComplete[lastAxis] = true;
}
else
{
// Didn't complete.?
// Reset readings and value, so they can be done again.
G.FilteredReadings[lastAxis] = 0;
G.FilteredComplete[lastAxis] = false;
G.FilteredValue[lastAxis] = 0;
}
// Say something
Console.WriteLine("Changed Axis from {0} to {1}", U.AxisToString(G.LastAxisX, G.LastAxisY, G.LastAxisZ), U.AxisToString(G.AxisX, G.AxisY, G.AxisZ));
}
int axisIndex = U.AxisToIndex(G.AxisX, G.AxisY, G.AxisZ);
// Read and perform a low pass if the number of readings of the current axis
// has not been met yet.
if (G.FilteredReadings[axisIndex] < K.MinReadings)
{
// Set Initial Value, which is +-4096 (based on axis) where 4096 is 1G.
// Ideally the accelerometer would be +-4096 but due to manufacturing this
// can vary, hence the need for calibration!
if (G.RecordingStarted)
{
G.RecordingStarted = false;
G.FilteredValue[axisIndex] = K.LowPassDefaultFilter * U.AxisSign(G.AxisX, G.AxisY, G.AxisZ);
}
// Perform a low pass filter on the value and store.
double filtered = G.FilteredValue[axisIndex];
double now = frame.Get(U.AxisToSymbol(G.AxisX, G.AxisY, G.AxisZ));
G.FilteredValue[axisIndex] = U.LowPass(filtered, now, K.LowPassD);
G.FilteredReadings[axisIndex]++;
}
// Exceeded reading count? Then it's complete
if (G.FilteredReadings[axisIndex] >= K.MinReadings)
{
G.FilteredComplete[axisIndex] = true;
}
// Update the view
// V.RefreshAccelerometerDisplay();
if (Views.Accelerometer.Instance != null)
{
Views.Accelerometer.Instance.Refresh();
}
});
OnTrigger("save_to_server.menu", args =>
{
Move("NULL");
T.Set("NULL");
});
}
///<command>
/// <name>camera.resolution.set</name>
/// <symbol>kCameraResolutionSet</symbol>
/// <scope>camera.resolution</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kResolution">Resolution</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kResult">Result</response>
/// </responses>
/// <see>camera.resolution.get</see>
///</command>
public static void CameraResolutionSet(uint handle, byte resolution)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraResolutionSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kResolution;
sendFrame.Values[0] = (int) resolution;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.imageprocessing.sharpness.get</name>
/// <symbol>kCameraImageprocessingSharpnessGet</symbol>
/// <scope>camera.imageprocessing.sharpness</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kValue">Value</response>
/// </responses>
/// <see>camera.imageprocessing.sharpness.set</see>
///</command>
public static void CameraImageprocessingSharpnessGet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraImageprocessingSharpnessGet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.contrast.set</name>
/// <symbol>kCameraContrastSet</symbol>
/// <scope>camera.contrast</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kContrast">Contrast</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kResult">Result</response>
/// </responses>
/// <see>camera.contrast.get</see>
///</command>
public static void CameraContrastSet(uint handle, byte contrast)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraContrastSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kContrast;
sendFrame.Values[0] = (int) contrast;
}
Library.Send(ref sendFrame);
}
public static extern int TrackedSendFrame2(ref Frame frame1, ref Frame frame2, byte userData, uint maxCount, uint resendTime);
public static extern int Receive(ref Frame frame);
///<command>
/// <name>system.expansion.byte.set</name>
/// <symbol>kSystemExpansionByteSet</symbol>
/// <scope>system.expansion.byte</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kLength">Length</arg>
/// </arguments>
/// <see>system.expansion.byte.get</see>
///</command>
public static void SystemExpansionByteSet(uint handle, byte length)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemExpansionByteSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kLength;
sendFrame.Values[0] = (int) length;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>system.calibratecompass.set</name>
/// <symbol>kSystemCalibratecompassSet</symbol>
/// <scope>system.calibratecompass</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
///</command>
public static void SystemCalibratecompassSet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemCalibratecompassSet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>system.bandwidth.set</name>
/// <symbol>kSystemBandwidthSet</symbol>
/// <scope>system.bandwidth</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="ushort" symbol="kValue">Value</arg>
/// </arguments>
/// <see>system.bandwidth.get</see>
///</command>
public static void SystemBandwidthSet(uint handle, ushort value)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemBandwidthSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kValue;
sendFrame.Values[0] = (int) value;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>sensors.temperature.get</name>
/// <symbol>kSensorsTemperatureGet</symbol>
/// <scope>sensors.temperature</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="short" symbol="kTemperature">Temperature</response>
/// </responses>
///</command>
public static void SensorsTemperatureGet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSensorsTemperatureGet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>messages.get</name>
/// <symbol>kMessagesGet</symbol>
/// <scope>messages</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kIndex">Index</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kIndex">Index</response>
/// <response type="byte" symbol="kCount">Count</response>
/// <response type="ushort" symbol="kLength">Length</response>
/// </responses>
///</command>
public static void MessagesGet(uint handle, byte index)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kMessagesGet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kIndex;
sendFrame.Values[0] = (int) index;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>media.recv</name>
/// <symbol>kMediaRecv</symbol>
/// <scope>media</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="ushort" symbol="kType">Type</response>
/// <response type="uint" symbol="kTime">Time</response>
/// <response type="uint" symbol="kFrame">Frame</response>
/// <response type="uint" symbol="kLength">Length</response>
/// <response type="uint" symbol="kOffset">Offset</response>
/// <response type="ushort" symbol="kFragmentSize">FragmentSize</response>
/// </responses>
/// <see>media.get</see>
///</command>
public static void MediaRecv(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kMediaRecv;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>media.get</name>
/// <symbol>kMediaGet</symbol>
/// <scope>media</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="ushort" symbol="kType">Type</arg>
/// <arg type="uint" symbol="kFrame">Frame</arg>
/// </arguments>
/// <see>media.recv</see>
///</command>
public static void MediaGet(uint handle, ushort type, uint frame)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kMediaGet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kType;
sendFrame.Values[0] = (int) type;
sendFrame.Names[1] = Symbols.kFrame;
sendFrame.Values[1] = (int) frame;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>waypoint.stop</name>
/// <symbol>kWaypointStop</symbol>
/// <scope>waypoint</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <see>waypoint.add</see>
/// <see>waypoint.get</see>
/// <see>waypoint.mode</see>
/// <see>waypoint.pause</see>
/// <see>waypoint.set</see>
/// <see>waypoint.start</see>
///</command>
public static void WaypointStop(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kWaypointStop;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.bandingfilter.set</name>
/// <symbol>kCameraBandingfilterSet</symbol>
/// <scope>camera.bandingfilter</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kFilter">Filter</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kResult">Result</response>
/// </responses>
/// <see>camera.bandingfilter.get</see>
///</command>
public static void CameraBandingfilterSet(uint handle, byte filter)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraBandingfilterSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kFilter;
sendFrame.Values[0] = (int) filter;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.agc.exposure.weight.get</name>
/// <symbol>kCameraAgcExposureWeightGet</symbol>
/// <scope>camera.agc.exposure.weight</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kValue">Value</response>
/// </responses>
/// <see>camera.agc.exposure.weight.set</see>
///</command>
public static void CameraAgcExposureWeightGet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraAgcExposureWeightGet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
public static extern int Send(ref Frame frame);
///<command>
/// <name>system.expansion.config.set</name>
/// <symbol>kSystemExpansionConfigSet</symbol>
/// <scope>system.expansion.config</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kSpeed">Speed</arg>
/// </arguments>
///</command>
public static void SystemExpansionConfigSet(uint handle, byte speed)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemExpansionConfigSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kSpeed;
sendFrame.Values[0] = (int) speed;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.brightness.set</name>
/// <symbol>kCameraBrightnessSet</symbol>
/// <scope>camera.brightness</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kBrightness">Brightness</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kResult">Result</response>
/// </responses>
/// <see>camera.brightness.get</see>
///</command>
public static void CameraBrightnessSet(uint handle, byte brightness)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraBrightnessSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kBrightness;
sendFrame.Values[0] = (int) brightness;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>system.motor.set</name>
/// <symbol>kSystemMotorSet</symbol>
/// <scope>system.motor</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="short" symbol="kMotor1">Motor1</arg>
/// <arg type="short" symbol="kMotor2">Motor2</arg>
/// <arg type="short" symbol="kMotor3">Motor3</arg>
/// <arg type="short" symbol="kMotor4">Motor4</arg>
/// </arguments>
///</command>
public static void SystemMotorSet(uint handle, short motor1, short motor2, short motor3, short motor4)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemMotorSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kMotor1;
sendFrame.Values[0] = (int) motor1;
sendFrame.Names[1] = Symbols.kMotor2;
sendFrame.Values[1] = (int) motor2;
sendFrame.Names[2] = Symbols.kMotor3;
sendFrame.Values[2] = (int) motor3;
sendFrame.Names[3] = Symbols.kMotor4;
sendFrame.Values[3] = (int) motor4;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.imageprocessing.pixelcorrection.set</name>
/// <symbol>kCameraImageprocessingPixelcorrectionSet</symbol>
/// <scope>camera.imageprocessing.pixelcorrection</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kValue">Value</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kResult">Result</response>
/// </responses>
/// <see>camera.imageprocessing.pixelcorrection.get</see>
///</command>
public static void CameraImageprocessingPixelcorrectionSet(uint handle, byte value)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraImageprocessingPixelcorrectionSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kValue;
sendFrame.Values[0] = (int) value;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>system.obstacle.pid.get</name>
/// <symbol>kSystemObstaclePidGet</symbol>
/// <scope>system.obstacle.pid</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="int" symbol="kPitchProportional">PitchProportional</response>
/// <response type="int" symbol="kPitchIntegral">PitchIntegral</response>
/// <response type="int" symbol="kPitchDerivative">PitchDerivative</response>
/// <response type="int" symbol="kRollProportional">RollProportional</response>
/// <response type="int" symbol="kRollIntegral">RollIntegral</response>
/// <response type="int" symbol="kRollDerivative">RollDerivative</response>
/// <response type="int" symbol="kYawProportional">YawProportional</response>
/// <response type="int" symbol="kYawIntegral">YawIntegral</response>
/// <response type="int" symbol="kYawDerivative">YawDerivative</response>
/// </responses>
///</command>
public static void SystemObstaclePidGet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemObstaclePidGet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.photo.get</name>
/// <symbol>kCameraPhotoGet</symbol>
/// <scope>camera.photo</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="byte" symbol="kValue">Value</arg>
/// </arguments>
///</command>
public static void CameraPhotoGet(uint handle, byte value)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraPhotoGet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kValue;
sendFrame.Values[0] = (int) value;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>system.time.set</name>
/// <symbol>kSystemTimeSet</symbol>
/// <scope>system.time</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="uint" symbol="kTime">Time</arg>
/// </arguments>
/// <see>system.time.get</see>
///</command>
public static void SystemTimeSet(uint handle, uint time)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kSystemTimeSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kTime;
sendFrame.Values[0] = (int) time;
}
Library.Send(ref sendFrame);
}
///<command>
/// <name>camera.saturation.get</name>
/// <symbol>kCameraSaturationGet</symbol>
/// <scope>camera.saturation</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// </arguments>
/// <responses>
/// <response type="byte" symbol="kSaturation">Saturation</response>
/// </responses>
/// <see>camera.saturation.set</see>
///</command>
public static void CameraSaturationGet(uint handle)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kCameraSaturationGet;
sendFrame.Type = Frame.kSendFrame;
Library.Send(ref sendFrame);
}
///<command>
/// <name>waypoint.get</name>
/// <symbol>kWaypointGet</symbol>
/// <scope>waypoint</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="ushort" symbol="kWaypointId">WaypointId</arg>
/// </arguments>
/// <responses>
/// <response type="ushort" symbol="kWaypointId">WaypointId</response>
/// <response type="int" symbol="kLatitude">Latitude</response>
/// <response type="int" symbol="kLongitude">Longitude</response>
/// <response type="int" symbol="kLatitudeDirection">LatitudeDirection</response>
/// <response type="int" symbol="kLongitudeDirection">LongitudeDirection</response>
/// <response type="int" symbol="kAltitude">Altitude</response>
/// <response type="uint" symbol="kType">Type</response>
/// <response type="uint" symbol="kFlags">Flags</response>
/// </responses>
/// <see>waypoint.add</see>
/// <see>waypoint.mode</see>
/// <see>waypoint.pause</see>
/// <see>waypoint.set</see>
/// <see>waypoint.start</see>
/// <see>waypoint.stop</see>
///</command>
public static void WaypointGet(uint handle, ushort waypointid)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kWaypointGet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kWaypointId;
sendFrame.Values[0] = (int) waypointid;
}
Library.Send(ref sendFrame);
}
public static void Tick()
{
if (Initialised && CanTick)
{
A.Trigger("tick");
LibZano.Library.GetFirmwareVersion(Handle, ref FirmwareVersion);
if (Library.Time() >= BatteryTimer)
{
BatteryTimer = Library.Time() + 1000;
Console.WriteLine("Booted = {0}, Connected = {1}", IsBooted, IsConnected);
if (IsBooted && IsConnected)
{
Frames.SensorsBatteryGet(Handle);
}
}
Library.Tick();
Frame frame = new Frame();
while (Library.Receive(ref frame) == 1)
{
switch (frame.Type)
{
case Frame.kSendFrame:
{
String evt;
if (listens.TryGetValue(frame.Reference, out evt))
{
T.Trigger(evt, frame);
}
if (frame.Reference == Symbols.kSensorsBatteryGet)
{
Z.LastBattery = frame.Get(Symbols.kCharge);
Console.WriteLine("Battery = {0}", Z.LastBattery);
A.Trigger("battery", Z.LastBattery);
}
}
break;
case Frame.kConnectFrame:
{
Console.WriteLine("Connect Frame");
}
break;
case Frame.kDisconnectFrame:
{
Console.WriteLine("Disconnect Frame");
}
break;
case Frame.kFlyStateFrame:
{
Console.WriteLine("Fly State Frame");
}
break;
case Frame.kFirmware:
{
Console.WriteLine("Firmware Frame");
}
break;
case Frame.kServerConnectivity:
{
Console.WriteLine("Server Connectivity Frame");
}
break;
}
}
Library.Status status;
while ((status = Library.GetStatus()) != Library.Status.None)
{
Console.WriteLine("Status = {0}", status);
switch (status)
{
case Library.Status.None:
break;
case Library.Status.FlashingStarted:
Internal.Connect.Trigger("firmware_upgrade_start");
A.Trigger("firmware_upgrade_start");
break;
case Library.Status.FlashingProcessSucessfull:
Internal.Connect.Trigger("firmware_upgrade_start_complete");
A.Trigger("firmware_upgrade_start_complete");
break;
case Library.Status.FlashingProcessFailed:
Internal.Connect.Trigger("firmware_upgrade_start_failed");
A.Trigger("firmware_upgrade_start_failed");
break;
case Library.Status.FlashingProcessInProgress:
Internal.Connect.Trigger("firmware_upgrade_in_progress");
A.Trigger("firmware_upgrade_in_progress");
break;
case Library.Status.ConfigurationStarting:
break;
case Library.Status.ConfigurationApplied:
break;
case Library.Status.ConfigurationNotNeeded:
break;
case Library.Status.ConfigurationDoesNotExist:
break;
case Library.Status.HelloRequested:
break;
case Library.Status.HelloSuccess:
A.Trigger("has_internet");
T.Trigger("has_internet");
break;
case Library.Status.HelloFailed:
A.Trigger("no_internet");
T.Trigger("no_internet");
break;
case Library.Status.HaveServerConnection:
A.Trigger("have_server_connection");
T.Trigger("have_server_connection");
break;
case Library.Status.FirmwareDownloadingRequested:
break;
case Library.Status.FirmwareDownloadedNew:
break;
case Library.Status.FirmwareDownloadedUpToDate:
break;
case Library.Status.FirmwareDownloadedNetworkError:
break;
case Library.Status.ConfigurationRequest:
break;
case Library.Status.ConfigurationNetworkError:
break;
case Library.Status.ConfigurationAuthenticationError:
break;
case Library.Status.ConfigurationNoConfigurationAssociatedWithAccount:
break;
case Library.Status.ConfigurationDownloaded:
A.Trigger("configuration_downloaded");
T.Trigger("configuration_downloaded");
break;
case Library.Status.DeviceConnectionAttempt:
break;
case Library.Status.DeviceConnectionGotConnection:
break;
case Library.Status.DeviceConnectionBooted:
Internal.Connect.Trigger("booted");
A.Trigger("booted");
break;
case Library.Status.DeviceConnectionInRecovery:
break;
case Library.Status.DeviceConnectionHeldStill:
Internal.Connect.Trigger("not_still");
A.Trigger("not_still");
break;
case Library.Status.DeviceConnectionBootFailure:
break;
case Library.Status.DeviceConnectionNeedToUpdate:
Internal.Connect.Trigger("need_to_update");
A.Trigger("need_to_update");
break;
case Library.Status.DeviceConnectionConnected:
Library.GetSerialNumber(Handle, ref SerialNumber);
Internal.Connect.Trigger("connected");
A.Trigger("connected");
BatteryTimer = Library.Time() + 1000;
LastBattery = 0;
break;
case Library.Status.DeviceConnectionNotConnected:
LastBattery = 0;
Internal.Connect.Trigger("not_connected");
A.Trigger("not_connected");
break;
case Library.Status.DeviceConnectionBadUpdate:
Internal.Connect.Trigger("bad_update");
A.Trigger("bad_update");
break;
case Library.Status.DeviceConnectionDroneNotAssociatedWithAccount:
Internal.Connect.Trigger("drone_not_associated");
A.Trigger("drone_not_associated");
break;
case Library.Status.DeviceConnectionPeekConnected:
A.Trigger("peek_connected");
break;
case Library.Status.DeviceDisconnectionDisconnected:
LastBattery = 0;
T.Trigger("disconnected");
A.Trigger("disconnected");
break;
case Library.Status.ServerConnectivityLoginSuccess:
A.Trigger("logged_in");
T.Trigger("logged_in");
break;
case Library.Status.ServerConnectivityLoginFailure:
A.Trigger("not_logged_in");
T.Trigger("not_logged_in");
break;
case Library.Status.FirmwareConfigurationPersistanceSaveRequested:
A.Trigger("config_server_save_started");
T.Trigger("config_server_save_started");
break;
case Library.Status.FirmwareConfigurationPersistanceSaveCompleted:
A.Trigger("config_server_save_complete");
T.Trigger("config_server_save_complete");
break;
case Library.Status.FirmwareConfigurationPersistanceSaveFailure:
A.Trigger("config_server_save_failed");
T.Trigger("config_server_save_failed");
break;
}
}
}
}
///<command>
/// <name>waypoint.set</name>
/// <symbol>kWaypointSet</symbol>
/// <scope>waypoint</scope>
/// <arguments>
/// <arg type="uint">Drone Handle</arg>
/// <arg type="ushort" symbol="kWaypointId">WaypointId</arg>
/// <arg type="int" symbol="kLatitude">Latitude</arg>
/// <arg type="int" symbol="kLongitude">Longitude</arg>
/// <arg type="int" symbol="kLatitudeDirection">LatitudeDirection</arg>
/// <arg type="int" symbol="kLongitudeDirection">LongitudeDirection</arg>
/// <arg type="int" symbol="kAltitude">Altitude</arg>
/// <arg type="uint" symbol="kType">Type</arg>
/// <arg type="uint" symbol="kFlags">Flags</arg>
/// </arguments>
/// <responses>
/// <response type="ushort" symbol="kid">id</response>
/// </responses>
/// <see>waypoint.add</see>
/// <see>waypoint.get</see>
/// <see>waypoint.mode</see>
/// <see>waypoint.pause</see>
/// <see>waypoint.start</see>
/// <see>waypoint.stop</see>
///</command>
public static void WaypointSet(uint handle, ushort waypointid, int latitude, int longitude, int latitudedirection, int longitudedirection, int altitude, uint type, uint flags)
{
Frame sendFrame = new Frame(handle);
sendFrame.Reference = Symbols.kWaypointSet;
sendFrame.Type = Frame.kSendFrame;
unchecked
{
sendFrame.Names[0] = Symbols.kWaypointId;
sendFrame.Values[0] = (int) waypointid;
sendFrame.Names[1] = Symbols.kLatitude;
sendFrame.Values[1] = (int) latitude;
sendFrame.Names[2] = Symbols.kLongitude;
sendFrame.Values[2] = (int) longitude;
sendFrame.Names[3] = Symbols.kLatitudeDirection;
sendFrame.Values[3] = (int) latitudedirection;
sendFrame.Names[4] = Symbols.kLongitudeDirection;
sendFrame.Values[4] = (int) longitudedirection;
sendFrame.Names[5] = Symbols.kAltitude;
sendFrame.Values[5] = (int) altitude;
sendFrame.Names[6] = Symbols.kType;
sendFrame.Values[6] = (int) type;
sendFrame.Names[7] = Symbols.kFlags;
sendFrame.Values[7] = (int) flags;
}
Library.Send(ref sendFrame);
}
