protected H.OutputPort _enablePort = null; // if enabled, then IsNeutral = false public HBridgeMotor(H.Cpu.PWMChannel a1Pin, H.Cpu.PWMChannel a2Pin, H.Cpu.Pin enablePin, float pwmFrequency = 1600) { this._pwmFrequency = pwmFrequency; // create our PWM outputs this._motorLeftPwm = new H.PWM(a1Pin, _pwmFrequency, 0, false); this._motorRighPwm = new H.PWM(a2Pin, _pwmFrequency, 0, false); this._enablePort = new H.OutputPort(enablePin, false); }
public static HBridgeMotor CreateForNetduino(Microsoft.SPOT.Hardware.Cpu.PWMChannel enable, Microsoft.SPOT.Hardware.Cpu.Pin a1, Microsoft.SPOT.Hardware.Cpu.Pin a2) { var leftPwm = new Robotics.Micro.Devices.PwmOutputPin(enable); var leftMotor = new HBridgeMotor(leftPwm); leftMotor.A1Output.ConnectTo(new Robotics.Micro.Devices.DigitalOutputPin(a1).Input); leftMotor.A2Output.ConnectTo(new Robotics.Micro.Devices.DigitalOutputPin(a2).Input); return(leftMotor); }
/// <summary> /// Creates a new PwmLed on the specified PWM pin and limited to the appropriate /// voltage based on the passed `forwardVoltage`. Typical LED forward voltages /// can be found in the `TypicalForwardVoltage` class. /// </summary> /// <param name="pin"></param> /// <param name="forwardVoltage"></param> public PwmLed(H.Cpu.PWMChannel pin, float forwardVoltage) { // validate and persist forward voltage if (forwardVoltage < 0 || forwardVoltage > 3.3F) { throw new ArgumentOutOfRangeException("forwardVoltage", "error, forward voltage must be between 0, and 3.3"); } this.ForwardVoltage = forwardVoltage; this._maximumPwmDuty = Helpers.CalculateMaximumDutyCycle(forwardVoltage); this._pwm = new H.PWM(pin, 100, this._maximumPwmDuty, false); }
public NativePwmOutput(Socket socket, Socket.Pin pin, bool invert, Module module, Hardware.Cpu.PWMChannel channel) { if (channel == Hardware.Cpu.PWMChannel.PWM_NONE) { Socket.InvalidSocketException.ThrowIfOutOfRange(pin, Socket.Pin.Seven, Socket.Pin.Nine, "PWM", module); // this is a mainboard error that should not happen (we already check for it in SocketInterfaces.RegisterSocket) but just in case... throw Socket.InvalidSocketException.FunctionalityException(socket, "PWM"); } _channel = channel; _socket = socket; _invert = invert; }
public NativePwmOutput(Socket socket, Socket.Pin pin, bool invert, Module module, Hardware.Cpu.PWMChannel channel) { if (channel == Hardware.Cpu.PWMChannel.PWM_NONE) { Socket.InvalidSocketException.ThrowIfOutOfRange(pin, Socket.Pin.Seven, Socket.Pin.Nine, "PWM", module); // this is a mainboard error that should not happen (we already check for it in SocketInterfaces.RegisterSocket) but just in case... throw Socket.InvalidSocketException.FunctionalityException(socket, "PWM"); } _channel = channel; _socket = socket; _invert = invert; }
public PwmOutputPin(Microsoft.SPOT.Hardware.Cpu.PWMChannel channel, double frequencyHz = 1000, double dutyCycle = 0) { pwm = new PWM(channel, frequencyHz, dutyCycle, false); DutyCycleInput = AddInput("DutyCycleInput", Units.Ratio, dutyCycle); FrequencyInput = AddInput("FrequencyInput", Units.Frequency, frequencyHz); DutyCycleInput.ValueChanged += (s, e) => { pwm.DutyCycle = DutyCycleInput.Value; }; FrequencyInput.ValueChanged += (s, e) => { pwm.Frequency = FrequencyInput.Value; }; pwm.Start(); }
/// <summary> /// /// Implementation notes: Architecturally, it would be much cleaner to construct this class /// as three PwmLeds. Then each one's implementation would be self-contained. However, that /// would require three additional threads during ON; one contained by each PwmLed. For this /// reason, I'm basically duplicating the functionality for all three in here. /// </summary> /// <param name="redPin"></param> /// <param name="greenPin"></param> /// <param name="bluePin"></param> /// <param name="isCommonCathode"></param> public RgbPwmLed( H.Cpu.PWMChannel redPin, H.Cpu.PWMChannel greenPin, H.Cpu.PWMChannel bluePin, float redLedForwardVoltage = TypicalForwardVoltage.ResistorLimited, float greenLedForwardVoltage = TypicalForwardVoltage.ResistorLimited, float blueLedForwardVoltage = TypicalForwardVoltage.ResistorLimited, bool isCommonCathode = true) { // validate and persist forward voltages if (redLedForwardVoltage < 0 || redLedForwardVoltage > 3.3F) { throw new ArgumentOutOfRangeException("redLedForwardVoltage", "error, forward voltage must be between 0, and 3.3"); } RedForwardVoltage = redLedForwardVoltage; if (greenLedForwardVoltage < 0 || greenLedForwardVoltage > 3.3F) { throw new ArgumentOutOfRangeException("greenLedForwardVoltage", "error, forward voltage must be between 0, and 3.3"); } GreenForwardVoltage = greenLedForwardVoltage; if (blueLedForwardVoltage < 0 || blueLedForwardVoltage > 3.3F) { throw new ArgumentOutOfRangeException("blueLedForwardVoltage", "error, forward voltage must be between 0, and 3.3"); } BlueForwardVoltage = blueLedForwardVoltage; // calculate and set maximum PWM duty cycles _maximumRedPwmDuty = Helpers.CalculateMaximumDutyCycle(RedForwardVoltage); _maximumGreenPwmDuty = Helpers.CalculateMaximumDutyCycle(GreenForwardVoltage); _maximumBluePwmDuty = Helpers.CalculateMaximumDutyCycle(BlueForwardVoltage); IsCommonCathode = isCommonCathode; RedPin = redPin; GreenPin = greenPin; BluePin = bluePin; RedPwm = new H.PWM(RedPin, 100, 0, false); GreenPwm = new H.PWM(GreenPin, 100, 0, false); BluePwm = new H.PWM(BluePin, 100, 0, false); }
/// <summary> /// Instantiates a new Servo on the specified PWM Pin with the specified config. /// </summary> /// <param name="pin"></param> /// <param name="config"></param> public ServoBase(H.Cpu.PWMChannel pin, ServoConfig config) { _config = config; _pwm = new H.PWM(pin, config.Frequency, 0, false); }
public StepperMotorController(CTRE.Phoenix.CANifier CANifier, CTRE.Phoenix.CANifier.GeneralPin directionPin, Microsoft.SPOT.Hardware.Cpu.PWMChannel movePin, uint maxSpeed, CTRE.Phoenix.CANifier.GeneralPin forwardLimitSwitchPin, CTRE.Phoenix.CANifier.GeneralPin reverseLimitSwitchPin) { lastDirection = Direction.STOPPED; this.maxSpeed = maxSpeed; this.directionPort = directionPin; this.forwardLimitSwitch = forwardLimitSwitchPin; this.reverseLimitSwitch = reverseLimitSwitchPin; this.CANifier = CANifier; movePort = new PWM(movePin, maxSpeed, maxSpeed / 2, PWM.ScaleFactor.Microseconds, false); }
/// <summary> /// Instantiates a new continuous rotation servo on the specified pin, with the specified configuration. /// </summary> /// <param name="pin"></param> /// <param name="config"></param> public ContinuousRotationServo(H.Cpu.PWMChannel pin, ServoConfig config) : base(pin, config) { }