private bool IsDeviceShouldBeStopped(NandakaDevice device, DeviceError newError) { int errorCount = device.ErrorCounter[newError]; device.ErrorCounter[newError] = errorCount + 1; return(errorCount > _maxErrorInRowCount); }
public static void PowerOff() { DeviceError res = (DeviceError)Interop.Device.DevicePowerPowerOff(); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to power off the device."); } }
protected void RaiseShirtErrorEvent(DeviceError shirtError) { var handler = ShirtReceivedError; if (handler != null) { handler(shirtError); } }
protected void RaisePantsErrorEvent(DeviceError pantsError) { var handler = PantsReceivedError; if (handler != null) { handler(pantsError); } }
public static void Reboot(string reason) { DeviceError res = (DeviceError)Interop.Device.DevicePowerReboot(reason); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to reboot the device."); } }
/// <summary> /// Stops the LED that is located at the front of the device. /// </summary> /// <since_tizen> 3 </since_tizen> /// <exception cref="UnauthorizedAccessException">If the privilege is not set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// try /// { /// Led.Play(500, 200, Color.FromRgba(255, 255, 255, 1)); /// //wait for a while and stop... /// Led.Stop(); /// } /// Catch(Exception e) /// { /// } /// </code> /// </example> public static void Stop() { DeviceError res = (DeviceError)Interop.Device.DeviceLedStopCustom(); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "failed to stop Led."); } }
public static void ReleaseCpuLock() { DeviceError res = (DeviceError)Interop.Device.DevicePowerReleaseLock(Interop.Device.PowerLock.Cpu); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to release power lock."); } }
public static void RequestCpuLock(int timeout) { DeviceError res = (DeviceError)Interop.Device.DevicePowerRequestLock(Interop.Device.PowerLock.Cpu, timeout); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to acquire power lock."); } }
public void OnError(DeviceError error) { EventHandler <DeviceError> eventHandler = this.OnFailed; if (eventHandler != null) { eventHandler(this, error); } }
/* Public */ public Controller(SerialPortStream port) { Buffer = new StringBuilder(16); TerminalQueue = new BlockingCollectionQueue(); DataQueue = new BlockingCollectionQueue(); Port = port; Port.DataReceived += Port_DataReceived; DataErrorEventThreadStart = (object x) => { DataError?.Invoke(this, (DataErrorEventArgs)x); }; DeviceErrorThreadStart = (object x) => { DeviceError?.Invoke(this, (TerminalEventArgs)x); }; }
/// <summary> /// Transmits the IR command. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="carrierFreequency"> /// The carrier frequency to transmit the IR command (Hertz). /// </param> /// <param name="pattern"> /// The IR command list of type integer. /// </param> /// <exception cref="ArgumentException"> When an invalid parameter value is set.</exception> /// <exception cref="UnauthorizedAccessException">If the privilege is not set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// try /// { /// List<int> pattern = new List<int>(); /// pattern.Add(10); /// pattern.Add(50); /// IR.Transmit(60657, pattern); /// } /// catch(Exception e) /// { /// } /// </code> /// </example> public static void Transmit(int carrierFreequency, IList <int> pattern) { int[] patternArray = pattern.ToArray(); DeviceError res = (DeviceError)Interop.Device.DeviceIRTransmit(carrierFreequency, patternArray, pattern.Count()); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to trasmit IR command."); } }
/// <summary> /// Plays the LED that is located at the front of the device. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="on">Turn on time in milliseconds.</param> /// <param name="off">Turn off time in milliseconds.</param> /// <param name="color"> /// The Color value /// The first byte means opaque and the other 3 bytes are the RGB values. /// </param> /// <exception cref="ArgumentException">When an invalid parameter value is set.</exception> /// <exception cref="UnauthorizedAccessException">If the privilege is not set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// try /// { /// Led.Play(500, 200, Color.FromRgba(255, 255, 255, 1)); /// } /// Catch(Exception e) /// { /// } /// </code> /// </example> public static void Play(int on, int off, Color color) { //looks like only blink option is supported. So hard coded to default blink option. DeviceError res = (DeviceError)Interop.Device.DeviceLedPlayCustom(on, off, Convert.ToUInt32(color.GetArgb()), 1); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "failed to play Led."); } }
/// <summary> /// Stops all the vibration effects which are being played. /// This function can be used to stop all the effects started by Vibrate(). /// </summary> /// <since_tizen> 3 </since_tizen> /// <feature> /// http://tizen.org/feature/feedback.vibration /// </feature> /// <exception cref="ArgumentException"> In case an invalid vibrator instance is used.</exception> /// <exception cref="UnauthorizedAccessException">If the privilege is not set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// Vibrator vibrator = Vibrator.Vibrators[0]; /// try /// { /// vibrator.Stop(); /// } /// catch(Exception e) /// { /// } /// </code> /// </example> public void Stop() { if (_hapticHandle != IntPtr.Zero) { DeviceError res = (DeviceError)Interop.Device.DeviceHapticStop(_hapticHandle, IntPtr.Zero); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to stop the current vibrator."); } } }
private string GetNicifiedString(DeviceError deviceError) { switch (deviceError) { case DeviceError.CalibrationFailed: return("Please Recalibrate"); case DeviceError.NoCalibration: return("Please Calibrate"); case DeviceError.UnknownDevice: return("Unknown Device"); } return(""); }
private Vibrator(int id) { _vibratorId = id; DeviceError res = (DeviceError)Interop.Device.DeviceHapticOpen(_vibratorId, out _hapticHandle); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to create Vibrator for given Id"); } res = (DeviceError)Interop.Device.DeviceHapticGetCount(out _maxcount); if (res != DeviceError.None) { Log.Warn(DeviceExceptionFactory.LogTag, "unable to get Vibrators count."); } }
/// <summary> /// Increase the cpu clock within timeout. /// </summary> /// <param name="type">Performance Control Type</param> /// <param name="timeout">Cpu clock increasing duration in milliseconds.</param> /// <exception cref="ArgumentException">When an invalid parameter value is set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// try /// { /// PerformanceController.Request(PerformanceControlType.AppLaunchHome, 100); /// } /// Catch(Exception e) /// { /// } /// </code> /// </example> public static void Request(PerformanceControlType type, int timeout) { PerformanceControlFunc func = null; if (!PerformanceControlFunctions.TryGetValue(type, out func)) { throw new ArgumentException("Invalid Arguments"); } DeviceError res = (DeviceError)func(timeout); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to transmit PmQos command."); } }
private static IReadOnlyList <Vibrator> GetAllVibrators() { int count = 0; List <Vibrator> vibrators = new List <Vibrator>(); DeviceError res = (DeviceError)Interop.Device.DeviceHapticGetCount(out count); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to get Vibrators count."); } for (int i = 0; i < NumberOfVibrators; i++) { vibrators.Add(new Vibrator(i)); } return(vibrators); }
private dynamic MakeResult(int code, DeviceError errorcode, string description) { dynamic res = new ExpandoObject(); switch (errorcode) { case DeviceError.NO_ANSWER: res.code = 310; break; default: res.code = code; break; } res.description = description; return(res); }
public AnvizDevice(TcpClient socket) { DeviceStream = new AnvizStream(socket); DeviceStream.ReceivedPacket += (s, e) => { if (e.ResponseCode == 0x7F) { DevicePing?.Invoke(this, null); } else { ReceivedPacket?.Invoke(this, e); } }; DeviceStream.DeviceError += (s, e) => { DeviceError?.Invoke(this, e); }; }
public dynamic MakeResult(int code, DeviceError errorcode, string description) { dynamic result = new ExpandoObject(); switch (errorcode) { case DeviceError.NO_ANSWER: result.code = 310; break; default: result.code = code; break; } result.success = code == 0 ? true : false; result.description = description; return(result); }
/// <summary> /// Vibrates during the specified time with a constant intensity. /// This function can be used to start monotonous vibration for the specified time. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="duration">The play duration in milliseconds.</param> /// <param name="feedback">The amount of the intensity variation (0 ~ 100).</param> /// <feature> /// http://tizen.org/feature/feedback.vibration /// </feature> /// <exception cref="ArgumentException"> When an invalid parameter value is set.</exception> /// <exception cref="UnauthorizedAccessException">If the privilege is not set.</exception> /// <exception cref="InvalidOperationException">In case of any system error.</exception> /// <exception cref="NotSupportedException">In case the device does not support this behavior.</exception> /// <example> /// <code> /// Vibrator vibrator = Vibrator.Vibrators[0]; /// try /// { /// vibrator.Vibrate(2000, 70); /// } /// catch(Exception e) /// { /// } /// </code> /// </example> public void Vibrate(int duration, int feedback) { IntPtr effect; DeviceError res = DeviceError.None; if (_hapticHandle == IntPtr.Zero) { res = (DeviceError)Interop.Device.DeviceHapticOpen(_vibratorId, out _hapticHandle); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to get vibrator."); } } res = (DeviceError)Interop.Device.DeviceHapticVibrate(_hapticHandle, duration, feedback, out effect); if (res != DeviceError.None) { throw DeviceExceptionFactory.CreateException(res, "unable to vibrate the current vibrator."); } }
public static Result MakeResult(int code, DeviceError devicecode = DeviceError.NO_ERROR, string description = "") { Result result = new Result(); switch (devicecode) { case DeviceError.NO_ANSWER: result.code = 310; break; default: result.code = code; break; } result.devicecode = devicecode; result.description = description; //result.success = code == 0 ? true : false; return(result); }
internal static Exception CreateException(DeviceError err, string msg) { Exception exp; switch (err) { case DeviceError.InvalidParameter: case DeviceError.NotInitialized: //fall through exp = new ArgumentException(msg); break; case DeviceError.NotSupported: exp = new NotSupportedException(msg + " : Device does not support the Operation."); break; case DeviceError.AlreadyInProgress: //fall through case DeviceError.ResourceBusy: //fall through case DeviceError.OperationFailed: //fall through case DeviceError.InvalidOperation: exp = new InvalidOperationException(msg); break; case DeviceError.PermissionDenied: exp = new UnauthorizedAccessException(msg); break; default: exp = new InvalidOperationException("Unknown error occured."); break; } return(exp); }
protected void InvokeDeviceError(IDeviceEventArgs e) { CheckDisposed(); DeviceError?.Invoke(this, e); }
protected void FireDeviceError(string msg) { DeviceError?.Invoke(this, msg); }
private void Listen(CancellationToken token) { CheckDisposed(); DeviceStateEventArgs state = new DeviceStateEventArgs { IsEnabled = true }; resetWait.Reset(); NetworkStream stream = client.Connected ? client.GetStream() : null; while (!token.IsCancellationRequested) { if (state.IsEnabled) { try { if (!client.Connected) { lock (lockerClient) { client.Dispose(); client = null; OpenClient(); stream = client.Connected ? client.GetStream() : null; } } PollingRequests(); if (stream?.DataAvailable ?? false) { byte[] buffer = new byte[client.ReceiveBufferSize]; int length = 0; lock (lockerClient) { length = stream.Read(buffer, 0, buffer.Length); } try { IDeviceEventArgs message = RecivedData(buffer, length); if (message != null) { DeviceRecivedMessage?.Invoke(this, message); } } catch (Exception ex) { DeviceError?.Invoke(this, new DeviceErrorEventArgs { Ex = ex }); } } DeviceCheckState?.Invoke(this, state); if (!state.IsEnabled) { break; } } catch (Exception ex) { DeviceError?.Invoke(this, new DeviceErrorEventArgs { Ex = ex }); } } else { Disconnection(false); } Thread.Sleep(pollingTimeout); } resetWait.Set(); }
public void OnErrorOccured(NandakaDevice device, DeviceError error, ILog log) { log.AppendMessage(LogMessageType.Error, $"Error occured with {device}. Reason: {error}"); }
public override void OnDeviceError(CloverDeviceErrorEvent deviceErrorEvent) => DeviceError?.Invoke(deviceErrorEvent);
public DeviceError_dst_adapter(DeviceError dst) { this.dst = dst; }
public void OnErrorOccured(NandakaDevice device, DeviceError error) { _updatePolicy.OnErrorOccured(device, error, _log); }