public override void Init()
        {
            Debug.WriteLine("Initializing push button.");

            try
            {
                _pushButtonPin = _gpioController.OpenPin(Pin);

                if (_pushButtonPin == null)
                {
                    Debug.WriteLine(string.Format("Push button pin not found at GPIO {0}.", Pin));
                    throw new Exception(string.Format("Push button pin not found at GPIO {0}.", Pin));
                }
                else
                {
                    Debug.WriteLine(string.Format("Push button initialized at GPIO {0}.", Pin));
                }

                if (_pushButtonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
                    _pushButtonPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
                else
                    _pushButtonPin.SetDriveMode(GpioPinDriveMode.Input);

                _pushButtonPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);

                _pushButtonPin.ValueChanged += _pushButtonPin_ValueChanged;

                Debug.WriteLine("Push button initialized.");
            }
            catch
            {
                Debug.WriteLine("Failed to initialize push button.");
                throw new Exception("Failed to initialize push button.");
            }
        }

        private void InitGPIO()
        {
            var mygpio = GpioController.GetDefault();

            // Show an error if there is no GPIO controller
            if (mygpio == null)
            {
                buttonPin = null;
                ledPin = null;
                return;
            }
            ledPin = mygpio.OpenPin(LEDPINNBR);
            ledPin.Write(GpioPinValue.Low); //initialize Led to On as wired in active Low config (+3.3-Led-GPIO)
            ledPin.SetDriveMode(GpioPinDriveMode.Output);

            buttonPin = mygpio.OpenPin(BUTTONPINNBR);
            //buttonPin.Write(GpioPinValue.High);
            //buttonPin.SetDriveMode(GpioPinDriveMode.Output);
            //buttonPinValCurrent = buttonPin.Read();
            buttonPin.SetDriveMode(GpioPinDriveMode.Input);
            //buttonPinValPrior = GpioPinValue.High;

            Debug.WriteLine("ButtonPin Value at Init: " + buttonPin.Read() + ",      with Pin ID = " + buttonPin.PinNumber);

            //buttonPinVal = buttonPin.Read();
            // Set a debounce timeout to filter out switch bounce noise from a button press
            buttonPin.DebounceTimeout = TimeSpan.FromMilliseconds(20);

            // Register for the ValueChanged event so our buttonPin_ValueChanged
            // function is called when the button is pressed
            buttonPin.ValueChanged += buttonPressAction;
        }

        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 InitGPIO()
        {
            // Initialize the GPIO controller
            GpioController gpio = GpioController.GetDefault();

            // Show an error if there is no GPIO controller
            if (gpio == null)
            {
                _pin1 = null;
                _pin2 = null;
                GpioStatus.Text = "There is no GPIO controller on this device.";
                return;
            }

            // Initialize the GPIO pin for the first LED
            _pin1 = gpio.OpenPin(LED1_PIN);
            _pin1.Write(GpioPinValue.Low);
            _pin1.SetDriveMode(GpioPinDriveMode.Output);

            // Initialize the LED1 Ellipse to draw Gray
            LED1.Fill = _grayBrush;

            // Initialize the GPIO pin for the second LED
            _pin2 = gpio.OpenPin(LED2_PIN);
            _pin2.Write(GpioPinValue.Low);
            _pin2.SetDriveMode(GpioPinDriveMode.Output);

            // Initialize the LED2 Ellipse to draw Gray
            LED2.Fill = _grayBrush;

            // Show the GPIO is OK message
            GpioStatus.Text = "GPIO pin initialized correctly.";
        }

        private void InitGPIO()
        {
            GpioController gpio = null;
            try
            {
                gpio = GpioController.GetDefault();
            }
            catch (Exception e)
            {
                GpioStatus.Text = e.Message;
            }

            if (gpio == null)
            {
                _pin = null;
                GpioStatus.Text = "There is no GPIO controller on this device.";
                return;
            }

            _pin = gpio.OpenPin(LED_PIN);
            _pinValue = GpioPinValue.High;
            _pin.Write(_pinValue);
            _pin.SetDriveMode(GpioPinDriveMode.Output);

            GpioStatus.Text = "GPIO pin intitialized correctly.";
        }

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

        private void InitializeGpio()
        {
            var gpio = GpioController.GetDefault();

            if (gpio == null)
            {
                GpioStatus.Text = "There is no GPIO controller on this device.";
                return;
            }

            buttonPin = gpio.OpenPin(BUTTON_PIN);

            if ( buttonPin == null)
            {
                GpioStatus.Text = "Unable to open button pin.";
                return;
            }

            // Button is in a active high configuration which means it will go to high when pressed
            // Take advantage of the Raspberry Pi's built in pull down resistors
            buttonPin.SetDriveMode(GpioPinDriveMode.InputPullDown);

            // Set a debounce timeout to filter out the ups and downs from a button press
            buttonPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);

            // Register for the ValueChanged event - aka when the button is pushed
            buttonPin.ValueChanged += buttonPin_ValueChanged;

            GpioStatus.Text = "GPIO pins initialized correctly.";
        }

        private void InitGPIO()
        {
            var gpio = GpioController.GetDefault();

            // error prompt
            if (gpio == null) {
                GpioStatus.Text = "There's no GPIO controller on this device";
                return -1;
            }

            buttonPin = gpio.OpenPin(BUTTON_PIN);
            ledPin = gpio.OpenPin(LED_PIN);

            // init LED to OFF by HIGH, cuz LED is wired in LOW config
            ledPin.Write(GpioPinValue.High);
            ledPin.SetDriveMode(GpioPinDriveMode.Output);

            // checking if input pull-up resistors are supported
            if (buttonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp)) {
                buttonPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
            }
            else {
                buttonPin.SetDriveMode(GpioPinDriveMode.Input);
            }

            // setting debounce timeout
            buttonPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);

            // register for ValueChanged event
            // so buttonPin_ValueChanged()
            // is called when button is pressed
            buttonPin.ValueChanged += buttonPin_ValueChanged;

            GpioStatus.Text = "GPIO pins initialized correctly";
        }

        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]);
                }
            }
        }

 public void AddPin(int pinNumber, GpioPin pin)
 {
     lock (m_pinMap)
     {
         m_pinMap[pin.PinNumber] = pin;
     }
 }

        public void Run(IBackgroundTaskInstance taskInstance)
        {
            deferral = taskInstance.GetDeferral();

            //Motor starts off
            currentPulseWidth = 0;

            //The stopwatch will be used to precisely time calls to pulse the motor.
            stopwatch = Stopwatch.StartNew();

            GpioController controller = GpioController.GetDefault();

            //Buttons are attached to pins 5 and 6 to control which direction the motor should run in
            //Interrupts (ValueChanged) events are used to notify this app when the buttons are pressed
            forwardButton = controller.OpenPin(5);
            forwardButton.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 250);
            forwardButton.SetDriveMode(GpioPinDriveMode.Input);
            forwardButton.ValueChanged += _forwardButton_ValueChanged;

            backwardButton = controller.OpenPin(6);
            backwardButton.SetDriveMode(GpioPinDriveMode.Input);
            forwardButton.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 250);
            backwardButton.ValueChanged += _backgwardButton_ValueChanged;


            servoPin = controller.OpenPin(13);
            servoPin.SetDriveMode(GpioPinDriveMode.Output);

            
           

            //You do not need to await this, as your goal is to have this run for the lifetime of the application
            Windows.System.Threading.ThreadPool.RunAsync(this.MotorThread, Windows.System.Threading.WorkItemPriority.High);
        }

        /// <summary>
        /// 
        /// </summary>
        private void InitGpio()
        {
            var gpio = GpioController.GetDefault();
            if (gpio== null)
            {
                Debug.WriteLine("Can't find GpioController.");
                return;
            }

            pin = gpio.OpenPin(inputPin);

            if (pin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
            {
                pin.SetDriveMode(GpioPinDriveMode.InputPullUp);
            }
            else
            {
                pin.SetDriveMode(GpioPinDriveMode.Input);
            }

            Debug.WriteLine("GPIO initializing...");

            //Sleep
            for (int i = 0; i <= 10000; i++) { }

            //Event
            pin.ValueChanged += Pin_ValueChanged;

            Debug.WriteLine("GPIO initialized.");
        }

        private void InitGPIO()
        {
            if (!ApiInformation.IsTypePresent(GpioPresentNS))
            {
                return;
            }

            var gpio = GpioController.GetDefault();
            if (gpio == null)
            {
                Debug.WriteLine("There is no GPIO controller on this device.");
                return;
            }

            var buttonPin = gpio.OpenPin(ButtonPin);
            ledPin = gpio.OpenPin(LedPin);

            // Initialize LED to the OFF state by first writing a HIGH value
            // We write HIGH because the LED is wired in a active LOW configuration
            ledPin.Write(GpioPinValue.High);
            ledPin.SetDriveMode(GpioPinDriveMode.Output);

            // Check if input pull-up resistors are supported
            if (buttonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
                buttonPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
            else
                buttonPin.SetDriveMode(GpioPinDriveMode.Input);

            // Set a debounce timeout to filter out switch bounce noise from a button press
            buttonPin.DebounceTimeout = TimeSpan.FromMilliseconds(100);

            buttonPin.ValueChanged += ButtonPin_ValueChanged;
        }

        public MainPage()
        {
            this.InitializeComponent();

            // call the method to initialize variables and hardware components
            InitHardware();

            // set interval of timer to 1 second
            _dispatchTimer.Interval = TimeSpan.FromSeconds(1);

            // invoke a method at each tick (as per interval of your timer)
            _dispatchTimer.Tick += _dispatchTimer_Tick;

            // initialize pin (GPIO pin on which you have set your temperature sensor)
            _temperaturePin = GpioController.GetDefault().OpenPin(4, GpioSharingMode.Exclusive);

            // create instance of a DHT11 
            _dhtInterface = new Dht11(_temperaturePin, GpioPinDriveMode.Input);

            // start the timer
            _dispatchTimer.Start();

            // set start date time
            _startedAt = DateTimeOffset.Now;
        }

        /// <summary>
        ///   Initializes SPI connection and control pins
        /// </summary>
        public void Initialize(SpiMode spiMode, int chipSelectPin, int chipEnablePin, int interruptPin)
        {
            var gpio = GpioController.GetDefault();
            // Chip Select : Active Low
            // Clock : Active High, Data clocked in on rising edge
            _spiDevice = InitSpi(chipSelectPin, spiMode).Result;

            _irqPin = gpio.OpenPin(interruptPin);
            _irqPin.SetDriveMode(GpioPinDriveMode.InputPullUp);

            // Initialize IRQ Port
            // _irqPin = new InterruptPort(interruptPin, false, Port.ResistorMode.PullUp,
            //                            Port.InterruptMode.InterruptEdgeLow);
            _irqPin.ValueChanged += _irqPin_ValueChanged;

            _cePin = gpio.OpenPin(chipEnablePin);
            // Initialize Chip Enable Port
            _cePin.SetDriveMode(GpioPinDriveMode.Output);

            // Module reset time
            var task = Task.Delay(100);
            task.Wait();

            _initialized = true;
        }

        public async Task InitAsync()
        {
            if (!init)
            {
                var gpio = GpioController.GetDefault();

                if (gpio != null)
                {
                    gpioPinTrig = gpio.OpenPin(trigGpioPin);
                    gpioPinEcho = gpio.OpenPin(echoGpioPin);
                    gpioPinTrig.SetDriveMode(GpioPinDriveMode.Output);
                    gpioPinEcho.SetDriveMode(GpioPinDriveMode.Input);
                    gpioPinTrig.Write(GpioPinValue.Low);

                    //first time ensure the pin is low and wait two seconds
                    gpioPinTrig.Write(GpioPinValue.Low);
                    await Task.Delay(2000);
                    init = true;
                }
                else
                {
                    throw new InvalidOperationException("Gpio not present");
                }
            }
        }

        public IOProvider(Container container)
        {
            m_Container = container;

            if (m_Controller != null)
            {
                m_NextPagePin = m_Controller.OpenPin(NextPagePin);
                m_NextSubRedditPin = m_Controller.OpenPin(NextSubRedditPin);
                m_ShutdownPin = m_Controller.OpenPin(ShutdownPin);
            }

            if (m_ShutdownPin != null)
            {
                m_ShutdownPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
                m_ShutdownPin.DebounceTimeout = DebounceTimeout;
                m_ShutdownPin.ValueChanged += InputValueChanged;
            }

            if (m_NextPagePin != null)
            {
                m_NextPagePin.SetDriveMode(GpioPinDriveMode.InputPullUp);
                m_NextPagePin.DebounceTimeout = DebounceTimeout;
                m_NextPagePin.ValueChanged += InputValueChanged;
            }

            if (m_NextSubRedditPin != null)
            {
                m_NextSubRedditPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
                m_NextSubRedditPin.DebounceTimeout = DebounceTimeout;
                m_NextSubRedditPin.ValueChanged += InputValueChanged;
            }
        }

        private double PulseIn(GpioPin echoPin, GpioPinValue value)
        {
            var t = Task.Run(() =>
            {
                //Recieve pusle
                while (this.echoPin.Read() != value)
                {
                }
                timeWatcher.Start();

                while (this.echoPin.Read() == value)
                {
                }
                timeWatcher.Stop();
                //Calculating distance
                double distance = timeWatcher.Elapsed.TotalSeconds * 17000;
                return distance;
            });
            bool didComplete = t.Wait(TimeSpan.FromMilliseconds(100));
            if(didComplete)
            {
                return t.Result;
            }
            else
            {
                return 0.0;                
            }
        }

 private void InitGPIO()
 {
     var gpio = GpioController.GetDefault();
     _pinMotion = gpio.OpenPin(LED_MOTION);
     _pinMotion.SetDriveMode(GpioPinDriveMode.Input);
     _pinMotion.ValueChanged += _pinMotion_ValueChanged;
 }

 public MotionSensor()
 {
     var gpioController = GpioController.GetDefault();
     motionSensorPin = gpioController.OpenPin(App.Controller.XmlSettings.GpioMotionPin);
     motionSensorPin.SetDriveMode(GpioPinDriveMode.Input);
     motionSensorPin.ValueChanged += MotionSensorPin_ValueChanged;
 }