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);
}
}