private async void btnInitialize_Click(object sender, RoutedEventArgs e)
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
gpioController = await GpioController.GetDefaultAsync();
if (gpioController == null)
{
return;
}
pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider());
if (pwmControllers == null)
{
return;
}
LeftMotor = new MotorControl(gpioController, pwmControllers[1]);
LeftMotor.Initialize(LEFTINA, LEFTINB, LEFTPWM);
RightMotor = new MotorControl(gpioController, pwmControllers[1]);
RightMotor.Initialize(RIGHTINA, RIGHTINB, RIGHTPWM);
}
private async Task InitPlantMonitoringSystem()
{
try
{
_bme280Sensor = new BMP280Sensor33();
await _bme280Sensor.InitializeAsync();
_relaySensorLightPins = new List <GpioPin>(3);
_gpioController = await GpioController.GetDefaultAsync();
foreach (HydroPonicLights hydro in Enum.GetValues(typeof(HydroPonicLights)))
{
_relaySensorLightPins.Add(
_gpioController.OpenPin(
(int)Enum.GetValues(typeof(HydroPonicLightsPinMap)).GetValue((int)hydro)));
_relaySensorLightPins[(int)hydro].SetDriveMode(GpioPinDriveMode.Output);
_relaySensorLightPins[(int)hydro].Write(GpioPinValue.Low);
}
HydroponicPlantData = new HydroponicPlantData();
_dhtTemeratureSensor.RunDHTSensor(12, _gpioController, TimeSpan.FromMilliseconds(1000));
_dhtTemeratureSensor.DhtValuesChanged += OnDhtTemperatureChange;
}
catch (Exception ex)
{
Debug.WriteLine($"{nameof(InitPlantMonitoringSystem)} threw exception: {ex.Message}");
}
}
private async Task InitGPIO()
{
try
{
GpioController gpioController = await GpioController.GetDefaultAsync();
// When applying the sleep function, note that the fan stops working when you sleep and the
// fan restart requires at least 30 Sec settling time, so to obtain accurate data,
// the sleep wake-up after the sensor working time should not be less then 30 seconds.
if (_sleepPin > 0)
{
_sleepGPIOPin = gpioController.OpenPin(_sleepPin, GpioSharingMode.Exclusive);
_sleepGPIOPin.SetDriveMode(GpioPinDriveMode.Output);
_sleepGPIOPin.Write(GpioPinValue.High); //low is sleep mode, high is active
}
if (_resetPin > 0)
{
_resetGPIOPin = gpioController.OpenPin(_resetPin, GpioSharingMode.Exclusive);
_resetGPIOPin.SetDriveMode(GpioPinDriveMode.Output);
_resetGPIOPin.Write(GpioPinValue.High); //low resets the sensor
}
}
catch (Exception ex)
{
throw new Exception("UART Initialise Error", ex);
}
}
public MainPage()
{
this.InitializeComponent();
Func <Task> runner = async() =>
{
var controller = await GpioController.GetDefaultAsync();
var pin17 = controller.OpenPin(17);
var pin18 = controller.OpenPin(18);
pin17.SetDriveMode(GpioPinDriveMode.Output);
pin18.SetDriveMode(GpioPinDriveMode.Output);
var value = GpioPinValue.Low;
while (true)
{
pin17.Write(value);
value = value == GpioPinValue.Low ? GpioPinValue.High : GpioPinValue.Low;
pin18.Write(value);
await Task.Delay(1000);
}
};
_run = runner();
}
private async Task SetupButton()
{
var gpio = await GpioController.GetDefaultAsync();
if (gpio == null)
{
this.txtMessages.Text = "No GPIO controller found!";
return;
}
GpioButtonPin = gpio.OpenPin(ButtonPinNr);
GpioButtonPin.SetDriveMode(GpioButtonPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp)
? GpioPinDriveMode.InputPullUp
: GpioPinDriveMode.Input);
GpioButtonPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);
GpioButtonPin.ValueChanged += ButtonPin_ValueChanged;
var timer = new DispatcherTimer {
Interval = TimeSpan.FromMilliseconds(500)
};
timer.Tick += Timer_Tick;
timer.Start();
}
private async void initializePins()
{
GpioController gpio = await GpioController.GetDefaultAsync();
if (gpio == null)
{
System.Diagnostics.Debug.WriteLine("There is no Gpio controller on this device");
return;
}
chipSelect = gpio.OpenPin(8);
minSout = gpio.OpenPin(9);
moutSin = gpio.OpenPin(10);
sourceClock = gpio.OpenPin(11);
chipSelect.SetDriveMode(GpioPinDriveMode.Output);
minSout.SetDriveMode(GpioPinDriveMode.Input);
moutSin.SetDriveMode(GpioPinDriveMode.Output);
sourceClock.SetDriveMode(GpioPinDriveMode.Output);
chipSelect.Write(GpioPinValue.High);
moutSin.Write(GpioPinValue.Low);
sourceClock.Write(GpioPinValue.Low);
System.Diagnostics.Debug.WriteLine("The SPI pins have been initialized");
spiIsInitialized = true;
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
// ***
// *** Get a reference to the GPIO Controller.
// ***
var controller = await GpioController.GetDefaultAsync();
// ***
// *** Make sure the reference is valid (that e are connected to a device with
// *** a GPIO Controller.
// ***
if (controller == null)
{
return;
}
// ***
// *** Set up the data pin.
// ***
var dataPin = controller.OpenPin(DataPinNumber, GpioSharingMode.Exclusive);
// ***
// *** Create the sensor.
// ***
_sensor = new Dht11(dataPin);
// ***
// *** Start the timer.
// ***
_timer.Start();
}
private async void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider());
var pwmController = pwmControllers[1]; // the on-device controller
pwmController.SetDesiredFrequency(50); // try to match 50Hz
_pin27 = pwmController.OpenPin(27);
_pin27.SetActiveDutyCyclePercentage(0);
_pin27.Start();
}
var gpioController = await GpioController.GetDefaultAsync();
if (gpioController == null)
{
StatusMessage.Text = "There is no GPIO controller on this device.";
return;
}
_pin22 = gpioController.OpenPin(22);
_pin22.SetDriveMode(GpioPinDriveMode.Output);
_pin22.Write(GpioPinValue.Low);
}
private async void OnPageLoad(object sender, RoutedEventArgs e)
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
var gpioController = await GpioController.GetDefaultAsync();
if (gpioController == null)
{
return;
}
var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider());
pwmController = pwmControllers[1]; //hard code from examples to use index 1
pwmController.SetDesiredFrequency(1000); //do *not* debug over this line, it will crash
rightDrive = pwmController.OpenPin(13);
rightDrive.SetActiveDutyCyclePercentage(0.5);
rightDrive.Start();
leftDrive = pwmController.OpenPin(12);
leftDrive.SetActiveDutyCyclePercentage(0.5);
leftDrive.Start();
}
private async Task InitGpioAsync()
{
// Get the default GPIO controller
var gpio = await GpioController.GetDefaultAsync();
// If the default GPIO controller is not present, then the device
// running this app isn't capable of GPIO operations.
if (gpio == null)
{
pin = null;
GpioStatus.Text = "There is no GPIO controller on this device.";
return;
}
// Open the GPIO channel
pin = gpio.OpenPin(LED_PIN);
// As long as the pin object is not null, proceed
if (pin != null)
{
// Define the pin as an output pin
pin.SetDriveMode(GpioPinDriveMode.Output);
// Define the initial status as LOW (off)
pinValue = GpioPinValue.Low;
// Write the tate to the pin
pin.Write(pinValue);
// Update the on screen text to indicate that the GPIO is ready
GpioStatus.Text = "GPIO pin is initialized correctly.";
// Start the timer.
timer.Start();
}
}
public static async Task <bool> Initialize()
{
if (Initialized)
{
return(Initialized);
}
var controller = await GpioController.GetDefaultAsync();
if (controller == null)
{
return(Initialized); //No GPIO controller on device
}
if (!_leftInitialized)
{
_leftInitialized = InitializeLeft(controller);
}
if (!_rightInitialized)
{
_rightInitialized = InitializeRight(controller);
}
if (_leftInitialized && _rightInitialized)
{
Initialized = true;
}
return(Initialized);
}
public async Task InitGpioPin(int pinNumber)
{
var ctl = await GpioController.GetDefaultAsync();
MoistureSensorOutputPin = ctl?.OpenPin(pinNumber);
if (MoistureSensorOutputPin != null)
{
MoistureSensorOutputPin.SetDriveMode(GpioPinDriveMode.Input);
DispatcherTimer = new DispatcherTimer()
{
Interval = TimeSpan.FromSeconds(1)
};
DispatcherTimer.Tick += (sender, e) =>
{
var pinValue = MoistureSensorOutputPin.Read();
if (pinValue == GpioPinValue.High)
{
Debug.WriteLine("Dry");
}
else
{
Debug.WriteLine("Water Detected!");
}
};
DispatcherTimer.Start();
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
//Print out the FamilyName
//This string is needed to connect from a client
System.Diagnostics.Debug.WriteLine(Windows.ApplicationModel.Package.Current.Id.FamilyName);
//If this is the first time this background task is activated, init the gpio controller and pin
if (pin == null && controller == null)
{
controller = await GpioController.GetDefaultAsync();
pin = controller.OpenPin(5);
pin.SetDriveMode(GpioPinDriveMode.Output);
}
//Check to determine whether this activation was caused by an incoming app service connection
var appServiceTrigger = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (appServiceTrigger != null)
{
//Verify that the app service connection is requesting the "BlinkyService" that this class provides
if (appServiceTrigger.Name.Equals("BlinkyService"))
{
//Store the connection and subscribe to the "RequestRecieved" event to be notified when clients send messages
connection = appServiceTrigger.AppServiceConnection;
connection.RequestReceived += Connection_RequestReceived;
}
else
{
deferral.Complete();
}
}
}
public async Task InitGpioPin()
{
var controller = await GpioController.GetDefaultAsync();
newNotesPin = controller.OpenPin(5);
newNotesPin.Write(GpioPinValue.Low);
newNotesPin.SetDriveMode(GpioPinDriveMode.Output);
}
public async Task InitializeAsync()
{
var gpio = await GpioController.GetDefaultAsync();
this.cameraLedPin = gpio.OpenPin(Constants.LedPin);
this.cameraLedPin.Write(GpioPinValue.Low);
this.cameraLedPin.SetDriveMode(GpioPinDriveMode.Output);
}
public async Task Init()
{
lcd.init();
lcd.prints("bom dia");
lcd.gotoxy(0, 1);
lcd.prints("Lcd test");
var gpioController = await GpioController.GetDefaultAsync();
try
{
var pin7 = gpioController.OpenPin(17);
pin7.SetDriveMode(GpioPinDriveMode.Output);
lcd.clrscr();
lcd.prints("liga");
pin7.Write(GpioPinValue.Low);
await Task.Delay(1000);
lcd.clrscr();
lcd.prints("desliga");
pin7.Write(GpioPinValue.High);
await Task.Delay(1000);
lcd.clrscr();
lcd.prints("liga");
pin7.Write(GpioPinValue.Low);
}
catch
{
Debug.Write("Erro desconhecido");
}
var mfrc = new Mfrc522();
await mfrc.InitIO();
while (true)
{
if (!mfrc.IsTagPresent())
{
continue;
}
var uidd = mfrc.ReadUid();
mfrc.HaltTag();
lcd.clrscr();
lcd.prints(uidd.ToString());
await Task.Delay(1000);
}
}
protected override async Task DoSwitchOn()
{
controller = await GpioController.GetDefaultAsync();
ArgumentValidation.NonNull(controller, nameof(GpioController));
forwardPin = OpenPin(ForwardPinNumber);
backwardPin = OpenPin(BackwardPinNumber);
ApplyReversedPolarity();
}
public async Task <GpioPin> GetAsync(GpioPinDriveMode driveMode)
{
var controller = await GpioController.GetDefaultAsync();
var pin = controller.OpenPin(_pinNumber);
pin.SetDriveMode(driveMode);
return(pin);
}
private async void InitGPIOAsync()
{
m_Gpio = await GpioController.GetDefaultAsync();
m_DoorPin = m_Gpio.OpenPin(DOOR_PIN);
m_DoorPin.DebounceTimeout = TimeSpan.FromMilliseconds(50);
//m_DoorPin.Write(GpioPinValue.High);
m_DoorPin.SetDriveMode(GpioPinDriveMode.Input);
m_DoorPin.ValueChanged += DoorPin_ValueChanged;
}
public async Task Initialize(int pin)
{
_logger.LogDebug("Pin : initialization");
var controller = await GpioController.GetDefaultAsync();
_pinponPin = controller.OpenPin(pin);
_pinponPin.SetDriveMode(GpioPinDriveMode.Output);
TurnOff();
_logger.LogInformation("Pin : ready to pinpon !");
}
public static async Task <Brick> InitializeInstance(SerialDevice serialDevice)
{
instance = new Brick(serialDevice);
Task configSerialTask = instance.ConfigureSerialPort();
Task <GpioController> gpioControllerTask = GpioController.GetDefaultAsync().AsTask <GpioController>();
await Task.WhenAll(configSerialTask, gpioControllerTask);
instance.arduino1Led = new BrickLed(gpioControllerTask.Result, Arduino.Arduino1);
instance.arduino2Led = new BrickLed(gpioControllerTask.Result, Arduino.Arduino2);
return(instance);
}
private async Task InitGPIO()
{
GpioController GPIOController = await GpioController.GetDefaultAsync();
_digialGPIOPin = GPIOController.OpenPin(_digitalPin, GpioSharingMode.Exclusive);
_digialGPIOPin.SetDriveMode(GpioPinDriveMode.Input);
_digialGPIOPin.DebounceTimeout = new TimeSpan(0, 0, 0, 0, FlickerTimeOut);
Flame = _digialGPIOPin.Read() == GpioPinValue.High ? false : true;
_digialGPIOPin.ValueChanged += _digialGPIOPin_ValueChanged;
}
public async Task initialize()
{
var controller = await GpioController.GetDefaultAsync();
if (controller == null)
{
// Rogin?
return;
}
frontFilter = OnlineFilter.CreateDenoise();
backFilter = OnlineFilter.CreateDenoise();
rightFilter = OnlineFilter.CreateDenoise();
leftFilter = OnlineFilter.CreateDenoise();
triggerFrontPin = controller.OpenPin(kTriggerFront);
triggerBackPin = controller.OpenPin(kTriggerBack);
triggerLeftPin = controller.OpenPin(kTriggerLeft);
triggerRightPin = controller.OpenPin(kTriggerRight);
echoFrontPin = controller.OpenPin(kEchoFront);
echoBackPin = controller.OpenPin(kEchoBack);
echoLeftPin = controller.OpenPin(kEchoLeft);
echoRightPin = controller.OpenPin(kEchoRight);
triggerFrontPin.SetDriveMode(GpioPinDriveMode.Output);
triggerBackPin.SetDriveMode(GpioPinDriveMode.Output);
triggerLeftPin.SetDriveMode(GpioPinDriveMode.Output);
triggerRightPin.SetDriveMode(GpioPinDriveMode.Output);
echoFrontPin.SetDriveMode(GpioPinDriveMode.Input);
echoBackPin.SetDriveMode(GpioPinDriveMode.Input);
echoLeftPin.SetDriveMode(GpioPinDriveMode.Input);
echoRightPin.SetDriveMode(GpioPinDriveMode.Input);
long debounceTicks = Stopwatch.Frequency / (1000 * 1000 * 50);
echoFrontPin.DebounceTimeout = TimeSpan.FromTicks(debounceTicks);
echoBackPin.DebounceTimeout = TimeSpan.FromTicks(debounceTicks);
echoLeftPin.DebounceTimeout = TimeSpan.FromTicks(debounceTicks);
echoRightPin.DebounceTimeout = TimeSpan.FromTicks(debounceTicks);
echoFrontPin.ValueChanged += EchoFrontPin_ValueChanged;
echoBackPin.ValueChanged += EchoBackPin_ValueChanged;
echoLeftPin.ValueChanged += EchoLeftPin_ValueChanged;
echoRightPin.ValueChanged += EchoRightPin_ValueChanged;
// Every greater than 60 ms per datasheet due to echo.
// Round robin, so servicing each sonar every 120ms, but
// allowing for echo by servicing opposite sides.
timer.Interval = TimeSpan.FromMilliseconds(30);
timer.Tick += Timer_Tick;
timer.Start();
}
private async void GPIO_Switch_Toggled(object sender, RoutedEventArgs e)
{
try
{
await GpioController.GetDefaultAsync();
}
catch (Exception ex)
{
GPIO_Info.Visibility = Visibility.Visible;
GPIO_Info.Text += "\n" + ex.Source;
}
}
private async Task InitGpioAsync()
{
var gpio = await GpioController.GetDefaultAsync();
if (gpio == null)
{
throw new Exception("There is no GPIO controller on this device.");
}
redLedPin = gpio.OpenPin(RED_LED_PIN);
redLedPin.Write(GpioPinValue.High);
redLedPin.SetDriveMode(GpioPinDriveMode.Output);
}
private async void btnLedInitialize_Click(object sender, RoutedEventArgs e)
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
gpioController = await GpioController.GetDefaultAsync();
gpioPin = gpioController.OpenPin(5);
gpioPin.SetDriveMode(GpioPinDriveMode.Output);
}
private async void MainPage_Loaded(object sender, RoutedEventArgs e)
{
gpio = await GpioController.GetDefaultAsync();
led = gpio.OpenPin(24);
led.SetDriveMode(GpioPinDriveMode.Output);
button = gpio.OpenPin(18);
button.SetDriveMode(GpioPinDriveMode.Input);
button.ValueChanged += Button_ValueChanged;
BlinkLoop();
}
public async Task load()
{
try
{
switch (pwmselect.SelectedIndex)
{
case 1:
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider());
pwmController = pwmControllers[int.Parse(pwmidhd.Text)]; // use the on-device controller
pwmController.SetDesiredFrequency(double.Parse(frahz.Text));
//var _pin = pwmController.OpenPin(22);
//_pin.SetActiveDutyCyclePercentage(.25);
//_pin.Start();
}
else
{
await new MessageDialog("驱动程序不正常").ShowAsync();
}
break;
case 0:
{
var pwmManager = new PwmProviderManager();
pwmManager.Providers.Add(new SoftPwm());
var pwmControllers = await pwmManager.GetControllersAsync();
//use the first available PWM controller an set refresh rate (Hz)
pwmController = pwmControllers[0];
pwmController.SetDesiredFrequency(double.Parse(frahz.Text));
}
break;
default:
gpioController = await GpioController.GetDefaultAsync();
break;
}
pwmselect.IsEnabled = false;
}
catch (Exception err)
{
await new MessageDialog("初始化设备失败：" + err.ToString()).ShowAsync();
throw;
}
}
/// <summary>
/// Initializes the rfid reader and uses observable methodology to communicate tag detection
/// </summary>
/// <param name="updateFrequency">How often, in milliseconds, to check for a tag</param>
/// <returns></returns>
public async Task InitIO(int updateFrequency = 250)
{
Debug.WriteLine($"MainViewModel: Initiating RFID Reader");
try
{
await InitIO(await GpioController.GetDefaultAsync());
timer = new Timer(CheckForTag, null, 0, updateFrequency);
Debug.WriteLine($"MainViewModel: Initiating RFID Reader Successful");
}
catch (Exception ex)
{
Debug.WriteLine($"MainViewModel: Could not start the rfid reader. {ex}");
}
}
private async Task InitGpio()
{
_gpioController = await GpioController.GetDefaultAsync();
if (_gpioController == null)
{
return;
}
_pinLed = _gpioController?.OpenPin(26);
_pinLed.SetDriveMode(GpioPinDriveMode.Output);
_pinSensor = _gpioController?.OpenPin(18);
_pinSensor.DebounceTimeout = TimeSpan.FromMilliseconds(200);
_pinSensor.SetDriveMode(GpioPinDriveMode.InputPullDown);
_pinSensor.ValueChanged += _pinSensor_ValueChanged;
}