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; }
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 MotionSensorPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args) { if (OnChanged != null) { OnChanged(this, args); } }
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; }
// // Constructor // public TLC5947ControllerBase(uint latchPin, uint blackoutPin) { // Create the controller m_controller = new LedController(this, ControlerUpdateType.AllSlots); // Open the latch pin GpioController controller = GpioController.GetDefault(); m_latchPin = controller.OpenPin((int)latchPin); m_latchPin.SetDriveMode(GpioPinDriveMode.Output); // Open the black out pin, set it high and low to reset the device. m_blackoutPin = controller.OpenPin((int)blackoutPin); m_blackoutPin.SetDriveMode(GpioPinDriveMode.Output); m_blackoutPin.Write(GpioPinValue.High); m_blackoutPin.Write(GpioPinValue.Low); // Create a async task to setup SPI new Task(async () => { // Create the settings var settings = new SpiConnectionSettings(SPI_CHIP_SELECT_LINE); // Max SPI clock frequency, here it is 30MHz settings.ClockFrequency = 30000000; settings.Mode = SpiMode.Mode0; // Find the selector string for the SPI bus controller string spiAqs = SpiDevice.GetDeviceSelector(SPI_CONTROLLER_NAME); // Find the SPI bus controller device with our selector string var devicesInfo = await DeviceInformation.FindAllAsync(spiAqs); // Create an SpiDevice with our bus controller and SPI settings m_spiDevice = await SpiDevice.FromIdAsync(devicesInfo[0].Id, settings); }).Start(); }
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 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 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 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) { } }
public ServoDriver(GpioPin servoPin, ServoPulseModel servoPulseModel) { _servoPin = servoPin; _servoPin.SetDriveMode(GpioPinDriveMode.Output); _servoPulseModel = servoPulseModel; _servoBackgroundTask = Windows.System.Threading.ThreadPool.RunAsync(this.ServoBackgrounTask, Windows.System.Threading.WorkItemPriority.High); }
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); } } }