/// <summary>
/// Initialize a ServoMotor class
/// </summary>
/// <param name="pinNumber">The GPIO pin number in case of a software PWM. The chip in case of a hardware PWM</param>
/// <param name="pwmChannel">The channel to use in case of a hardware PWM.</param>
/// <param name="definition">The definition of a ServoMotor</param>
/// <remarks>Use -1 for pwmChannel to force using software PWM</remarks>
public ServoMotor(int pinNumber, int pwmChannel, ServoMotorDefinition definition)
{
this._definition = definition;
_pulseFrequency = definition.PeriodMicroseconds / 1000.0;
UpdateRange();
_servoPin = pinNumber;
this._pwmChannel = pwmChannel;
// try hardware PWM first
try
{
_pwmController = new PwmController();
_pwmController.OpenChannel(pinNumber, pwmChannel);
IsRunningHardwarePwm = true;
}
catch (Exception ex) when(ex is ArgumentException || ex is IOException)
{
_pwmController = new PwmController(new SoftPwm(true));
_pwmController.OpenChannel(pinNumber, pwmChannel);
IsRunningHardwarePwm = false;
}
_pwmController.StartWriting(_servoPin, pwmChannel, 1000 / _pulseFrequency, (1 - (_pulseFrequency - _currentPulseWidth) / _pulseFrequency) * 100);
}
static void PWMFanSimpleExample()
{
Console.WriteLine("Starting PWM Controller - Simple Demo");
using (var controller = new PwmController())
{
double dutyCycle = 100;
var chip = 0;
var channel = 0;
var hertz = 25;
controller.OpenChannel(chip, channel);
controller.StartWriting(chip, channel, hertz, dutyCycle);
Console.WriteLine("Duty cycle " + dutyCycle);
Task.Delay(new TimeSpan(0, 0, 10)).Wait(); //10 second wait to give fan time to power up
ReadTachometer();
dutyCycle = 70;
controller.ChangeDutyCycle(chip, channel, dutyCycle);
Console.WriteLine("Duty cycle " + dutyCycle);
Task.Delay(new TimeSpan(0, 0, 2)).Wait(); //2 second wait
ReadTachometer();
dutyCycle = 30;
controller.ChangeDutyCycle(chip, channel, dutyCycle);
Console.WriteLine("Duty cycle " + dutyCycle);
Task.Delay(new TimeSpan(0, 0, 2)).Wait(); //2 second wait
ReadTachometer();
controller.ChangeDutyCycle(chip, channel, 0); //
controller.StopWriting(chip, channel);
controller.CloseChannel(chip, channel);
Console.WriteLine("Finished - Simple Demo");
}
}
public DCMotor2PinNoEnable(
PwmController pwmController,
double pwmFrequency,
int pwmChip,
int pwmChannel,
int?pin1,
GpioController controller) : base(controller)
{
_pwm = pwmController;
_chip = pwmChip;
_channel = pwmChannel;
_pin1 = pin1;
_speed = 0;
_pwm.OpenChannel(_chip, _channel);
_pwm.StartWriting(_chip, _channel, pwmFrequency, 0);
if (_pin1.HasValue)
{
Controller.OpenPin(_pin1.Value, PinMode.Output);
Controller.Write(_pin1.Value, PinValue.Low);
}
}
public DCMotor3Pin(
PwmController pwmController,
double pwmFrequency,
int pwmChip,
int pwmChannel,
int pin0,
int pin1,
GpioController controller)
: base(controller)
{
if (pwmController == null)
{
throw new ArgumentNullException(nameof(pwmController));
}
_pwm = pwmController;
_chip = pwmChip;
_channel = pwmChannel;
_pin0 = pin0;
_pin1 = pin1;
_speed = 0;
_pwm.OpenChannel(_chip, _channel);
_pwm.StartWriting(_chip, _channel, pwmFrequency, 0);
Controller.OpenPin(_pin0, PinMode.Output);
Controller.Write(_pin0, PinValue.Low);
Controller.OpenPin(_pin1, PinMode.Output);
Controller.Write(_pin1, PinValue.Low);
}
/// <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.FromName(controller);
_servo = pwm.OpenChannel(pwmPinNumber);
pwm.SetDesiredFrequency(1 / 0.020);
}
/// <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.FromName(controller);
_pwmPin = ctl.OpenChannel(pin);
_playlist = new Queue();
_syncRoot = new object();
}
/// <summary>
/// Main class constructor for Buzzer
/// <para><b>Pins used :</b> Cs, Pwm</para>
/// </summary>
/// <param name="socket">The socket on which the Buzzer Click board is plugged on MikroBus.Net</param>
/// <exception cref="System.InvalidOperationException">Thrown if some pins are already in use by another board on the same socket</exception>
public BuzzerClick(Hardware.Socket socket)
{
// Initialize PWM and set initial brightness
PWM = PwmController.FromName(socket.PwmController);
PWM.SetDesiredFrequency(10000);
_buzzPwm = PWM.OpenChannel(socket.PwmChannel);
_buzzPwm.SetActiveDutyCyclePercentage(0.0);
_buzzPwm.Start();
_playList = new Melody();
}
static Motors()
{
PWM.SetDesiredFrequency(6000);
M1PWM = PWM.OpenChannel(FEZ.PwmChannel.Controller3.D9);
M1PWM.Stop();
M1PWM.SetActiveDutyCyclePercentage(0.1);
M1PWM.Start();
M2PWM = PWM.OpenChannel(FEZ.PwmChannel.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);
}
/// <summary>
/// Create Buzzer class instance with output on specified pin with specified channel.
/// </summary>
/// <param name="pinNumber">The GPIO pin number in case of a software PWM. The chip in case of a hardware PWM.</param>
/// <param name="pwmChannel">The channel to use in case of a hardware PWM.</param>
public Buzzer(int pinNumber, int pwmChannel)
{
_buzzerPin = pinNumber;
_pwmChannel = pwmChannel;
try
{
_pwmController = new PwmController();
_pwmController.OpenChannel(_buzzerPin, _pwmChannel);
}
catch (Exception ex) when(ex is ArgumentException || ex is IOException)
{
// If hardware PWM is unable to initialize we will use software PWM.
_pwmController = new PwmController(new SoftPwm(true));
_pwmController.OpenChannel(_buzzerPin, _pwmChannel);
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello PWM!");
var PwmController = new PwmController(new SoftPwm());
PwmController.OpenChannel(17, 0);
PwmController.StartWriting(17, 0, 200, 0);
while (true)
{
for (int i = 0; i < 100; i++)
{
PwmController.ChangeDutyCycle(17, 0, i);
Thread.Sleep(100);
}
}
}
