public void Backward(double frequency, double dutyCycle) { if (pwmController == null || servoGpioPinEn == null || gpioPinIn1 == null || gpioPinIn2 == null) { return; } var max = pwmController.MaxFrequency; var min = pwmController.MinFrequency; frequency = Math.Min(frequency, max); frequency = Math.Max(frequency, min); var maxDuty = 1.0; var minDuty = 0.0; dutyCycle = Math.Min(dutyCycle, maxDuty); dutyCycle = Math.Max(dutyCycle, minDuty); pwmController.SetDesiredFrequency(frequency); servoGpioPinEn.SetActiveDutyCyclePercentage(dutyCycle); gpioPinIn1.Write(GpioPinValue.High); gpioPinIn2.Write(GpioPinValue.Low); servoGpioPinEn.Start(); }
private async Task EnsureInitializedAsync() { if (_isInitialized) { return; } // Create PWM manager var pwmManager = new PwmProviderManager(); // Add providers ~ pwmControllers //var provider = new PCA9685Provider(_i2Caddr); pwmManager.Providers.Add(new PCA9685()); // Get the well-known controller collection back var pwmControllers = await pwmManager.GetControllersAsync(); _pwmController = pwmControllers.Last(); if (_frequency > _pwmController.MaxFrequency) { _frequency = _pwmController.MaxFrequency; } _pwmController.SetDesiredFrequency(_frequency); _isInitialized = true; }
/// <summary> /// /// </summary> /// <returns></returns> private async Task InitBuzzer() { pwmController = (await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider()))[0]; pwmController.SetDesiredFrequency(40); buzzer = pwmController.OpenPin(BUZZER_PIN); buzzer.SetActiveDutyCyclePercentage(RestingPulseLegnth); }
public async Task <bool> Rotate(LuisResult result, object context, object speak) { var speech = (App.SpeechFunc)speak; var c = (Context)context; if (c.IsIoTCore) { speech("Feel the burn baby!"); pwmController = (await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider()))[0]; pwmController.SetDesiredFrequency(50); try { motorPin = pwmController.OpenPin(26); } catch { } motorPin.SetActiveDutyCyclePercentage(RestingPulseLegnth); motorPin.Start(); iteration = 0; timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromSeconds(1)); } else { speech("I am a fully functioning PC, not a robot."); } return(true); }
public ServoMotor(string controller, int PwmPinNumber) { PwmController PWM = PwmController.FromId(controller); servo = PWM.OpenPin(PwmPinNumber); PWM.SetDesiredFrequency(1 / 0.020); }
private async void MainPage_Loaded(object sender, RoutedEventArgs e) { // Check presence of GPIO Controller // Since this is UWP, this application runs on desktop, mobile, as well as embedded devices // best to confirm we are running on an embedded device like R Pi GpioController gpio = GpioController.GetDefault(); if (gpio == null) { Debug.WriteLine("This device does not have GPIO Controller."); return; } var pwmManager = new PwmProviderManager(); pwmManager.Providers.Add(new SoftPwm()); var pwmContollers = await pwmManager.GetControllersAsync(); pwmController = pwmContollers[0]; pwmController.SetDesiredFrequency(50); pwmPin = pwmController.OpenPin(servoPin); pwmPin.Start(); timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(15) }; timer.Tick += Timer_Tick; timer.Start(); IsClockwise = false; }
/// <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); }
public static void SetMotorDuty(Servo servo, double speedPercentage, Direction direction) { if (speedPercentage < 0 || speedPercentage > 100) { throw new ArgumentOutOfRangeException("speedPercentage", "Must be between 0 and 100 %"); } if (servo == Servo.A) { if (direction == Direction.Back) { DIRA.Write(GpioPinValue.Low); } else { DIRA.Write(GpioPinValue.High); } PWM1.SetDesiredFrequency(5000); PWMA.Start(); PWMA.SetActiveDutyCyclePercentage(speedPercentage / 100); } else { if (direction == Direction.Forvard) { DIRB.Write(GpioPinValue.High); } else { DIRB.Write(GpioPinValue.Low); } PWM3.SetDesiredFrequency(5000); PWMB.Start(); PWMB.SetActiveDutyCyclePercentage(speedPercentage / 100); } }
/// <summary> /// Constructor of Grove ServoMotor module /// </summary> /// <param name="controller">Id of pwm controller</param> /// <param name="pwmPinNumber">Pwm pin number of board</param> public ServoMotor(string controller, int pwmPinNumber) { PwmController pwm = PwmController.FromName(controller); _servo = pwm.OpenChannel(pwmPinNumber); pwm.SetDesiredFrequency(1 / 0.020); }
public void InitMotors() { Debug.WriteLine("Initialising motors"); motorsBySide = new Dictionary <string, Motor>(); Debug.WriteLine("Initialising driver"); hat = new PwmController(); hat.SetDesiredFrequency(90); var motor = new Motor(hat, 0); motorsBySide.Add("frontLeft", motor); motor = new Motor(hat, 4); motorsBySide.Add("frontRight", motor); motor = new Motor(hat, 8); motorsBySide.Add("rearRight", motor); motor = new Motor(hat, 12); motorsBySide.Add("rearLeft", motor); Debug.WriteLine("Initialized motors"); ArmMotors(); }
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); }
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 InitPwm() { //_controller = (await PwmController.GetControllersAsync(PwmPCA9685.PwmProviderSoftware.GetPwmProvider())).First(); _controller = (await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider())).First(); _controller.SetDesiredFrequency(40); _pin = _controller.OpenPin(5); _pin.SetActiveDutyCyclePercentage(0.5); }
public RgbLed(int PwmPinNumber) { //PWM redLed = new PWM(PWMChannels.PWM_PIN_D11, 100, 0, false); PwmController PWM = PwmController.GetDefault(); Lamp = PWM.OpenPin(PwmPinNumber); PWM.SetDesiredFrequency(100); }
/// <summary> /// Main class constructor for Buzzer /// <para><b>Pins used :</b> Cs, Pwm</para> /// </summary> /// <param name="socket">The socket on which the Buzzer Click board is plugged on MikroBus.Net</param> /// <exception cref="System.InvalidOperationException">Thrown if some pins are already in use by another board on the same socket</exception> public BuzzerClick(Hardware.Socket socket) { // Initialize PWM and set initial brightness PWM = PwmController.FromName(socket.PwmController); PWM.SetDesiredFrequency(10000); _buzzPwm = PWM.OpenChannel(socket.PwmChannel); _buzzPwm.SetActiveDutyCyclePercentage(0.0); _buzzPwm.Start(); _playList = new Melody(); }
public ServoMotor(string pwmId, ServoType type, int pwmPin) { PwmController pwmController = PwmController.FromId(pwmId); pwmController.SetDesiredFrequency(50); this.ConfigurePulseParameters(1.0, 2.0); this.servo = pwmController.OpenPin(pwmPin); this.type = type; this.Position = 0; }
/// <summary> /// Constructor /// </summary> /// <param name="PWMOutputPin">Output pin for Ref frequency</param> /// <param name="PWMFrequency">The Reference frequency</param> public Reference(int PWMOutputPin, int PWMFrequency) { PwmController pwmc = PwmController.GetDefault(); pwmc.SetDesiredFrequency(PWMFrequency); pwmRefFreq = pwmc.OpenPin(PWMOutputPin); pwmRefFreq.SetActiveDutyCyclePercentage(0.5); Console.WriteLine("PWM max freq = " + pwmc.MaxFrequency.ToString()); Console.WriteLine("PWM min freq = " + pwmc.MinFrequency.ToString()); }
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; } }
/* 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); }
public LightBulb() { PwmController pwmController = PwmController.FromId("TIM3"); pwmController.SetDesiredFrequency(10000); this.red = pwmController.OpenPin(BrainPad2.Light.Red); this.green = pwmController.OpenPin(BrainPad2.Light.Greeen); this.blue = pwmController.OpenPin(BrainPad2.Light.Blue); this.red.Start(); this.green.Start(); this.blue.Start(); this.TurnColor(0, 0, 0); }
/// <summary> /// This constructor is void, You must configure this class by this.SetupBasic() /// </summary> /// <summary> /// Initialize of pwm (it must be used after constructor PwmBasic() ) /// </summary> /// <param name="__pinNumber">Pin of RPi where this pwm must be work</param> /// <param name="__frequency">Frequency of pwm (can change this param later)</param> /// <returns></returns> protected async Task SetupPwmCore(int __pinNumber, double __frequency) { var gpioController = GpioController.GetDefault(); var pwmManager = new PwmProviderManager(); pwmManager.Providers.Add(new SoftPwm()); var pwmControllers = await pwmManager.GetControllersAsync(); _pwmController = pwmControllers[0]; Frequency = __frequency; _pwmController.SetDesiredFrequency(frequency); _pwmPin = _pwmController.OpenPin(__pinNumber); State = true; }
public async void Setup(int _pinNumber, double _frequency) { var gpioController = GpioController.GetDefault(); var pwmManager = new PwmProviderManager(); pwmManager.Providers.Add(new SoftPwm()); var pwmControllers = await pwmManager.GetControllersAsync(); _pwmController = pwmControllers[0]; frequency = _frequency; //TODO: get; set; _pwmController.SetDesiredFrequency(frequency); _pwmPin = _pwmController.OpenPin(_pinNumber); _pwmPin.Start(); }
static ZumoBot() { led = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D13); led.SetDriveMode(GpioPinDriveMode.Output); button = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D12); button.SetDriveMode(GpioPinDriveMode.InputPullUp); PwmController pwm = PwmController.FromId(FEZ.PwmPin.Controller3.Id); pwm.SetDesiredFrequency(4 * 1000); Buzzer = pwm.OpenPin(FEZ.PwmPin.Controller3.D6); // D3 or D6 Buzzer.Stop(); Buzzer.SetActiveDutyCyclePercentage(0.5); voltage = AdcController.GetDefault().OpenChannel(FEZ.AdcChannel.A1); }
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); }
public void Initialize() { _redController.SetDesiredFrequency(10000); _greenController.SetDesiredFrequency(10000); _blueController.SetDesiredFrequency(10000); _redPin = _redController.OpenPin(0); _greenPin = _greenController.OpenPin(2); _bluePin = _blueController.OpenPin(4); _redPin.SetActiveDutyCyclePercentage(0.000f); _greenPin.SetActiveDutyCyclePercentage(0.000f); _bluePin.SetActiveDutyCyclePercentage(0.000f); _redPin.Start(); _greenPin.Start(); _bluePin.Start(); }
public async Task InitAsync() { pwmController = (await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider()))[0]; pwmController.SetDesiredFrequency(100); redPin = InitPin(REDLED_PIN); orangePin = InitPin(ORANGELED_PIN); bluePin = InitPin(BLUELED_PIN); SetCyclePercentage(redPin, 1); SetCyclePercentage(orangePin, 1); SetCyclePercentage(bluePin, 1); Task.Delay(50).Wait(); SetCyclePercentage(redPin, 0); SetCyclePercentage(orangePin, 0); SetCyclePercentage(bluePin, 0); }
async void InitPwm() { var gpio_controller = GpioController.GetDefault(); var manager = new PwmProviderManager(); manager.Providers.Add(new SoftPwm()); var controllers = await manager.GetControllersAsync(); _controller = controllers[0]; _controller.SetDesiredFrequency(120); _led = new RgbLed { RedPin = _controller.OpenPin(PIN_R), GreenPin = _controller.OpenPin(PIN_G), BluePin = _controller.OpenPin(PIN_B), Color = Colors.Black }; }
/// <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 async Task <bool> InitAsync(double frequency) { try { var controllers = await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider()); _pwmController = controllers?.FirstOrDefault(); if (_pwmController != null) { _pwmController.SetDesiredFrequency(frequency); return(true); } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } return(false); }
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 void RotateExample() { try { using (var hat = new PwmController()) { hat.SetDesiredFrequency(364); // spec'd to 658? while (true) { int s = 0; int m = 8; int max = (int) ((float) 4096*(0.75)); int min = (int) ((float) 4096*(0.28)); while (true) { s += m; if (s >= max) { s = max; m = -4; } if (s <= min) { s = min; m = 4; } hat.SetPulseParameters(15, s); Task.Delay(TimeSpan.FromMilliseconds(10)).Wait(); } hat.SetPulseParameters(15, 0); hat.SetPulseParameters(4, 40); //aux hat.SetPulseParameters(3, 40); //rud hat.SetPulseParameters(2, 40); //ele hat.SetPulseParameters(1, 40); //ail hat.SetPulseParameters(0, 40); //thr Task.Delay(TimeSpan.FromSeconds(5)).Wait(); hat.SetPulseParameters(15, 4096); hat.SetPulseParameters(4, 4055); //aux hat.SetPulseParameters(3, 4055); //rud hat.SetPulseParameters(2, 4055); //ele hat.SetPulseParameters(1, 4055); //ail hat.SetPulseParameters(0, 4055); //thr Task.Delay(TimeSpan.FromSeconds(5)).Wait(); } } } /* If the write fails display the error and stop running */ catch (Exception ex) { Text_Status.Text = "Failed to communicate with device: " + ex.Message; return; } }