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();
}
private void SetCyclePercentage(PwmPin pin, double value)
{
if (value >= 0 && value <= 1)
{
pin.SetActiveDutyCyclePercentage(value);
}
}
/// <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 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);
}
/// <inheritdoc/>
public void Dispose()
{
if (bluePin != null)
{
if (bluePin.IsStarted)
{
bluePin.Stop();
}
bluePin.Dispose();
bluePin = null;
}
if (greenPin != null)
{
if (greenPin.IsStarted)
{
greenPin.Stop();
}
greenPin.Dispose();
greenPin = null;
}
if (redPin != null)
{
if (redPin.IsStarted)
{
redPin.Stop();
}
redPin.Dispose();
redPin = null;
}
}
internal Servo(PwmController pwmController, int pwmPin)
{
_position = 0.0;
_limitsSet = false;
_pwmPin = pwmController.OpenPin(pwmPin);
_pwmPin.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();
}
// 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 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;
}
private void StopPin(PwmPin pin)
{
if (pin.IsStarted)
{
pin.Stop();
}
}
public ServoMotor(string controller, int PwmPinNumber)
{
PwmController PWM = PwmController.FromId(controller);
servo = PWM.OpenPin(PwmPinNumber);
PWM.SetDesiredFrequency(1 / 0.020);
}
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 Task init()
{
// ENSURE ITS DONE BEFORE PWM
// LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
// await PwmController.GetControllersAsyn DOES NOT WORK ON RPi3B+ in preview builds but works on other models
// var pwmControllers = await PwmController.GetControllersAsync(LightningPwmProvider.GetPwmProvider());
// HENCE USING PwmProviderManager
var pwmManager = new PwmProviderManager();
// Add providers
pwmManager.Providers.Add(new SoftPwm());
// Get the well-known controller collection back
var pwmControllers = await pwmManager.GetControllersAsync();
// Using the first PWM controller
this.pwmController = pwmControllers[0];
this.pwmController.SetDesiredFrequency(50);
this.panServo = this.pwmController.OpenPin(panMotorPin);
this.tiltServo = this.pwmController.OpenPin(TiltMotorPin);
this.panServo.SetActiveDutyCyclePercentage(this.RestingPulseLegnth);
this.panServo.Start();
this.tiltServo.SetActiveDutyCyclePercentage(this.RestingPulseLegnth);
this.tiltServo.Start();
var task = Task.Run(() =>
{
System.Threading.Tasks.Task.Delay(250).Wait();
this.tiltServo.Stop();
this.panServo.Stop();
});
}
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 bool disposedValue = false; // To detect redundant calls
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
this.conn.Close();
this.conn.Dispose();
this.conn = null;
pushButton.ValueChanged -= PushButton_ValueChanged;
pushButton.Dispose();
pushButton = null;
_servoPin.Dispose();
_servoPin = null;
foreach (FinishGate fg in FinishGates)
{
fg.Dispose();
}
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
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);
}
/// <summary>
/// Free up our resources.
/// </summary>
public void Dispose()
{
pin.Dispose();
pin = null;
t.Dispose();
t = null;
}
public PwmPinBase(PwmPin pin, int pinNumber, double frequency)
{
PinNumber = pinNumber;
_pin = pin;
Frequency = frequency;
MinPulseWidth = 0.0008;
MaxPulseWidth = 0.0026;
}
/// <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);
}
public PWM(IO60P16Module parentModule, PwmPin pin, double frequency_Hz, double dutyCycle, bool invertOutput)
{
_parentModule = parentModule;
_pin = pin;
_frequency = frequency_Hz;
_dutyCycle = dutyCycle;
_invertOutput = invertOutput;
}
/// <summary>
/// Disposes the underlying objects. This method will be called automatically and should not be called by user
/// code, but inheritors should call the base method.
/// </summary>
protected override void DisposeResource()
{
if (_pin != null)
{
_pin.Dispose();
_pin = null;
}
}
virtual protected void Dispose(bool disposing)
{
if (disposing)
{
_pin.Stop();
_pin.Dispose();
_pin = null;
}
}
/// <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();
}
private void DisposePin(PwmPin pin)
{
if (pin != null)
{
StopPin(pin);
pin.Dispose();
pin = null;
}
}
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);
}
public PWM(IO60P16Module parentModule, PwmPin pin, uint period, uint duration, ScaleFactor scale, bool invertOutput)
{
_parentModule = parentModule;
_pin = pin;
_period_ns = period * (uint)scale;
_duration_ns = duration * (uint)scale;
_scale = scale;
_invertOutput = invertOutput;
}
static void Main()
{
var _config = new configs.config(configs.Configuration.GetConfiguration());
Console.WriteLine("Starting... RaspiFanController StartingSettings is...");
Console.WriteLine($"PwmPin :{_config.PWMPin} GpioLogicPin: {_config.LogicPin}");
Console.WriteLine("\n**FanSpeedSettings");
Console.WriteLine($"*Frequency: {_config.PwmFrequency}Hz FanMaxSpeed: {_config.MaxSpeed}% FanMinSpeed: {_config.MinSpeed}%");
Console.WriteLine($"*FanMaxTemp:{_config.MaxSpeedTemp}C FanMinTemp: {_config.MinSpeedTemp}C");
using (var logicPin = new DigitalPin(_config.LogicPin, GpioPinDirection.Out))
using (var pwmPin = new PwmPin(_config.PWMPin, _config.PwmFrequency, 1))
{
Console.CancelKeyPress += (s, e) =>
{
Console.WriteLine("終了中...");
logicPin.Dispose();
pwmPin.Dispose();
};
logicPin.State = true;
Thread.Sleep(3000);
while (true)
{
float perSpeed = 1;
if (!float.TryParse(File.ReadAllText("/sys/class/thermal/thermal_zone0/temp"), out float temp))
{
return;
}
temp /= 1000;
if (_config.MaxSpeedTemp != _config.MinSpeedTemp)
{
float perTemp = (temp - _config.MinSpeedTemp) / (_config.MaxSpeedTemp - _config.MinSpeedTemp);
perSpeed = (_config.MinSpeed + ((_config.MaxSpeed - _config.MinSpeed) * perTemp)) / 100;
if (perTemp >= 1)
{
perSpeed = _config.MaxSpeed;
}
if (perTemp <= 0)
{
perSpeed = _config.MaxSpeed > _config.MinSpeed ? _config.MaxSpeed : _config.MinSpeed;
}
}
perSpeed = Math.Min(Math.Max(perSpeed, 0), 1);
Console.WriteLine($"[{DateTime.Now:yyyy/mm/dd HH:MM:ss}] Temp: {temp}C, Spd: {perSpeed * 100}%");
pwmPin.Duty = perSpeed;
Thread.Sleep(_config.GetStatePeriod * 1000);
}
}
}
/// <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 PwmPin OpenPin(int number)
{
number.ValidateIn(0, PinCount.Value - 1, nameof(number));
var pin = GetPin(number);
if (pin == null)
{
pin = new PwmPin(this,
string.Format($"Pin{number}"),
number,
Controller.OpenPin(number)
);
Children.Add(pin);
}
return pin;
}
/// <summary>
/// Sets the duty cycle of the given pwm pin.
/// </summary>
/// <param name="pin">The pin to set the duty cycle for.</param>
/// <param name="value">The new duty cycle between 0 (off) and 1 (on).</param>
public void SetPwmDutyCycle(PwmPin pin, double value) {
if (value < 0.0 || value > 1.0) throw new ArgumentOutOfRangeException(nameof(value));
if (!Enum.IsDefined(typeof(PwmPin), pin)) throw new ArgumentException(nameof(pin));
this.pwm.SetDutyCycle((int)pin, value);
}
