private void buttonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
        {
            // toggle the state of the LED every time the button is pressed
            if (e.Edge == GpioPinEdge.FallingEdge)
            {
                ledPinValue = (ledPinValue == GpioPinValue.Low) ?
                    GpioPinValue.High : GpioPinValue.Low;
                ledPin.Write(ledPinValue);
            }

            // 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)
                {
                    ledEllipse.Fill = (ledPinValue == GpioPinValue.Low) ? 
                        redBrush : grayBrush;
                    GpioStatus.Text = "Button Pressed";
                }
                else
                {
                    GpioStatus.Text = "Button Released";
                }
            });
        }

 private void InputPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if(args.Edge == GpioPinEdge.FallingEdge)
     {
         AccumulatedTotal = AccumulatedTotal + LitersPerPulse;
     }
 }

        /// <summary>
        /// Event called when GPIO PIN 16 changes (PIR signal)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        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 sound at a time please
            if (IsPlaying)
                return;
            else
                IsPlaying = true;
            try
            {
                await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                async () =>
                {
                  PIRStatus.Text = "New PIR pin value: " + args.Edge.ToString();
                 //SoundPlayer mantra = new SoundPlayer(@"C:\WINDOWS\Media\mantra.wav");
                 SoundPlayer mantra = new SoundPlayer(Resource1.mantra);

                  mantra.Play();
                    
                   });
            }
            catch (Exception ex)
            {
                await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                () =>
                {
                    PIRStatus.Text = "PIR Error: " + ex.Message;
                });
            }
            finally
            {
                isPlaying = false;
            }

            return;
        }

 private void Pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if (pin.Read() == GpioPinValue.High)
     {
         int bla;
     }
 }

        private void buttonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
        {
            //// toggle the state of the LED every time the button is pressed
            //if (e.Edge == GpioPinEdge.FallingEdge)
            //{
            //    ledPinValue = (ledPinValue == GpioPinValue.Low) ?
            //        GpioPinValue.High : GpioPinValue.Low;
            //    ledPin.Write(ledPinValue);
            //} 

            // 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 (buttonPin.Read() == GpioPinValue.High)
                {
                    ledPinValue = GpioPinValue.High;
                    ledEllipse.Fill = grayBrush;
                    ledPin.Write(ledPinValue);
                    GpioStatus.Text = "No Mouse...";
                    SendMessageToIoTHubAsync(1);
                }
                if (buttonPin.Read() == GpioPinValue.Low)
                {
                    ledPinValue = GpioPinValue.Low;
                    ledEllipse.Fill = redBrush;
                    ledPin.Write(ledPinValue);
                    GpioStatus.Text = "Dead Mouse...";
                    SendMessageToIoTHubAsync(2);
                }
            });
        }

        private async void pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
                if (args.Edge.CompareTo(GpioPinEdge.RisingEdge) == 0)
                {
                    //Motion Detected UI
                    UiAlert();

                    //Create JSON payload
                    var json = string.Format("{{sensor:Motion,  room:MsConfRoom1,  utc:{0}}}", DateTime.UtcNow.ToString("MM/dd/yyyy_HH:mm:ss"));
                    var data = new ASCIIEncoding().GetBytes(json);

                    //POST Data
                    string url = "https://rrpiot.azurewebsites.net/SensorData";
                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                    request.Method = "POST";
                    request.ContentType = "application/json";
                    using (Stream myStream = await request.GetRequestStreamAsync())
                    {
                        myStream.Write(data, 0, data.Length);
                    }
                    await request.GetResponseAsync();
                }
                else
                {
                    //Display No Motion Detected UI
                    UiNoMotion();
                }

        }

 private void MotionSensorPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if (OnChanged != null)
     {
         OnChanged(this, args);
     }
 }

        private void M_cadence_sensor_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            if (args.Edge == GpioPinEdge.RisingEdge)
            {
                Debug.WriteLine("{0} Pedal Sensor", DateTime.Now);

                //TimeSpan cadence_interval = DateTime.Now - m_last_cadence;

                //m_last_cadence = DateTime.Now;

                m_cadence_blips.Enqueue(DateTime.Now);

                if (m_cadence_blips.Count > 5)
                {
                    m_cadence_blips.Dequeue();
                }

                if (m_cadence_blips.Count > 2)
                {

                    double cadence_interval = (m_cadence_blips.Last() - m_cadence_blips.First()).TotalSeconds / m_cadence_blips.Count;

                    Debug.WriteLine("Interval = {0} (count = {1})", cadence_interval, m_cadence_blips.Count);

                    RPM = (int)Math.Floor(30 / cadence_interval); //its 60 divided by 2 due to the 2 magnets
                }

            }
        }

        private void ValueChangedHandler(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            var pinNumber = sender.PinNumber;
            var gpioPinValue = sender.Read();
            Debug.WriteLine("Pin {0} changed to {1}", pinNumber, gpioPinValue);

            if (pinNumber == TiltSensorPin)
            {
                _halper.DishwasherTilt(gpioPinValue == GpioPinValue.High);
                var currentStatus = _halper.Get().CurrentStatus;
                if (currentStatus == DishwasherStatus.Clean && gpioPinValue == GpioPinValue.High)
                {
                    ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromMilliseconds(10000));
                }
                return;
            }

            var tiltSensorValue = _gpioSensors[TiltSensorPin].Read();
            if (gpioPinValue == GpioPinValue.High)
            {
                if (pinNumber == CleanLightPin)
                {
                    _halper.EndDishwasherRun();
                }
                else if (tiltSensorValue == GpioPinValue.Low && _pinToCycleTypeMap.ContainsKey(pinNumber))
                {
                    _halper.StartDishwasherRun(_pinToCycleTypeMap[pinNumber]);
                }
            }
        }

 private void handleButton(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     Debug.WriteLine("Value Change on pin:" + sender.PinNumber + " : " + args.Edge);
     TelemetryManager.WriteTelemetryEvent("Action_PhysicalButton");
     if (args.Edge == GpioPinEdge.RisingEdge)
     {
         switch (this.buttonPins[sender.PinNumber])
         {
             case InputAction.NextChannel:
                 this.playlistManager.NextTrack();
                 break;
             case InputAction.PreviousChannel:
                 this.playlistManager.PreviousTrack();
                 break;
             case InputAction.VolumeUp:
                 this.playbackManager.Volume += 0.1;
                 break;
             case InputAction.VolumeDown:
                 this.playbackManager.Volume -= 0.1;
                 break;
             case InputAction.Sleep:
                 if (PowerState.Powered == this.powerManager.PowerState)
                 {
                     this.powerManager.PowerState = PowerState.Standby;
                 }
                 else
                 {
                     this.powerManager.PowerState = PowerState.Powered;
                 }
                 break;
         }
     }
 }

        private void Pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
        {
            var edge = e.Edge;
            if ((pressedValue == GpioPinValue.High) && (edge == GpioPinEdge.RisingEdge))
            {
                isPressed = true;
            }
            else if ((pressedValue == GpioPinValue.Low) && (edge == GpioPinEdge.FallingEdge))
            {
                isPressed = true;
            }
            else
            {
                isPressed = false;
            }

            // Notify
            if (isPressed)
            {
                pressedEvent.Raise(owner, EmptyEventArgs.Instance);
                if (ClickMode == ButtonClickMode.Press)
                {
                    clickEvent.Raise(owner, EmptyEventArgs.Instance);
                }
            }
            else
            {
                releasedEvent.Raise(owner, EmptyEventArgs.Instance);
                if (ClickMode == ButtonClickMode.Release)
                {
                    clickEvent.Raise(owner, EmptyEventArgs.Instance);
                }
            }
        }

        private void OverCurrentPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            bool state_changed = false;
            GpioPinValue curr_pin_value = _pin.Read();

            // Detect a change in pin state
            if ( (_last_pin_value == INACTIVE &&  curr_pin_value == ACTIVE) ||
                 (_last_pin_value == ACTIVE && curr_pin_value == INACTIVE) )
            {
                state_changed = true;
            }

            _last_pin_value = curr_pin_value;

            if (curr_pin_value == ACTIVE)
            {
                _state = DETECT_STATE;
            }
            else
            {
                _state = NO_DETECT_STATE;
            }

            // Send an alert only on a change
            if (state_changed)
            {                
                foreach (var callback in _alert_callbacks)
                {
                    callback("overcurrent:" + _id + ":" + _state);
                }
            }

        }

 private void ButtonpinValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     // Just shutdown on one edge
     if (args.Edge == GpioPinEdge.RisingEdge)
     {
         ShutdownManager.BeginShutdown(ShutdownKind.Shutdown, TimeSpan.FromSeconds(0.5));
     }
 }

 private void irqPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if (args.Edge != GpioPinEdge.FallingEdge) return;
     _logger.Trace("IRQ Event Received!");
     RegisterContainer.StatusRegister.Load();
     Interrupted?.Invoke(this, new InterruptedEventArgs { StatusRegister = RegisterContainer.StatusRegister });
     _irqPin.Write(GpioPinValue.High);
 }

 /*******************************************************************************************
 * PRIVATE METHODS
 ********************************************************************************************/
 private async void PirSensor_OnChanged(object sender, GpioPinValueChangedEventArgs e)
 {
     //Start the timer for the duration of motion
     if (e.Edge == GpioPinEdge.FallingEdge)
     {
         await TakePhotoAsync();
     }
 }

        private void Interrupt(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            if (device == null)
                return;

            int interruptStatus = readWriteHelper.ReadByte(Constants.IntStatus);
            if ((interruptStatus & 0x10) != 0)
                readWriteHelper.WriteByte(Constants.UserCtrl, 0x44); // reset and enable fifo

            if ((interruptStatus & 0x1) == 0)
                return;

            var ea = new MpuSensorEventArgs
            {
                Status = (byte)interruptStatus,
                SamplePeriod = 0.02f
            };

            var l = new List<MpuSensorValue>();

            int count = readWriteHelper.ReadWord(Constants.FifoCount);

            while (count >= Constants.SensorBytes)
            {
                var data = readWriteHelper.ReadBytes(Constants.FifoRW, Constants.SensorBytes);
                count -= Constants.SensorBytes;

                var xa = (short)(data[0] << 8 | data[1]);
                var ya = (short)(data[2] << 8 | data[3]);
                var za = (short)(data[4] << 8 | data[5]);

                var xg = (short)(data[6] << 8 | data[7]);
                var yg = (short)(data[8] << 8 | data[9]);
                var zg = (short)(data[10] << 8 | data[11]);

                var sv = new MpuSensorValue
                {
                    AccelerationX = xa / (float)16384,
                    AccelerationY = ya / (float)16384,
                    AccelerationZ = za / (float)16384,
                    GyroX = xg / (float)131,
                    GyroY = yg / (float)131,
                    GyroZ = zg / (float)131
                };

                l.Add(sv);
            }

            ea.Values = l.ToArray();

            if (SensorInterruptEvent == null)
                return;

            if (ea.Values.Length > 0)
                SensorInterruptEvent(this, ea);
        }

        private void FlowPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            GpioPinValue state = _pin.Read();

            if (_last_flow_state == GpioPinValue.Low && state == GpioPinValue.High)
            {
                _low_to_high_count++;
            }
            _last_flow_state = state;
        }

        private void OnValueChanged( GpioPin sender, GpioPinValueChangedEventArgs args )
        {
            EventHandler eventToFire = args.Edge == GpioPinEdge.FallingEdge
                ? this.Pushed
                : this.Released;

            if( eventToFire != null )
            {
                eventToFire( this, new EventArgs() );
            }
        }

 private void _forwardButton_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if (forwardButton.Read() == GpioPinValue.Low)
     {
         currentPulseWidth = ForwardPulseWidth;
     }
     else
     {
         currentPulseWidth = 0;
     }
 }

 private void CheckParking(GpioPin sender, GpioPinValueChangedEventArgs args)
 {
     if (switch_right.Read() == GpioPinValue.High && switch_left.Read() == GpioPinValue.High) //When both switches are pressed
     {
         led_blue.Write(GpioPinValue.Low); //Turn on blue LED
     }
     else
     {
         led_blue.Write(GpioPinValue.High); //Turn off blue LED
     }
 }