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); }
/// <summary> /// Initializes the PWM controller /// </summary> /// <returns>true if successfull init, false otherwise</returns> public static async Task <bool> InitPWM() { // PWM Pins http://raspberrypi.stackexchange.com/questions/40812/raspberry-pi-2-b-gpio-pwm-and-interrupt-pins var controllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (controllers.Count <= 1) { return(false); } driveControl = controllers[1]; if (driveControl == null) { return(false); } //can't step through the below line because reasons try { driveControl.SetDesiredFrequency(1000); } catch { return(false); } LeftDrive = new SMPWM(); RightDrive = new SMPWM(); LeftDrive.Init(5, 12, GpioController, driveControl); //PWM grey wire, m2 RightDrive.Init(6, 13, GpioController, driveControl); //PWM purple wire, m1 LeftDrive.Start(); RightDrive.Start(); return(true); }
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 void LoadUserCode(object sender, RoutedEventArgs e) { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } else { return; } var controllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (controllers.Count <= 1) { return; } driveControl = controllers[1]; if (driveControl == null) { return; } if (driveControl == null) { return; } driveControl.SetDesiredFrequency(1000); }
// Initialize the PwmController class instance public async void Initialize() { try { var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); var pwmController = pwmControllers[1]; // the device controller pwmController.SetDesiredFrequency(50); Pwm = pwmController.OpenPin(LED_pin); Pwm.SetActiveDutyCyclePercentage(0); // start at 0% Pwm.Start(); if (Pwm == null) { Debug.WriteLine("ERROR! Pwm device {0} may be in use."); return; } Debug.WriteLine("GPIO pin setup for Pwm."); } catch (Exception e) { Debug.WriteLine("EXEPTION CAUGHT: " + e.Message + "\n" + e.StackTrace); throw; } }
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 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 internetLed = new InternetLed(); _pin18 = pwmController.OpenPin(18); while (true) { await internetLed.GetThrottleFromWeb(); double test = internetLed.getThrottle() / 100.0; _pin18.SetActiveDutyCyclePercentage(internetLed.getThrottle() / 100.0); _pin18.Start(); await Task.Delay(200); } } }
protected override async Task <PwmController> GetController() { //return await PwmController.GetDefaultAsync(); // TODO: how to get soft PWM without guessing or studying source code? // https://github.com/ms-iot/lightning/blob/develop/Providers/PwmDeviceProvider.cpp var controllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); return(controllers[1]); // software PWM }
async void OpenPwnPin(int iPin) { var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); var pwmController = pwmControllers[1]; // use the on-device controller pwmController.SetDesiredFrequency(50); // try to match 50Hz, or 20ms _servoPin = pwmController.OpenPin(iPin); _servoPin.Start(); _servoPin.SetActiveDutyCyclePercentage(0); }
private async Task SetupPWM() { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); var pwmController = pwmControllers[1]; // use the on-device controller pwmController.SetDesiredFrequency(50); // try to match 50Hz pin = pwmController.OpenPin(21); } }
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; } }
private async void InitGPIO() { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); _pwmController = pwmControllers[1]; _outputPin = _pwmController.OpenPin(18); _outputPin.SetActiveDutyCyclePercentage(0.012); _outputPin.Start(); } }
public MainPage() { InitializeComponent(); LED.Fill = new SolidColorBrush(Windows.UI.Colors.Blue); timer = new DispatcherTimer(); timer.Interval = TimeSpan.FromMilliseconds(500); timer.Tick += Timer_Tick; if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()).AsTask().Result; var pwm = pwmControllers[1]; // use the on-device controller if (pwm == null) { pinR = pinG = null; GpioStatus.Text = "There is no PWM controller on this device."; } else { pwm.SetDesiredFrequency(50); pinR = pwm.OpenPin(17); pinR.Polarity = PwmPulsePolarity.ActiveLow; pinR.SetActiveDutyCyclePercentage(0); pinR.Stop(); pinG = pwm.OpenPin(18); pinG.Polarity = PwmPulsePolarity.ActiveLow; pinG.SetActiveDutyCyclePercentage(0); pinG.Stop(); GpioStatus.Text = "PWM pins initialized correctly."; pinR.Start(); pinG.Start(); if (pinR != null && pinG != null) { timer.Start(); } } } }
public async Task Connect() { var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (pwmControllers != null) { // use the on-device controller var pwmController = pwmControllers[1]; // Set the frequency, defaulted to 50Hz pwmController.SetDesiredFrequency(Frequency); ServoGpioPin = pwmController.OpenPin(ServoPin); } }
private async void Init(int pin, int frequency, int activeDutyCyclePercentage) { this.pin = pin; currentFrequency = frequency; this.activeDutyCyclePercentage = activeDutyCyclePercentage; var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); pwmController = pwmControllers[1]; // use the on-device controller motorPin = pwmController.OpenPin(pin); pwmController.SetDesiredFrequency(currentFrequency); // try to match 50Hz motorPin.SetActiveDutyCyclePercentage(activeDutyCyclePercentage); motorPin.Start(); ready = true; BuzzerReady?.Invoke(this); }
/// <summary> /// Initialize the servo. /// </summary> /// <returns></returns> public async Task InitializeAsync() { if (!LightningProvider.IsLightningEnabled) { throw new Exception("Servo can only be used with Lihtning provider"); } controller = (await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()))[1]; pin = controller.OpenPin(PIN_NUMBER); controller.SetDesiredFrequency(FREQUENCY); DesiredPulseWidth = MIDDLE_PULSE_WIDTH; MoveServo(); t = new Timer(TimerTick, null, 0, TimeSpan.FromMilliseconds(100).Milliseconds); }
public static async Task <PinManager> CreateAsync() { if (!LightningProvider.IsLightningEnabled) { throw new NotSupportedException("Controller needs Ligtning provider"); } var gpioController = await GpioController.GetDefaultAsync(); var pwmController = await PwmController.GetDefaultAsync(); var pwmProvider = LightningPwmProvider.GetPwmProvider(); var list = (await PwmController.GetControllersAsync(pwmProvider)); var length = list.Count; var controller = list[1]; controller.SetDesiredFrequency(50); return(new PinManager(gpioController, controller)); }
private async Task InitServoControllerAsync() { inited = false; if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } PwmController pwmController = (await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()))[1]; if (pwmController != null) { pwmController.SetDesiredFrequency(DESIRED_FREQUENCY); pwmPin = pwmController.OpenPin(GPIOPIN); } inited = (pwmPin != null); }
private async void button2_Click(object sender, RoutedEventArgs e) { //pinValue = GpioPinValue.Low; //pin.Write(GpioPinValue.Low); //LED.Fill = redBrush; LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); var pwmController = pwmControllers[0]; // use the on-device controller pwmController.SetDesiredFrequency(50); // try to match 50Hz var _pin = pwmController.OpenPin(LED_PIN); _pin.SetActiveDutyCyclePercentage(.75); _pin.Start(); }
private async void btnPwmInitialize_Click(object sender, RoutedEventArgs e) { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (pwmControllers != null) { // use the on-device controller var pwmController = pwmControllers[1]; // Set the frequency, defaulted to 50Hz pwmController.SetDesiredFrequency(pwmController.MinFrequency); // Open pin 5 for pulse width modulation var servoGpioPin = pwmController.OpenPin(18); // Set the Duty Cycle - 0.05 will set the servo to its 0 degree position servoGpioPin.SetActiveDutyCyclePercentage(.9); // Start PWN from pin 5, and give the servo a second to move to position servoGpioPin.Start(); //Task.Delay(1000).Wait(); //servoGpioPin.Stop(); //// Set the Duty Cycle - 0.1 will set the servo to its 180 degree position //servoGpioPin.SetActiveDutyCyclePercentage(0.1); //// Start PWN from pin 5, and give the servo a second to move to position //servoGpioPin.Start(); //Task.Delay(1000).Wait(); //servoGpioPin.Stop(); } //var infraredSensor = new InfraredSensor(4); //infraredSensor.Initialize(); //infraredSensor.InterruptHandler += InfraredSensor_InterruptHandler; }
async void OnLoaded(Object sender, Windows.UI.Xaml.RoutedEventArgs e) { if (Microsoft.IoT.Lightning.Providers.LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } else { return; } var controllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (controllers == null) { return; } var controller = controllers[1]; controller.SetDesiredFrequency(50.0); _pwmPin = controller.OpenPin(LED_PIN); _pwmPin.SetActiveDutyCyclePercentage(1.0); _pwmPin.Start(); while (true) { for (var i = INCREMENT; i > 0; i--) { var brightness = i / INCREMENT; _pwmPin.SetActiveDutyCyclePercentage(brightness); Task.Delay(DELAY).Wait(); } for (var i = 0; i < INCREMENT; i++) { var brightness = i / INCREMENT; _pwmPin.SetActiveDutyCyclePercentage(brightness); Task.Delay(DELAY).Wait(); } } }
private async static Task <bool> Initialise() { IsInitialising = true; bool status = false; if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); pwmController = pwmControllers[1]; pwmController.SetDesiredFrequency(700); status = true; } else { Debug.WriteLine("Lightning not enabled"); } IsInitialising = false; return(status); }
private async Task InitGpio() { if (LightningProvider.IsLightningEnabled) { // Do something with the Lightning providers LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); _pwmController = (await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()))[1]; _servoPin = _pwmController.OpenPin(_servoPinNum); _servoPin.SetActiveDutyCyclePercentage(0); _servoPin.Start(); _motorPin = _pwmController.OpenPin(_motorPinNumber); _pwmController.SetDesiredFrequency(50); _motorPin.SetActiveDutyCyclePercentage(0); _motorPin.Start(); } else { Debug.WriteLine("Please enable lightning providers"); } }
/// <summary> /// Initialize /// </summary> public async Task InitializeAsync() { if (!LightningProvider.IsLightningEnabled) { throw new NullReferenceException("Lightning isn't enabled !"); } controller = (await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()))[1]; controller.SetDesiredFrequency(pwmFrequency); redPin = controller.OpenPin(redPinNum); redPin.SetActiveDutyCyclePercentage(0); redPin.Start(); greenPin = controller.OpenPin(greenPinNum); greenPin.SetActiveDutyCyclePercentage(0); greenPin.Start(); bluePin = controller.OpenPin(bluePinNum); bluePin.SetActiveDutyCyclePercentage(0); bluePin.Start(); }
private async Task InitGPIO() { if (LightningProvider.IsLightningEnabled) { // Do something with the Lightning providers 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 motorPin = pwmController.OpenPin(_motorPinNumber); motorPin.SetActiveDutyCyclePercentage(RestingPulseLegnth); motorPin.Start(); _servoPin = pwmController.OpenPin(_servoPinNum); _servoPin.SetActiveDutyCyclePercentage(0); _servoPin.Start(); } else { StatusMessage.Text = "Please enable lightning providers"; } var gpioController = await GpioController.GetDefaultAsync(); if (gpioController == null) { StatusMessage.Text = "There is no GPIO controller on this device."; return; } _ledPin = gpioController.OpenPin(_ledPinNumber); _ledPin.SetDriveMode(GpioPinDriveMode.Output); _ledPin.Write(GpioPinValue.Low); }
/* We will initialize the PWM controller. For this we will be using Microsoft's Lightnening Provider * In Order this to work we neeed to change the Default Controller Driver to Direct Memory Access * Mapped driver. The Project Manifest file needs to be modified and low level devices capability * must be added. See documentation for details * */ public async Task <bool> Initialize() { bInit = false; try { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (pwmControllers == null) { return(false); } pwmController = pwmControllers[1]; pwmController.SetDesiredFrequency(FREQUENCY); //Min: 24hz to Max: 1000 hz gpio = await GpioController.GetDefaultAsync(); if (gpio == null) { return(false); } pwmController.SetDesiredFrequency(FREQUENCY); //Min: 24hz to Max: 1000 hz bInit = true; } catch (Exception e) { Debug.WriteLine("Exception Error {0} occured", e.ToString()); bInit = false; } return(true); }
private async Task init() { try { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); var pwmControllerPan = pwmControllers[1]; pwmControllerPan.SetDesiredFrequency(350); mPwmController = pwmControllerPan; pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); pwmControlleTilt = pwmControllers[1]; pwmControlleTilt.SetDesiredFrequency(450); mTopTiltServo = pwmControlleTilt.OpenPin(24); mBottomPanServo = mPwmController.OpenPin(25); mTopTiltServo.SetActiveDutyCyclePercentage(0.5); mBottomPanServo.SetActiveDutyCyclePercentage(0.5); mTopTiltServo.Start(); mBottomPanServo.Start(); Task.Run(() => { System.Threading.Tasks.Task.Delay(250).Wait(); mBottomPanServo.Stop(); mTopTiltServo.Stop(); }); } catch (Exception ex) { throw; } }
private async void Initialize() { //Set everithing ready for PWM mode if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); } var gpio = GpioController.GetDefault(); GPIOPIN_LASER = new GpioPin[5]; //Init lasers states for (int i = 0; i < LASER_PIN.Count; i++) { GPIOPIN_LASER[i] = gpio.OpenPin(LASER_PIN[i]); GPIOPIN_LASER[i].Write(GpioPinValue.Low); GPIOPIN_LASER[i].SetDriveMode(GpioPinDriveMode.Output); } var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()); if (pwmControllers != null) { var pwmController = pwmControllers[1]; pwmController.SetDesiredFrequency(50); //Open the two pin to start working servoGpioPinX = pwmController.OpenPin(X_PIN); servoGpioPinY = pwmController.OpenPin(Y_PIN); MakeRandom(); } else { GlobalDeferal.Complete(); } }
public async Task InitializeHardware() { if (LightningProvider.IsLightningEnabled) { LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); var pmwProvider = LightningPwmProvider.GetPwmProvider(); // var pwmControllers = await Windows.Devices.Pwm.PwmController.GetControllersAsync(pmwProvider); var pwmControllers = Windows.Devices.Pwm.PwmController.GetControllersAsync(pmwProvider).GetAwaiter().GetResult(); var pwmController = pwmControllers[1]; // the on-device controller // This seems to go bad //pwmController.SetDesiredFrequency(100); _gpioController = await GpioController.GetDefaultAsync(); IPin GetInputPin(int pinNr) { return(new GpioPinWrapper(_gpioController.OpenPin(pinNr, GpioSharingMode.Exclusive), GpioPinDriveMode.InputPullUp)); } _gateStates = new GateStates(); _gateStates.Add( // Center switches (on bread board) new GateState( // Yellow button, Closed GetInputPin(27), // Red button, Open GetInputPin(22)), 1); _gateStates.Add( // Top switches (on bread board) new GateState( // Yellow button, Closed GetInputPin(4), // Red button, Open GetInputPin(17)), 2); IPwmPin GetPwmPin(int pinNr) { //var pin = _gpioController.OpenPin(pinNr); //pin.SetDriveMode(GpioPinDriveMode.Output); return(new PwmPinWrapper(pwmController.OpenPin(pinNr))); } GateController = new GateController( // TODO : pins in settings, selector: 6, 13, 19 new Selector(GetOutputPins(6, 13, 19)), new PwmController( // TODO : pins in settings: 20, 21 GetPwmPin(20), GetPwmPin(21), // TODO : steps per change in settings 3), _gateStates); // TODO : pins in settings: 24 _heartBeatPin = GetOutputPins(24).First(); _heartBeatTimer = new Timer(HandleHeartBeat, _heartBeatState, 100, Timeout.Infinite); } }
/// <summary> /// 链接到指定的L298N电机控制器 /// </summary> private Motor(int [] gpios, int freq) { IN = new PwmPin[PinNumbers]; Frequency = freq; if (LightningProvider.IsLightningEnabled) { //获取控制器 LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider(); //获取系统Pwm控制器 Task <IReadOnlyList <PwmController> > t = PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider()).AsTask <IReadOnlyList <PwmController> >(); t.Wait(); PwmController controller = t.Result[1]; //设置频率 controller.SetDesiredFrequency(Frequency); //关联引脚 for (int i = 0; i < PinNumbers; ++i) { IN[i] = controller.OpenPin(gpios[i]); IN[i].SetActiveDutyCyclePercentage(0); IN[i].Start(); } } }