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(); }
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); }
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 PwmMotor(PwmController pwmController, int pwmPin, int direction1Pin, int direction2Pin) : base(pwmController, pwmPin) { _directionPin1 = PwmController.OpenPin(direction1Pin); _directionPin2 = PwmController.OpenPin(direction2Pin); _directionPin1.Start(); _directionPin2.Start(); }
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; }
public static void Main() { Debug.WriteLine("devMobile.Longboard.PwmTest starting"); Debug.WriteLine(PwmController.GetDeviceSelector()); try { PwmController pwm = PwmController.FromId("TIM5"); AdcController adc = AdcController.GetDefault(); AdcChannel adcChannel = adc.OpenChannel(0); PwmPin pwmPin = pwm.OpenPin(PinNumber('A', 0)); pwmPin.Controller.SetDesiredFrequency(1000); pwmPin.Start(); while (true) { double value = adcChannel.ReadRatio(); Debug.WriteLine(value.ToString("F2")); pwmPin.SetActiveDutyCyclePercentage(value); Thread.Sleep(100); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
/// <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.FromId(controller); _servo = pwm.OpenPin(pwmPinNumber); pwm.SetDesiredFrequency(1 / 0.020); }
internal Servo(PwmController pwmController, int pwmPin) { _position = 0.0; _limitsSet = false; _pwmPin = pwmController.OpenPin(pwmPin); _pwmPin.Start(); }
public ServoMotor(string controller, int PwmPinNumber) { PwmController PWM = PwmController.FromId(controller); servo = PWM.OpenPin(PwmPinNumber); PWM.SetDesiredFrequency(1 / 0.020); }
/// <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); }
/// <summary> /// Initialize the Pins with default values of low and 0 /// </summary> /// <param name="GPIO_pin">The number of the GPIO pin to open</param> /// <param name="PWM_pin">The number of the PWM pin to open</param> /// <param name="gpioController">The gpio controller</param> /// <param name="pwmController">The PWM controller</param> public void Init(int GPIO_pin, int PWM_pin, GpioController gpioController, PwmController pwmController) { _pwmPin = pwmController.OpenPin(PWM_pin); _GPIOPin = gpioController.OpenPin(GPIO_pin); _GPIOPin.Write(GpioPinValue.Low); _GPIOPin.SetDriveMode(GpioPinDriveMode.Output); _pwmPin.SetActiveDutyCyclePercentage(0); }
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); }
private PwmPin InitPin(int pinNumber) { var pin = pwmController.OpenPin(pinNumber); pin.Start(); return(pin); }
/// <summary> /// Constructor of Tunes /// </summary> /// <param name="controller">string of controller (must be a P Socket)</param> /// <param name="pin">Pin number (generally pin 9 of P Socket)</param> public Tunes(string controller, int pin) { PwmController ctl = PwmController.FromId(controller); _pwmPin = ctl.OpenPin(pin); _playlist = new Queue(); _syncRoot = new object(); }
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); }
protected PwmMotorBase(PwmController pwmController, int pwmPin) { if (pwmController == null) { throw new ArgumentNullException(nameof(pwmController)); } PwmController = pwmController; PwmPin = PwmController.OpenPin(pwmPin); PwmPin.Start(); }
/// <summary> /// Creates an instance. /// </summary> /// <param name="pin">The PWM-enabled pin to use.</param> public AnalogPwmOutput(DigitalPwmOutputPin pin) { if (_controller == null) { CreateController(PwmFrequency); } _pin = _controller.OpenPin((int)pin); _pin.SetActiveDutyCyclePercentage(0.0); _pin.Start(); }
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 }; }
public PwmPin OpenPin(int pinNumber, double dutyCyclePercentage = 0) { if (_pwmController == null) { throw new InvalidOperationException(); } var pin = _pwmController.OpenPin(pinNumber); pin?.SetActiveDutyCyclePercentage(dutyCyclePercentage); return(pin); }
/// <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 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; }
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(); }
static Motors() { PWM.SetDesiredFrequency(6000); M1PWM = PWM.OpenPin(FEZ.PwmPin.Controller3.D9); M1PWM.Stop(); M1PWM.SetActiveDutyCyclePercentage(0.1); M1PWM.Start(); M2PWM = PWM.OpenPin(FEZ.PwmPin.Controller3.D10); M2PWM.Stop(); M2PWM.SetActiveDutyCyclePercentage(0.1); M2PWM.Start(); M1DIR = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D7); M1DIR.SetDriveMode(GpioPinDriveMode.Output); M1DIR.Write(GpioPinValue.High); M2DIR = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D8); M2DIR.Write(GpioPinValue.High); M2DIR.SetDriveMode(GpioPinDriveMode.Output); }
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 void SetMotorConfig() { //Connect the motor Enabler to PWM pin pwmMotorLeft = pwmController.OpenPin(PWMLEFT); pwmMotorLeft.SetActiveDutyCyclePercentage(INITIALPOWER / 100); pwmMotorLeft.Stop(); pwmMotorRight = pwmController.OpenPin(PWMRIGHT); pwmMotorRight.SetActiveDutyCyclePercentage(INITIALPOWER / 100); pwmMotorRight.Stop(); //Assign the Motor Terminals to gpio pins MotorLeftNegative = gpio.OpenPin(MOTORLEFTN, GpioSharingMode.Exclusive); MotorLeftPositive = gpio.OpenPin(MOTORLEFTP, GpioSharingMode.Exclusive); MotorRightNegative = gpio.OpenPin(MOTORRIGHTN, GpioSharingMode.Exclusive); MotorRightPositive = gpio.OpenPin(MOTORRIGHTP, GpioSharingMode.Exclusive); //set Input or Output of the pins MotorLeftNegative.SetDriveMode(GpioPinDriveMode.Output); MotorLeftPositive.SetDriveMode(GpioPinDriveMode.Output); MotorRightNegative.SetDriveMode(GpioPinDriveMode.Output); MotorRightPositive.SetDriveMode(GpioPinDriveMode.Output); /* ******Set initial values for output ports ***** * Note the following * Negative Positive Result * Low High Forward * High Low Backward * Low Low Stop * High High Right * */ MotorLeftNegative.Write(GpioPinValue.Low); MotorLeftPositive.Write(GpioPinValue.Low); MotorRightNegative.Write(GpioPinValue.Low); MotorRightPositive.Write(GpioPinValue.Low); }
/// <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(); }
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); }
internal async static void MakeOutput(int pin) { while (IsInitialising) { await Task.Delay(500); } if (pwmController == null) { await Initialise(); } if (pwmController != null) { var x = pwmController.OpenPin(pin); Pins.Add(pin, x); } }