public Windows10PwmDriverChannel(WinPwm.PwmController winController, int channelIndex) { _winPin = winController.OpenPin(channelIndex); if (_winPin == null) { throw new ArgumentOutOfRangeException($"The PWM chip is unable to open a channel at index {channelIndex}.", nameof(channelIndex)); } }
internal PwmPin(PwmController controller, IPwmControllerProvider provider, int pinNumber) { m_controller = controller; m_provider = provider; m_pinNumber = pinNumber; m_provider.AcquirePin(pinNumber); }
public void Dispose() { _winController = null; foreach (Windows10PwmDriverChannel channel in _channelMap.Values) { channel.Dispose(); } _channelMap.Clear(); }
static void LedInit(PwmController controller) { Red = controller.OpenPin(LedPinRed); Green = controller.OpenPin(LedPinGreen); Blue = controller.OpenPin(LedPinBlue); Red.Start(); Green.Start(); Blue.Start(); }
public static PwmController[] GetControllers(IPwmProvider provider) { // FUTURE: This should return "Task<IReadOnlyList<PwmController>>" var providers = provider.GetControllers(); var controllers = new PwmController[providers.Length]; for (int i = 0; i < providers.Length; ++i) { controllers[i] = new PwmController(providers[i]); } return controllers; }
public async void Run(IBackgroundTaskInstance taskInstance) { deferral = taskInstance.GetDeferral(); // pwmController = (await PwmController.GetControllersAsync(PwmPCA9685.PwmProviderPCA9685.GetPwmProvider()))[0]; pwmController = (await PwmController.GetControllersAsync(PwmSoftware.PwmProviderSoftware.GetPwmProvider()))[0]; pwmController.SetDesiredFrequency(50); motorPin = pwmController.OpenPin(13); motorPin.SetActiveDutyCyclePercentage(RestingPulseLegnth); motorPin.Start(); secondMotorPin = pwmController.OpenPin(6); secondMotorPin.SetActiveDutyCyclePercentage(RestingPulseLegnth); secondMotorPin.Start(); timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromSeconds(2)); }
public Pwm( ObjectEnvironment environment, string id, string name, PwmController controller, string description = null, Object parent = null ) : base(environment, id, name, new ObjectType("PWM", "PWM", "Pulse width modulation"), description, parent) { controller.ValidateNonNull(nameof(controller)); Controller = controller; PinCount = new Property<int>(this, nameof(PinCount), "Pin count", Controller.PinCount); Items.Add(PinCount); DelegateCommand command; command = new DelegateCommand<int>(this, nameof(OpenPin), "Open pin", p => OpenPin(p), p => CanOpenPin(p), parameters: new CommandParameterInfo<int>("Number", "Number", "Pin number") ); Items.Add(command); Frequency = new PhysicalProperty<double>(this, nameof(Frequency), "Frequency", Controller.ActualFrequency, Units.Hertz); Items.Add(Frequency); MinFrequency = new PhysicalProperty<double>(this, nameof(MinFrequency), "Minimum frequency", Controller.MinFrequency, Units.Hertz); Items.Add(MinFrequency); MaxFrequency = new PhysicalProperty<double>(this, nameof(MaxFrequency), "Maximum frequency", Controller.MaxFrequency, Units.Hertz); Items.Add(MaxFrequency); command = new DelegateCommand<double>(this, nameof(SetFrequency), "Set frequency", p => SetFrequency(p), p => CanSetFrequency(p), parameters: new CommandPhysicalParameterInfo<double>(Frequency) ); Items.Add(command); }
public Windows10PwmDriverChip(int chipIndex) { // Open the Windows PWM controller for the specified PWM chip string controllerFriendlyName = $"PWM{chipIndex}"; string deviceSelector = WinPwm.PwmController.GetDeviceSelector(controllerFriendlyName); DeviceInformationCollection deviceInformationCollection = DeviceInformation.FindAllAsync(deviceSelector).WaitForCompletion(); if (deviceInformationCollection.Count == 0) { throw new ArgumentException($"No PWM device exists for PWM chip at index {chipIndex}", $"{nameof(chipIndex)}"); } string deviceId = deviceInformationCollection[0].Id; _winController = WinPwm.PwmController.FromIdAsync(deviceId).WaitForCompletion(); }
/// <summary> /// Initializes a new instance of the <see cref="Windows10PwmChannel"/> class. /// </summary> /// <param name="chip">The PWM chip number.</param> /// <param name="channel">The PWM channel number.</param> /// <param name="frequency">The frequency in hertz.</param> /// <param name="dutyCycle">The duty cycle percentage represented as a value between 0.0 and 1.0.</param> public Windows10PwmChannel( int chip, int channel, int frequency = 400, double dutyCycle = 0.5) { // When running on Hummingboard we require to use the default chip. var deviceInfo = new EasClientDeviceInformation(); bool useDefaultChip = false; if (deviceInfo.SystemProductName.IndexOf("Hummingboard", StringComparison.OrdinalIgnoreCase) >= 0) { useDefaultChip = true; } // Open the Windows PWM controller for the specified PWM chip. string deviceSelector = useDefaultChip ? WinPwm.PwmController.GetDeviceSelector() : WinPwm.PwmController.GetDeviceSelector($"PWM{chip}"); DeviceInformationCollection?deviceInformationCollection = DeviceInformation.FindAllAsync(deviceSelector).WaitForCompletion(); if (deviceInformationCollection is null || deviceInformationCollection.Count == 0) { throw new ArgumentException($"No PWM device exists for PWM chip at index {chip}.", nameof(chip)); } string deviceId = deviceInformationCollection[0].Id; WinPwm.PwmController?winController = WinPwm.PwmController.FromIdAsync(deviceId).WaitForCompletion(); if (winController is null) { throw new Exception("A PWM device could not be found."); } WinPwm.PwmPin?winPin = winController.OpenPin(channel); if (winPin is null) { throw new ArgumentOutOfRangeException(nameof(channel), $"The PWM chip is unable to open a channel at index {channel}."); } _winController = winController; _winPin = winPin; Frequency = frequency; DutyCycle = dutyCycle; }
private void Dispose(bool disposing) { if (disposing) { m_provider.ReleasePin(m_pinNumber); m_controller = null; m_provider = null; } }