C# GpioPin.SetDriveMode方法代码示例

        /// <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()
        {
            var gpio = GpioController.GetDefault();

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

            button1Pin = gpio.OpenPin(BUTTON1_PIN);
            led1Pin = gpio.OpenPin(LED1_PIN);

            // Initialize LED to the OFF state by first writing a HIGH value
            led1Pin.Write(GpioPinValue.High);
            led1Pin.SetDriveMode(GpioPinDriveMode.Output);

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

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

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

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

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

        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 gpio = GpioController.GetDefault();

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

            _buttonpin = gpio.OpenPin(BUTTON_PIN);
            _buzzerpin = gpio.OpenPin(BUZZER_PIN);

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

            _buttonpin.DebounceTimeout = TimeSpan.FromMilliseconds(50);
            _buttonpin.ValueChanged += Buttonpin_ValueChanged;

            _buzzerpin.Write(GpioPinValue.Low);
            _buzzerpin.SetDriveMode(GpioPinDriveMode.Output);

            GpioStatus.Text = "GPIO button and buzzer pin initialized correctly.";
        }

        int RCTime(GpioPin pin, int max)
        {
            pin.SetDriveMode(GpioPinDriveMode.Output);
            pin.Write(GpioPinValue.Low);

            pin.SetDriveMode(GpioPinDriveMode.Input);
            int reading = 0;
            while (pin.Read() == GpioPinValue.Low)
            {
                reading++;
                if (reading >= max) break;
            }
            return reading;
        }

        /// <summary>
        /// Attempts to initialize Gpio for application. This includes doorbell interaction and locking/unlccking of door.
        /// Returns true if initialization is successful and Gpio can be utilized. Returns false otherwise.
        /// </summary>
        public bool Initialize()
        {
            // Gets the GpioController
            gpioController = GpioController.GetDefault();
            if(gpioController == null)
            {
                // There is no Gpio Controller on this device, return false.
                return false;
            }

            // Opens the GPIO pin that interacts with the doorbel button
            doorbellPin = gpioController.OpenPin(GpioConstants.ButtonPinID);

            if (doorbellPin == null)
            {
                // Pin wasn't opened properly, return false
                return false;
            }

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

            if (doorbellPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
            {
                // Take advantage of built in pull-up resistors of Raspberry Pi 2 and DragonBoard 410c
                doorbellPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
            }
            else
            {
                // MBM does not support PullUp as it does not have built in pull-up resistors 
                doorbellPin.SetDriveMode(GpioPinDriveMode.Input);
            }

            // Opens the GPIO pin that interacts with the door lock system
            doorLockPin = gpioController.OpenPin(GpioConstants.DoorLockPinID);
            if(doorLockPin == null)
            {
                // Pin wasn't opened properly, return false
                return false;
            }
            // Sets doorbell pin drive mode to output as pin will be used to output information to lock
            doorLockPin.SetDriveMode(GpioPinDriveMode.Output);
            // Initializes pin to high voltage. This locks the door. 
            doorLockPin.Write(GpioPinValue.High);

            //Initialization was successfull, return true
            return true;
        }

        /// <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;
        }

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

        private bool initGPIO() {
            //Czy jest GPIO?
            if (!Windows.Foundation.Metadata.ApiInformation.IsApiContractPresent("Windows.Devices.DevicesLowLevelContract",1))
                return false;
            if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Devices.Gpio.GpioController"))
                return false;
            if (!Windows.Foundation.Metadata.ApiInformation.IsMethodPresent("Windows.Devices.Gpio.GpioController", "GetDefault"))
                return false;

            if (Windows.System.Profile.AnalyticsInfo.VersionInfo.DeviceFamily != "Windows.IoT")
                return false;
            //Windows.System.Profile.AnalyticsInfo.DeviceForm
            var gpio = GpioController.GetDefault();
            if (gpio == null) {
                pinLED = null;
                return false;
            }
            pinLED = gpio.OpenPin(LED_PIN);
            if (pinLED == null) return false;
            pinLED.SetDriveMode(GpioPinDriveMode.Output);
            pinPIR = gpio.OpenPin(PIR_PIN);
            if (pinPIR == null) return false;
            pinPIR.SetDriveMode(GpioPinDriveMode.Input);
            pinPIR.ValueChanged += PinPIR_ValueChanged;

            setState(false); //Zawsze zmienia stan - zapisuje do pin
            return true;
        }

        public void Run(IBackgroundTaskInstance taskInstance)
        {
            //
            // TODO: Insert code to perform background work
            //
            // If you start any asynchronous methods here, prevent the task
            // from closing prematurely by using BackgroundTaskDeferral as
            // described in http://aka.ms/backgroundtaskdeferral
            //
            var gpio = GpioController.GetDefault();

            // Show an error if there is no GPIO controller
            if (gpio == null)
            {
                pin = null;
                return;
            }

            pin = gpio.OpenPin(27);
            pin.Write(GpioPinValue.High);
            pin.SetDriveMode(GpioPinDriveMode.Output);

            while (true)
            {

            }
        }

        private void InitGPIO()
        {
            _pin = GpioController.GetDefault().OpenPin(_pinNumber);

            _pin.Write(GpioPinValue.High);
            _pin.SetDriveMode(GpioPinDriveMode.Output);
        }

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

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

            redpin = gpio.OpenPin(REDLED_PIN);
            bluepin = gpio.OpenPin(BLUELED_PIN);
            greenpin = gpio.OpenPin(GREENLED_PIN);

            redpin.Write(GpioPinValue.High);
            redpin.SetDriveMode(GpioPinDriveMode.Output);
            bluepin.Write(GpioPinValue.High);
            bluepin.SetDriveMode(GpioPinDriveMode.Output);
            greenpin.Write(GpioPinValue.High);
            greenpin.SetDriveMode(GpioPinDriveMode.Output);

            GpioStatus.Text = "GPIO red/green/blue pin initialized correctly";
        }

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

        private bool 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;
                return false;
            }

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

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

            return true;
        }