private void EchoGpio_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge == GpioPinEdge.RisingEdge) { pulseLength.Start(); } else { pulseLength.Stop(); TimeSpan timeBetween = pulseLength.Elapsed; var distance = timeBetween.TotalSeconds * 17000; if (OnDistance != null) { OnDistance.Invoke(distance); } } }
// Bouton Vert private void _pin13_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { // Détection du front montant if (args.Edge == GpioPinEdge.RisingEdge) { if (_MODE.Equals("HORLOGE")) { } else if (_MODE.Equals("REVEIL_SET")) { // Retrait d'une heure à l'horaire de réveil _H_REG = _UtilReveilDriver.removeHour(_H_REG); _H_SON = _H_REG; } else if (_MODE.Equals("REVEIL_ON")) { } else if (_MODE.Equals("REVEIL_TYPE")) { if (_TYPE.Equals("SONNERIE")) { _TYPE = "MP3"; } else if (_TYPE.Equals("MP3")) { _TYPE = "RADIO"; } else if (_TYPE.Equals("RADIO")) { _TYPE = "SONNERIE"; } } else if (_MODE.Equals("MP3")) { } else if (_MODE.Equals("RADIO")) { } else if (_MODE.Equals("SONNERIE")) { } } }
private void Pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { lock (_lock) { if (!_evaluatingRows) { IGpioPinMapping mapping = this.PinMappings.Where(t => t.PinNumber == sender.PinNumber).SingleOrDefault(); if (mapping != null) { PinChangedStatus status = mapping.GetChangedStatus(args.Edge); if (status != PinChangedStatus.None) { this.OnPinValueChanged(mapping, status); } } } } }
private void InterruptGpioPinOnValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { try { _lastState = new GroveMiniPIRMotionSensorState() { CurrentEdge = args.Edge, PinNumber = sender.PinNumber }; if (myAction != null) { myAction.Invoke(_lastState); } } catch { } }
private void Pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { byte[] r; if (!_i2CDevice.Read(2, out r)) { return; } var touched = BitConverter.ToUInt16(r, 0); for (var i = 0; i <= 15; i++) { if ((touched & (1 << i)) != 0) { Debug.WriteLine("Touched " + i); } } }
private void Light_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { if (e.Edge == GpioPinEdge.FallingEdge) //release { SetLED(LEDCOLOR.Grey); var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { timer.Stop(); }); } else //pressed { SetLED(LEDCOLOR.Blue); var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { timer.Start(); }); } }
private async void ButtonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge == GpioPinEdge.FallingEdge) { // Get Registered Callbacks IClientCallbackStore <PushTriggerConfiguration> callbackStore = new AzureStorageClientCallbackStore <PushTriggerConfiguration>(); var callbacks = await callbackStore.ReadCallbacksAsync(); // Trigger Logic App foreach (var callback in callbacks) { if (!callback.Configuration.Enabled) { continue; } await callback.InvokeAsync(); } } }
private void buttonPressed(object sender, GpioPinValueChangedEventArgs e) { if (e.Edge == GpioPinEdge.FallingEdge) { var pin = (GpioPin)sender; if (pin != null) { var button = (Buttons)pin.PinNumber; if (button == Buttons.Select) { _isQuitPressed = true; } _buttonPressStack.Push(button); } } }
private void buttonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { // Random para seleccionar un color al azar Random r = new Random(); int color = r.Next(3); // Si el boton esta pulsado if (args.Edge == GpioPinEdge.FallingEdge) { Debug.WriteLine("Button Pressed"); // Establece el color según el valor obtenido en el random switch (color) { default: pinVerde.Write(GpioPinValue.Low); pinRojo.Write(GpioPinValue.Low); break; case 0: // Verde pinVerde.Write(GpioPinValue.High); pinRojo.Write(GpioPinValue.Low); break; case 1: // Rojo pinVerde.Write(GpioPinValue.Low); pinRojo.Write(GpioPinValue.High); break; case 2: pinVerde.Write(GpioPinValue.High); pinRojo.Write(GpioPinValue.High); break; } } else { Debug.WriteLine("Button Released"); // Una vez soltado el boton, apagamos el led pinVerde.Write(GpioPinValue.Low); pinRojo.Write(GpioPinValue.Low); } }
private async void StopButtonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { GpioPinValue currentValue = sender.Read(); await eventDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { bool wasDown = stopButtonDown; stopButtonDown = (currentValue == GpioPinValue.Low); if (wasDown != stopButtonDown) { if (stopButtonDown) { GpioStopButtonDown?.Invoke(this, null); } else { GpioStopButtonUp?.Invoke(this, null); } } }); }
private void EncA_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { _aState = _encA.Read(); if (_aState != _aLastState) { if (_encB.Read() != _aState) { InternalCounter++; Direction = Directions.Clockwise; } else { InternalCounter--; Direction = Directions.CounterClockwise; } RotationEventHandler rotationEvent = RotationDetected; rotationEvent(this, new RotationEventArgs(Direction, InternalCounter)); } _aLastState = _aState; }
private void _buttonDisLike_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge == GpioPinEdge.FallingEdge) { if (SelectedMenuItem != null) { var task = Task.Run(() => WebApiHelper.UpdateProduct(SelectedMenuItem.Id, false)); task.Wait(); if (task.Result != null) { Dispatcher.InvokeOnUI(() => { SelectedMenuItem.Reset(task.Result); CustomText = "Button DisLike was pressed..."; }); } } } }
private void InterruptPinB_ValueChanged(object sender, GpioPinValueChangedEventArgs e) { var interruptFlags = this.ReadRegister(MCP23017_INTFB); for (byte i = 0; i < 8; i++) { var interruptFlag = (interruptFlags & (1 << i)) != 0; if (interruptFlag) { var capture = ReadRegister(MCP23017_INTCAPB, i); var value = this.ReadRegister(MCP23017_GPIOB, i); // We can now fire the individual PORT event handler. if (this._gpioPin[i + 8] != null) { this._gpioPin[i + 8].DoValueChangedEvent(new GpioPinValueChangedEventArgs(capture ? GpioPinEdge.FallingEdge : GpioPinEdge.RisingEdge)); } } } }
// Detect button press event private void Button_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { // Pedestrian has pushed the button. Start timer for going red. if (e.Edge == GpioPinEdge.FallingEdge) { // Start the timer if and only if not in a cycle if (this.secondsElapsed == 0) { // need to invoke UI updates on the UI thread because this event // handler gets invoked on a separate thread. var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (e.Edge == GpioPinEdge.FallingEdge) { this.walkTimer.Start(); } }); } } }
/// <summary> /// Get sensor data and display the result /// </summary> private async Task GetSensorValueAndUpdateUI(string sensorName, GpioPinValueChangedEventArgs e) { StringBuilder sb = new StringBuilder(); // When user touched, pushed or tiled, then lit the LED and display sensor data if (e.Edge == GpioPinEdge.RisingEdge) { ledPinValue = GpioPinValue.High; ledPin.Write(ledPinValue); onboardLedPin1Value = GpioPinValue.High; onboardLedPin1.Write(onboardLedPin1Value); onboardLedPin2Value = GpioPinValue.High; onboardLedPin2.Write(onboardLedPin1Value); sb.Append($"{sensorName} on"); var geoposition = await GetCurrentLocation(); sb.Append($"Temp: {GetTemperature()}"); sb.Append($"Lux: {GetLux()}"); sb.Append($"Latitude: {geoposition.Coordinate.Point.Position.Latitude}"); sb.Append($"Longitude: {geoposition.Coordinate.Point.Position.Longitude}"); } else if (e.Edge == GpioPinEdge.FallingEdge) { ledPinValue = GpioPinValue.Low; ledPin.Write(ledPinValue); onboardLedPin1Value = GpioPinValue.Low; onboardLedPin1.Write(onboardLedPin1Value); onboardLedPin2Value = GpioPinValue.Low; onboardLedPin2.Write(onboardLedPin1Value); sb.Append($"Off"); } // Display the result to the view. await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { LedColor = (ledPinValue == GpioPinValue.High) ? redBrush : grayBrush; Message = sb.ToString(); }); }
private void Pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { var currentPinValue = pin.Read(); // If same value of last read, exits. if (currentPinValue == lastPinValue) { return; } // Checks the pin value. if (currentPinValue == actualHighPinValue) { longClickWatch.Restart(); IsPressed = true; this.RaiseEvent(Pressed); } else if (currentPinValue == actualLowPinValue) { longClickWatch.Stop(); this.RaiseEvent(Released); if (IsPressed) { IsPressed = false; if (longClickWatch.Elapsed > longClickTimeout) { this.RaiseEvent(LongClick); } else { this.RaiseEvent(Click); } } } lastPinValue = currentPinValue; }
private void Input_ValueChanged(object sender, GpioPinValueChangedEventArgs e) { var state = e.Edge == GpioPinEdge.FallingEdge ? ButtonState.Released : ButtonState.Pressed; switch (state) { case ButtonState.Released: if (this.Mode == LedMode.OnWhilePressed) { this.TurnLedOff(); } else if (this.Mode == LedMode.OnWhileReleased) { this.TurnLedOn(); } else if (this.Mode == LedMode.ToggleWhenReleased) { this.ToggleLED(); } break; case ButtonState.Pressed: if (this.Mode == LedMode.OnWhilePressed) { this.TurnLedOn(); } else if (this.Mode == LedMode.OnWhileReleased) { this.TurnLedOff(); } else if (this.Mode == LedMode.ToggleWhenPressed) { this.ToggleLED(); } break; } this.OnButtonEvent(this, state); }
private void SwPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge == GpioPinEdge.FallingEdge) { // switch down //ToggleLED(); // Cross Thread 문제가 발생!! if (isBlink == true) { tmrBlink.Stop(); } else { tmrBlink.Start(); } isBlink = !isBlink; } //throw new NotImplementedException(); }
protected override void countStep(GpioPin p, GpioPinValueChangedEventArgs args) { if (motorDrv.State == MotorState.Forward) { if (args.Edge == GpioPinEdge.FallingEdge) { Position++; } } else if (motorDrv.State == MotorState.Backward) { if (args.Edge == GpioPinEdge.RisingEdge) { Position--; } } else { System.Diagnostics.Debug.WriteLine("Read step when motor stopped."); } }
/// <summary> /// Event handler for when the GPIO pin value is changed /// </summary> /// <param name="sender">The sender object</param> /// <param name="args">Event arguements</param> private void OnValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { //default is high, so check for lows //roomba IR works by pulsing the frequency //but we only need a few downs to detect the IR //but make sure we have started the sensor reading if (!Enabled) { return; } if (args.Edge == GpioPinEdge.FallingEdge) { if (NumDetections++ >= DetectionThreshold) { WallDetected = true; //do not fire any more events since we don't have to anymore _pin.ValueChanged -= OnValueChanged; } } }
private void DataReady(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge == GpioPinEdge.FallingEdge) { if (_tcs == null) { return; } try { var r = ReadRegister(Register.ConfB, 8); MagneticField field = RegistersToMagneticField(r); _tcs.SetResult(field); } catch (Exception ex) { _tcs.SetException(ex); } } }
/// <summary> /// This interrupt will trigger when detector receives back reflected sonic pulse /// </summary> /// <param name="data1">Not used</param> /// <param name="data2">Not used</param> /// <param name="time">Transfer to endTick to calculated sound pulse travel time</param> void InterIn_OnInterrupt(object sender, GpioPinValueChangedEventArgs e) { // if (gpcc.IsStarted) { gpcc.Stop(); } // save the ticks when pulse was received back //if (e.Edge == GpioPinEdge.RisingEdge) //{ // beginTick = (long)gpcc.Read().Count; // // Console.WriteLine("begintick = " + beginTick.ToString()); //}; if (e.Edge == GpioPinEdge.FallingEdge) { etick = gpcc.Read(); //endTick = (long)gpcc.Read().Count; //Console.WriteLine("EndTick = " + endTick.ToString()); } ; //GpioChangeCount etick = gpcc.Reset(); // endTick = etick.Count; }
private async void buttonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (e.Edge != GpioPinEdge.FallingEdge) { return; } if (_timer.IsEnabled) { _timer.Stop(); _pin.Write(GpioPinValue.High); GpioText.Text = "LED stopped"; } else { _timer.Start(); GpioText.Text = "LED started"; } }); }
private void boton1_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)//Funcion que verifica el estado en boton es decir presionado o no { if (e.Edge == GpioPinEdge.FallingEdge) { valor_led = (valor_led == GpioPinValue.Low) ? //Si el valor del led es 0 lo colocara en 1 y viceversa GpioPinValue.High : GpioPinValue.Low; Led1.Write(valor_led); //Enciende el led } //Esta funcion es opcional y unicamente sirve para cuando este presionado el boton, nos muestre el estado del led //El metodo se creo como un procedimiento asincrono, ya que se ejecuta a la par de la funcion cambio del estado del boton //los colores se tienen que declarar como recursos var task = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { if (e.Edge == GpioPinEdge.FallingEdge) //Verifica el valor del led para colocar el color segun corresponda { led_virtual.Fill = (valor_led == GpioPinValue.Low) ? Rojo : Gris; } }); }
private void TriggerEchoPort_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { if (triggerEchoPort.Read() == GpioPinValue.High) { tickStart = DateTime.Now.Ticks; return; } // Calculate Difference float elapsed = DateTime.Now.Ticks - tickStart; // Return elapsed ticks // x10 for ticks to micro sec // divide by 58 for cm (assume speed of sound is 340m/s) CurrentDistance = elapsed / 580f; // if (CurrentDistance < MinimumDistance || CurrentDistance > MaximumDistance) // CurrentDistance = -1; DistanceDetected?.Invoke(this, new DistanceEventArgs(CurrentDistance)); }
private void Button_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e) { for (var i = 0; i < 4; i++) { if (sender.PinNumber == this.buttons[i].PinNumber) { var pressed = e.Edge == GpioPinEdge.FallingEdge; switch ((Button)i) { case Button.Left: (pressed ? this.WhenLeftButtonPressed : this.WhenLeftButtonReleased)?.Invoke(); break; case Button.Right: (pressed ? this.WhenRightButtonPressed : this.WhenRightButtonReleased)?.Invoke(); break; case Button.Up: (pressed ? this.WhenUpButtonPressed : this.WhenUpButtonReleased)?.Invoke(); break; case Button.Down: (pressed ? this.WhenDownButtonPressed : this.WhenDownButtonReleased)?.Invoke(); break; } } } }
private void OnEchoResponse(GpioPin sender, GpioPinValueChangedEventArgs args) { if (RobotController.SystemDispatcher == null) { NetworkUtils.LogNetwork("RobotController.SystemDispatcher is null", MessageType.Error); return; } var task = RobotController.SystemDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { switch (args.Edge) { case GpioPinEdge.FallingEdge: //session_microseconds = distanceTimer.ElapsedTicks / TICKS_PER_MICROSECOND; //distance_in_cm = session_microseconds * MICROSECONDS_TO_CM; //just using elappsed ms for now Collected_Distance = distanceTimer.ElapsedMilliseconds; if (Current_avg_itteration++ >= Total_avg_itterations) { Distance_in_cm = Avg_Distance / Total_avg_itterations; Current_avg_itteration = 1; Avg_Distance = 0; } else { if (Collected_Distance > Maximum_distance_width) { Collected_Distance = Maximum_distance_width; } Avg_Distance += Collected_Distance; } distanceTimer.Reset(); break; case GpioPinEdge.RisingEdge: //it's a response, log it! distanceTimer.Start(); break; } }); }
private void InterruptGpioPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (args.Edge != GpioPinEdge.RisingEdge) { return; } byte IrqFlags = this.RegisterManager.ReadByte(0x12); // RegIrqFlags Debug.WriteLine(string.Format("RegIrqFlags {0}", Convert.ToString(IrqFlags, 2).PadLeft(8, '0'))); if ((IrqFlags & 0b01000000) == 0b01000000) // RxDone { Debug.WriteLine("Receive-Message"); byte currentFifoAddress = this.RegisterManager.ReadByte(0x10); // RegFifiRxCurrent this.RegisterManager.WriteByte(0x0d, currentFifoAddress); // RegFifoAddrPtr byte numberOfBytes = this.RegisterManager.ReadByte(0x13); // RegRxNbBytes // Allocate buffer for message byte[] messageBytes = new byte[numberOfBytes]; for (int i = 0; i < numberOfBytes; i++) { messageBytes[i] = this.RegisterManager.ReadByte(0x00); // RegFifo } string messageText = UTF8Encoding.UTF8.GetString(messageBytes); Debug.WriteLine("Received {0} byte message {1}", messageBytes.Length, messageText); } if ((IrqFlags & 0b00001000) == 0b00001000) // TxDone { this.RegisterManager.WriteByte(0x01, 0b10000101); // RegOpMode set LoRa & RxContinuous Debug.WriteLine("Transmit-Done"); } this.RegisterManager.WriteByte(0x40, 0b00000000); // RegDioMapping1 0b00000000 DI0 RxReady & TxReady this.RegisterManager.WriteByte(0x12, 0xff); // RegIrqFlags }
// Bouton Jaune private void _pin26_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { // Détection du front montant if (args.Edge == GpioPinEdge.RisingEdge) { if (_MODE.Equals("HORLOGE")) { } else if (_MODE.Equals("REVEIL_SET")) { // Retrait d'une minute à l'horaire de réveil _M_REG = _UtilReveilDriver.removeMinute(_M_REG); _M_SON = _M_REG; } else if (_MODE.Equals("REVEIL_ON")) { if (reveil.Equals("1")) { mediaPlayerReveil.Pause(); _M_SON = _UtilReveilDriver.addMinute(_M_AFF); _M_SON = _UtilReveilDriver.addMinute(_M_SON); reveil = "0"; } } else if (_MODE.Equals("REVEIL_TYPE")) { } else if (_MODE.Equals("MP3")) { } else if (_MODE.Equals("RADIO")) { } else if (_MODE.Equals("SONNERIE")) { } } }
private async void PinPIR_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { //simple guard to prevent it from triggering this function again before it's compelted the first time - one photo at a time please if (IsInPictureCaptureMode) { return; } else { IsInPictureCaptureMode = true; } // turn off the LED because we're about to take a picture and send to Bot LightLED(false); try { StorageFile picture = await TakePicture(); if (picture != null) { UploadPictureToBot(picture); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } finally { //reset the "IsInPictureMode" singleton guard so the next //PIR movement can come into this method and take a picture IsInPictureCaptureMode = false; //Turn the LED Status Light on - we're ready for another picture LightLED(true); } return; }