public ATAnalogInputConfigManagerUnsafe(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe _0) { _Instance = Marshal.AllocHGlobal(sizeof(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe._Internal)); _ownsNativeInstance = true; NativeToManagedMap[_Instance] = this; *((DeviceConfiguration.ATAnalogInputConfigManagerUnsafe._Internal *)_Instance) = *((DeviceConfiguration.ATAnalogInputConfigManagerUnsafe._Internal *)_0._Instance); }
/// <summary>Determine if an input's port config needs clearing in storage</summary> /// <param name="inputConfigManager">The input config manager</param> /// <param name="port">The port</param> /// <returns>`true` if port config needs clearing</returns> public static bool ATAnalogInputConfigManagerPortConfigNeedsClearing(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _ret = _Internal.ATAnalogInputConfigManagerPortConfigNeedsClearing(_arg0, port); return(_ret); }
/// <summary>Apply an analog action to an input config</summary> /// <param name="inputConfigManager">The input config manager</param> /// <param name="action">The action to apply</param> /// <param name="currentValue">The current analog input value for this port, for calibrate now actions. Ignored for other actions</param> /// <returns>If successful, `true`, otherwise `false`</returns> public static bool ATAnalogInputConfigManagerApplyAnalogAction(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATAnalogActionUnsafe action, short currentValue) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _arg1 = ReferenceEquals(action, null) ? IntPtr.Zero : action._Instance; var _ret = _Internal.ATAnalogInputConfigManagerApplyAnalogAction(_arg0, _arg1, currentValue); return(_ret); }
/// <summary>Parse data into multiple config objects</summary> /// <param name="inputConfigManager">The input config manager</param> /// <param name="data">The data to parse</param> /// <returns>`true` if successful, otherwise `false`.</returns> public static bool ATAnalogInputConfigManagerParseMultiple(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, Foundation.ATDataUnsafe data) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _arg1 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance; var _ret = _Internal.ATAnalogInputConfigManagerParseMultiple(_arg0, _arg1); return(_ret); }
/// <summary>Parse data into a analog input config manager object from its binary representation as received from an AirTurn/storage</summary> /// <param name="inputConfigManager">The analog input config manager object</param> /// <param name="port">The port to parse data for</param> /// <param name="data">The data</param> /// <param name="lengthParsed">The length of the data</param> /// <returns>The initialized object or `NULL` if initialization failed</returns> public static bool ATAnalogInputConfigManagerParseData(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port, Foundation.ATDataUnsafe data, ref ulong lengthParsed) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _arg2 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance; fixed(ulong *_lengthParsed3 = &lengthParsed) { var _arg3 = _lengthParsed3; var _ret = _Internal.ATAnalogInputConfigManagerParseData(_arg0, port, _arg2, _arg3); return(_ret); } }
/// <summary>Get the stored analog analog input config data</summary> /// <param name="inputConfigManager">The analog input config</param> /// <param name="port">The port to get data for</param> /// <param name="optionalDataToFill">An optional data object to fill with the generated data</param> /// <returns>The generated data. If `optionalDataToFill` is NULL, returns a data object owned by the analog input config object, otherwise returns `optionalDataToFill`</returns> public static Foundation.ATDataUnsafe ATAnalogInputConfigManagerGetData(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port, Foundation.ATDataUnsafe optionalDataToFill, bool includeLimits) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _arg2 = ReferenceEquals(optionalDataToFill, null) ? IntPtr.Zero : optionalDataToFill._Instance; var _ret = _Internal.ATAnalogInputConfigManagerGetData(_arg0, port, _arg2, includeLimits); Foundation.ATDataUnsafe _result0; if (_ret == IntPtr.Zero) { _result0 = null; } else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret)) { _result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret]; } else { _result0 = Foundation.ATDataUnsafe._CreateInstance(_ret); } return(_result0); }
/// <summary>Inform the input config manager that a port config has been cleared</summary> /// <param name="inputConfigManager">The input config manager</param> /// <param name="port">The port</param> public static void ATAnalogInputConfigManagerPortConfigCleared(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; _Internal.ATAnalogInputConfigManagerPortConfigCleared(_arg0, port); }
/// <summary>Reset all active input configs to the stored configs</summary> /// <param name="inputConfigManager">The input config manager</param> public static void ATAnalogInputConfigManagerResetToStored(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; _Internal.ATAnalogInputConfigManagerResetToStored(_arg0); }
/// <summary>Get an input config</summary> /// <param name="inputConfigManager">The input config manager</param> /// <param name="port">The port to get the input config for</param> /// <param name="active">If `true`, returns the active input config, otherwise returns the stored input config</param> /// <returns>The input config, if port is valid, otherwise `NULL`</returns> public static DeviceConfiguration.ATAnalogInputConfigUnsafe ATAnalogInputConfigManagerGetInputConfig(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port, bool active) { var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance; var _ret = _Internal.ATAnalogInputConfigManagerGetInputConfig(_arg0, port, active); DeviceConfiguration.ATAnalogInputConfigUnsafe _result0; if (_ret == IntPtr.Zero) { _result0 = null; } else if (DeviceConfiguration.ATAnalogInputConfigUnsafe.NativeToManagedMap.ContainsKey(_ret)) { _result0 = (DeviceConfiguration.ATAnalogInputConfigUnsafe)DeviceConfiguration.ATAnalogInputConfigUnsafe.NativeToManagedMap[_ret]; } else { _result0 = DeviceConfiguration.ATAnalogInputConfigUnsafe._CreateInstance(_ret); } return(_result0); }
/// <summary>Create a new analog input config manager object</summary> /// <param name="optionalStorage">Optionally, a pointer to a struct or memory where the object can be stored</param> /// <returns>A pointer to the new object. `NULL` if allocation could not be completed</returns> public static DeviceConfiguration.ATAnalogInputConfigManagerUnsafe ATAnalogInputConfigManagerNew(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe optionalStorage) { var _arg0 = ReferenceEquals(optionalStorage, null) ? IntPtr.Zero : optionalStorage._Instance; var _ret = _Internal.ATAnalogInputConfigManagerNew(_arg0); DeviceConfiguration.ATAnalogInputConfigManagerUnsafe _result0; if (_ret == IntPtr.Zero) { _result0 = null; } else if (DeviceConfiguration.ATAnalogInputConfigManagerUnsafe.NativeToManagedMap.ContainsKey(_ret)) { _result0 = (DeviceConfiguration.ATAnalogInputConfigManagerUnsafe)DeviceConfiguration.ATAnalogInputConfigManagerUnsafe.NativeToManagedMap[_ret]; } else { _result0 = DeviceConfiguration.ATAnalogInputConfigManagerUnsafe._CreateInstance(_ret); } return(_result0); }