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(); }
public void TiltUp() { mTopTiltServo.SetActiveDutyCyclePercentage(Math.Max(mBottomPanServo.GetActiveDutyCyclePercentage() - 0.01, 0)); mTopTiltServo.Start(); Task.Run(() => { System.Threading.Tasks.Task.Delay(100).Wait(); mTopTiltServo.Stop(); }); }
// 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 void DoWork() { while (true) { MusicNote note; lock (_syncRoot) { if (_playlist.Count == 0) { break; } note = (MusicNote)_playlist.Dequeue(); } if (Math.Abs(note.Tone.Frequency) > 0.01) { _pwmPin.Controller.SetDesiredFrequency((int)note.Tone.Frequency); _pwmPin.SetActiveDutyCyclePercentage(0.5); _pwmPin.Start(); } else { _pwmPin.Stop(); } Thread.Sleep(note.Duration); } _pwmPin.Controller.SetDesiredFrequency(100); _pwmPin.SetActiveDutyCyclePercentage(0.0001); }
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); } } }
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(); }
public async void StepperMotorExample() { MotorHat2348 mh = null; PwmStepperMotor stepper = null; PwmPin pwm = null; if (mh == null) { // Create a driver object for the HAT at address 0x60 mh = new MotorHat2348(0x60); // Create a stepper motor object at the specified ports and steps per rev stepper = mh.CreateStepperMotor(1, 2, 200); // Create a PwmPin object at one of the auxiliary PWMs on the HAT pwm = mh.CreatePwm(1); } // step 200 full steps in the forward direction using half stepping (so 400 steps total) at 30 rpm stepper.SetSpeed(30); await stepper.StepAsync(200, Direction.Forward, SteppingStyle.Half); // Activate the pin and set it to 50% duty cycle pwm.Start(); pwm.SetActiveDutyCyclePercentage(0.5); // for demonstration purposes we will wait 10 seconds to observe the PWM and motor operation. await Task.Delay(10000); // Stop the auxiliary PWM pin pwm.Stop(); // Dispose of the MotorHat and free all its resources mh.Dispose(); }
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 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); } }
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); } }
public async void Run(IBackgroundTaskInstance taskInstance) { _deferral = taskInstance.GetDeferral(); _controller = new PinsController(); _gpioController = GpioController.GetDefault(); bool initialized = await _controller.InitAsync(PWM_FREQUENCY); if (initialized) { _pin1 = _controller.OpenPin(6); _pin1.Start(); _pin2 = _controller.OpenPin(13); _pin2.Start(); _pin3 = _controller.OpenPin(19); _pin3.Start(); _pin4 = _controller.OpenPin(26); _pin4.Start(); _pin5 = _gpioController.OpenPin(4); _pin5.SetDriveMode(GpioPinDriveMode.Output); _pin5.Write(GpioPinValue.Low); } _httpServer = new HttpServer(6000, 250); _httpServer.StartServer(); _httpServer.MessageReceived += new EventHandler <byte[]>((s, m) => HandleMessage(m)); _httpServer.CommunicationTimedOut += new EventHandler <long>((s, l) => HandleTimeOut(l)); }
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 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); }
internal Servo(PwmController pwmController, int pwmPin) { _position = 0.0; _limitsSet = false; _pwmPin = pwmController.OpenPin(pwmPin); _pwmPin.Start(); }
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(); }
public virtual Task InitializeAsync() { if (!LightningProvider.IsLightningEnabled) { throw new NotSupportedException("PwmPinBase is not supported outside Lightning Provider"); } _pin.Start(); return(Task.CompletedTask); }
/// <summary> /// If you dont move the servo outter forces can disorient it so we have to refresh it periodically. /// </summary> /// <param name="state"></param> private void TimerTick(object state) { // do some work not connected with UI pin.SetActiveDutyCyclePercentage(percentage); lock (lockObject) { pin.Start(); Task.Delay(SIGNAL_DURATION).Wait(); pin.Stop(); } /* * await Window.Current.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, * () => * { * * // do some work on UI here; * }); */ }
public void RotateServo() { // Start the servo with pwm pin.SetActiveDutyCyclePercentage(currPercent); pin.Start(); // Update the previous duty cycle prevPercent = currPercent; // Wait 1s for servo to turn Task.Delay(1000).Wait(); // Stop the servo pin.Stop(); }
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(); } } } }
/// <summary> /// Sets the position of the Servo Motor. /// </summary> /// <param name="position">The position of the servo between 0 and 180 degrees.</param> public void SetPosition(double position) { if (position < 0 || position > 180) { throw new ArgumentOutOfRangeException("degrees", "degrees must be between 0 and 180."); } // Typically, with 50 hz, 0 degree is 0.05 and 180 degrees is 0.10 //double duty = ((position / 180.0) * (0.10 - 0.05)) + 0.05; double duty = ((position / 180.0) * (_MaxPulseCalibration / 20 - _MinPulseCalibration / 20)) + _MinPulseCalibration / 20; servo.SetActiveDutyCyclePercentage(duty); servo.Start(); }
/// <inheritdoc /> public void SetActiveDutyCyclePercent(int newDutyCycle) { double newDutyCyclePercent = Math.Round(newDutyCycle / 100D, 2); _wrappedPin.SetActiveDutyCyclePercentage(newDutyCyclePercent); if (!_wrappedPin.IsStarted) { _wrappedPin.Start(); } if (_wrappedPin.IsStarted && newDutyCyclePercent < 0.01) { _wrappedPin.Stop(); } }
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); }
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 static void Main() { Debug.WriteLine("devMobile.Longboard starting"); Debug.WriteLine($"I2C:{I2cDevice.GetDeviceSelector()}"); Debug.WriteLine($"PWM:{PwmController.GetDeviceSelector()}"); try { Debug.WriteLine("LED Starting"); GpioPin led = GpioController.GetDefault().OpenPin(PinNumber('A', 10)); led.SetDriveMode(GpioPinDriveMode.Output); led.Write(GpioPinValue.Low); Debug.WriteLine("LED Starting"); WiiNunchuk nunchuk = new WiiNunchuk("I2C1"); Debug.WriteLine("ESC Starting"); PwmController pwm = PwmController.FromId("TIM5"); PwmPin pwmPin = pwm.OpenPin(PinNumber('A', 1)); pwmPin.Controller.SetDesiredFrequency(PulseFrequency); pwmPin.Start(); Debug.WriteLine("Thread.Sleep Starting"); Thread.Sleep(2000); Debug.WriteLine("Mainloop Starting"); while (true) { nunchuk.Read(); double duration = Map(nunchuk.AnalogStickY, WiiNunchukYMinimum, WiiNunchukYMaximum, PulseDurationMinimum, PulseDurationMaximum); Debug.WriteLine($"Value:{nunchuk.AnalogStickY} Duration:{duration:F3}"); pwmPin.SetActiveDutyCyclePercentage(duration); led.Toggle(); Thread.Sleep(ThrottleUpdatePeriod); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
/// <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); pin.Start(); DesiredPulseWidth = MIDDLE_PULSE_WIDTH; MoveServo(); }
private void SetMotorDirection(App.DIRECTION d) { //first stop the motors, change direction and then start the motors pwmMotorLeft.Stop(); pwmMotorRight.Stop(); switch (d) { case App.DIRECTION.FORWARD: //Both Motors in the same direction - Forward MotorLeftNegative.Write(GpioPinValue.Low); MotorLeftPositive.Write(GpioPinValue.High); MotorRightNegative.Write(GpioPinValue.Low); MotorRightPositive.Write(GpioPinValue.High); break; case App.DIRECTION.REVERSE: //Both Motors in the same direction but Reverse MotorLeftNegative.Write(GpioPinValue.High); MotorLeftPositive.Write(GpioPinValue.Low); MotorRightNegative.Write(GpioPinValue.High); MotorRightPositive.Write(GpioPinValue.Low); break; case App.DIRECTION.LEFT: //One of the Motor is in the reverse, while the other forward - Friction turn MotorLeftNegative.Write(GpioPinValue.Low); MotorLeftPositive.Write(GpioPinValue.High); //Left Motor Forward MotorRightNegative.Write(GpioPinValue.High); MotorRightPositive.Write(GpioPinValue.Low); //Right Motor Reverse break; case App.DIRECTION.RIGHT: //One of the Motor is in the reverse, while the other forward - Friction turn MotorLeftNegative.Write(GpioPinValue.High); MotorLeftPositive.Write(GpioPinValue.Low); MotorRightNegative.Write(GpioPinValue.Low); MotorRightPositive.Write(GpioPinValue.High); break; } pwmMotorLeft.Start(); pwmMotorRight.Start(); }