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