// Callback function for acceleration // static void accelCallback(YGyro yGyro, double w, double x, double y, double z) { // this callback value is returned in milli-g; convert to g _ax = x * 0.001; _ay = y * 0.001; _az = z * 0.001; eventCount[3]++; }
// link the instance to a real YoctoAPI object internal override void linkToHardware(string hwdName) { YGyro hwd = YGyro.FindGyro(hwdName); // first redo base_init to update all _func pointers base_init(hwd, hwdName); // then setup Yocto-API pointers and callbacks init(hwd); }
// Configure the value callbacks on the currently selected device // private void setupDevice() { YAccelerometer accelerometer; YCompass compass; YTilt tilt1, tilt2; YGyro gyro; YQt qt1, qt2, qt3, qt4; if (currentSerialNumber != prevSerialNumber && prevSerialNumber != "") { // Unregister previous device tilt1 = YTilt.FindTilt(prevSerialNumber + ".tilt1"); tilt2 = YTilt.FindTilt(prevSerialNumber + ".tilt2"); compass = YCompass.FindCompass(prevSerialNumber + ".compass"); gyro = YGyro.FindGyro(prevSerialNumber + ".gyro"); compass.registerValueCallback(null); tilt1.registerValueCallback(null); tilt2.registerValueCallback(null); gyro.registerAnglesCallback(null); } if (currentSerialNumber == "") { return; } // Register the newly selected device accelerometer = YAccelerometer.FindAccelerometer(currentSerialNumber + ".accelerometer"); tilt1 = YTilt.FindTilt(currentSerialNumber + ".tilt1"); tilt2 = YTilt.FindTilt(currentSerialNumber + ".tilt2"); compass = YCompass.FindCompass(currentSerialNumber + ".compass"); gyro = YGyro.FindGyro(currentSerialNumber + ".gyro"); qt1 = YQt.FindQt(currentSerialNumber + ".qt1"); qt2 = YQt.FindQt(currentSerialNumber + ".qt2"); qt3 = YQt.FindQt(currentSerialNumber + ".qt3"); qt4 = YQt.FindQt(currentSerialNumber + ".qt4"); compass.registerValueCallback(valueCallback); tilt1.registerValueCallback(valueCallback); tilt2.registerValueCallback(valueCallback); if (modeChooser.SelectedIndex != 1) { accelerometer.set_bandwidth(7); qt1.set_logicalName("w"); qt2.set_logicalName("x"); qt3.set_logicalName("y"); qt4.set_logicalName("z"); gyro.registerAnglesCallback(anglesCallback); } else { accelerometer.set_bandwidth(50); qt2.set_logicalName("ax"); qt3.set_logicalName("ay"); qt4.set_logicalName("az"); gyro.registerQuaternionCallback(accelCallback); } }
// perform the 2nd stage setup that requires YoctoAPI object protected void init(YGyro hwd) { if (hwd == null) { return; } base.init(hwd); InternalStuff.log("registering Gyro callback"); _func.registerValueCallback(valueChangeCallback); }
// Callback function for orientation // static void anglesCallback(YGyro yGyro, double roll, double pitch, double head) { if (Double.IsNaN(roll) || Double.IsNaN(pitch) || Double.IsNaN(head)) { return; } _roll = roll; _pitch = pitch; _head = head; eventCount[3]++; }
public override async Task <int> Run() { try { await YAPI.RegisterHub(HubURL); YTilt anytilt, tilt1, tilt2; YCompass compass; YAccelerometer accel; YGyro gyro; if (Target.ToLower() == "any") { anytilt = YTilt.FirstTilt(); if (anytilt == null) { WriteLine("No module connected (check USB cable)"); return(-1); } } else { anytilt = YTilt.FindTilt(Target + ".tilt1"); } string serial = await(await anytilt.get_module()).get_serialNumber(); tilt1 = YTilt.FindTilt(serial + ".tilt1"); tilt2 = YTilt.FindTilt(serial + ".tilt2"); compass = YCompass.FindCompass(serial + ".compass"); accel = YAccelerometer.FindAccelerometer(serial + ".accelerometer"); gyro = YGyro.FindGyro(serial + ".gyro"); int count = 0; while (await tilt1.isOnline()) { if (count++ % 10 == 0) { WriteLine("tilt1 tilt2 compass acc gyro"); } Write(await tilt1.get_currentValue() + "\t"); Write(await tilt2.get_currentValue() + "\t"); Write(await compass.get_currentValue() + "\t"); Write(await accel.get_currentValue() + "\t"); WriteLine("" + await gyro.get_currentValue()); await YAPI.Sleep(250); } WriteLine("Module not connected (check identification and USB cable)"); } catch (YAPI_Exception ex) { WriteLine("error: " + ex.Message); } YAPI.FreeAPI(); return(0); }
/** * <summary> * Retrieves a gyroscope for a given identifier. * <para> * The identifier can be specified using several formats: * </para> * <para> * </para> * <para> * - FunctionLogicalName * </para> * <para> * - ModuleSerialNumber.FunctionIdentifier * </para> * <para> * - ModuleSerialNumber.FunctionLogicalName * </para> * <para> * - ModuleLogicalName.FunctionIdentifier * </para> * <para> * - ModuleLogicalName.FunctionLogicalName * </para> * <para> * </para> * <para> * This function does not require that the gyroscope is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method <c>YGyro.isOnline()</c> to test if the gyroscope is * indeed online at a given time. In case of ambiguity when looking for * a gyroscope by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * </para> * </summary> * <param name="func"> * a string that uniquely characterizes the gyroscope * </param> * <returns> * a <c>YGyro</c> object allowing you to drive the gyroscope. * </returns> */ public static YGyro FindGyro(string func) { YGyro obj; obj = (YGyro)YFunction._FindFromCache("Gyro", func); if (obj == null) { obj = new YGyro(func); YFunction._AddToCache("Gyro", func, obj); } return(obj); }
public static YGyroProxy FindGyro(string name) { // cases to handle: // name ="" no matching unknwn // name ="" unknown exists // name != "" no matching unknown // name !="" unknown exists YGyro func = null; YGyroProxy res = (YGyroProxy)YFunctionProxy.FindSimilarUnknownFunction("YGyroProxy"); if (name == "") { if (res != null) { return(res); } res = (YGyroProxy)YFunctionProxy.FindSimilarKnownFunction("YGyroProxy"); if (res != null) { return(res); } func = YGyro.FirstGyro(); if (func != null) { name = func.get_hardwareId(); if (func.get_userData() != null) { return((YGyroProxy)func.get_userData()); } } } else { func = YGyro.FindGyro(name); if (func.get_userData() != null) { return((YGyroProxy)func.get_userData()); } } if (res == null) { res = new YGyroProxy(func, name); } if (func != null) { res.linkToHardware(name); if (func.isOnline()) { res.arrival(); } } return(res); }
/** * <summary> * Enumerates all functions of type Gyro available on the devices * currently reachable by the library, and returns their unique hardware ID. * <para> * Each of these IDs can be provided as argument to the method * <c>YGyro.FindGyro</c> to obtain an object that can control the * corresponding device. * </para> * </summary> * <returns> * an array of strings, each string containing the unique hardwareId * of a device function currently connected. * </returns> */ public static new string[] GetSimilarFunctions() { List <string> res = new List <string>(); YGyro it = YGyro.FirstGyro(); while (it != null) { res.Add(it.get_hardwareId()); it = it.nextGyro(); } return(res.ToArray()); }
protected static void yInternalGyroCallback(YQt obj, String value) { YGyro gyro = (YGyro)obj.get_userData(); if (gyro == null) { return; } string tmp = obj.get_functionId().Substring(2); int idx = Convert.ToInt32(tmp); double dbl_value = Convert.ToDouble(value); gyro._invokeGyroCallbacks(idx, dbl_value); }
public static bool RegisterGyroscope() { _gyro = YGyro.FirstGyro(); if (_gyro == null) { throw new Exception("No USB gyroscope found!"); } _gyro = YGyro.FindGyro(_gyro.get_module().get_serialNumber() + GYRO_SUFFIX); if (_gyro == null) { throw new Exception("Yocto device found, but no gyroscope could be conneceted to!"); } return(true); }
static void Main(string[] args) { string errmsg = ""; string target; YTilt anytilt, tilt1, tilt2; YCompass compass; YAccelerometer accelerometer; YGyro gyro; if (args.Length < 1) { usage(); } target = args[0].ToUpper(); // Setup the API to use local USB devices if (YAPI.RegisterHub("usb", ref errmsg) != YAPI.SUCCESS) { Console.WriteLine("RegisterHub error: " + errmsg); Environment.Exit(0); } if (target == "ANY") { anytilt = YTilt.FirstTilt(); if (anytilt == null) { Console.WriteLine("No module connected (check USB cable)"); Environment.Exit(0); } } else { anytilt = YTilt.FindTilt(target + ".tilt1"); if (!anytilt.isOnline()) { Console.WriteLine("Module not connected"); Console.WriteLine("check identification and USB cable"); Environment.Exit(0); } } string serial = anytilt.get_module().get_serialNumber(); tilt1 = YTilt.FindTilt(serial + ".tilt1"); tilt2 = YTilt.FindTilt(serial + ".tilt2"); compass = YCompass.FindCompass(serial + ".compass"); accelerometer = YAccelerometer.FindAccelerometer(serial + ".accelerometer"); gyro = YGyro.FindGyro(serial + ".gyro"); int count = 0; if (!tilt1.isOnline()) { Console.WriteLine("device disconnected"); Environment.Exit(0); } while (tilt1.isOnline()) { if (count % 10 == 0) { Console.WriteLine("tilt1 tilt2 compass acc gyro"); } Console.Write(tilt1.get_currentValue().ToString() + "\t"); Console.Write(tilt2.get_currentValue().ToString() + "\t"); Console.Write(compass.get_currentValue().ToString() + "\t"); Console.Write(accelerometer.get_currentValue().ToString() + "\t"); Console.WriteLine(gyro.get_currentValue().ToString()); YAPI.Sleep(250, ref errmsg); } YAPI.FreeAPI(); }
/** * <summary> * Retrieves a gyroscope for a given identifier. * <para> * The identifier can be specified using several formats: * </para> * <para> * </para> * <para> * - FunctionLogicalName * </para> * <para> * - ModuleSerialNumber.FunctionIdentifier * </para> * <para> * - ModuleSerialNumber.FunctionLogicalName * </para> * <para> * - ModuleLogicalName.FunctionIdentifier * </para> * <para> * - ModuleLogicalName.FunctionLogicalName * </para> * <para> * </para> * <para> * This function does not require that the gyroscope is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method <c>YGyro.isOnline()</c> to test if the gyroscope is * indeed online at a given time. In case of ambiguity when looking for * a gyroscope by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * </para> * </summary> * <param name="func"> * a string that uniquely characterizes the gyroscope * </param> * <returns> * a <c>YGyro</c> object allowing you to drive the gyroscope. * </returns> */ public static YGyro FindGyro(string func) { YGyro obj; obj = (YGyro) YFunction._FindFromCache("Gyro", func); if (obj == null) { obj = new YGyro(func); YFunction._AddToCache("Gyro", func, obj); } return obj; }
// perform the initial setup that may be done without a YoctoAPI object (hwd can be null) internal override void base_init(YFunction hwd, string instantiationName) { _func = (YGyro)hwd; base.base_init(hwd, instantiationName); }
//--- (end of YGyro definitions) //--- (YGyro implementation) internal YGyroProxy(YGyro hwd, string instantiationName) : base(hwd, instantiationName) { InternalStuff.log("Gyro " + instantiationName + " instantiation"); base_init(hwd, instantiationName); }