public override void Set(double frequency, double dutyCycle) { if (frequency < 0) { throw new ArgumentException("frequency"); } if (dutyCycle < 0 || dutyCycle > 1) { throw new ArgumentException("dutyCycle"); } if (_port == null) { _port = new Hardware.PWM(_channel, frequency, dutyCycle, _invert); _port.Start(); _started = true; } else { if (_started) { _port.Stop(); } _port.Frequency = frequency; _port.DutyCycle = dutyCycle; _port.Start(); _started = true; } }
/// <summary> /// Piezo speaker driver and notes and playback manager /// </summary> /// <param name="pin">From the SecretLabs.NETMF.Hardware.NetduinoPlus.PWMChannels namespace</param> /// <param name="name">Unique identifying name for command and control</param> public Piezo(Cpu.PWMChannel pin, string name) : base(name, "piezo") { //_piezo = new PWM(pin, 2048, 0, PWM.ScaleFactor.Milliseconds, false); _piezo = new PWM(pin, 2048, 0, false); _piezo.Start(); }
static double fadeAmount = 0.01; // brightness fade rate #endregion Fields #region Methods public static void Main() { // create a new outpot port using Pulse Width Modulation (PWM) and the onboard LED // PWM is a digital method of delivering a varying amount of power... // can be used to control the brightness of an LED or speed of a DC motor... PWM led = new PWM(SecretLabs.NETMF.Hardware.Netduino.PWMChannels.PWM_ONBOARD_LED, 100, 1.0, false); led.Start(); // enable the PWM LED // create a loop for the program to run in... while (true) { // PWM duty cycle value is a percentage of ON // 0.0 = 0%, while 1.0 = 100% led.DutyCycle = brightness; // scroll through the brightness at the rate of fadeAmount brightness = brightness + fadeAmount; // if we reach our limits... if (brightness <= 0.0 || brightness >= 0.99) { // invert the fade rate to go in reverse direction fadeAmount = -fadeAmount; } // sleep for 30ms, long enough to see the transistions Thread.Sleep(30); } }
private void Move(Direction direction) { //Debug.Print((!CANifier.GetGeneralInput(forwardLimitSwitch)).ToString() + (!CANifier.GetGeneralInput(reverseLimitSwitch)).ToString()); if (direction != lastDirection) { Thread.Sleep(250); } if (direction == Direction.FORWARDS && IsForwardLimitSwitchPressed()) { Stop(); // Debug.Print("Forward Limit Switch Tripped"); return; } else if (direction == Direction.BACKWARDS && IsReverseLimitSwitchPressed()) { Stop(); // Debug.Print("Reverse Limit Switch Tripped"); return; } lastDirection = direction; if (direction == Direction.STOPPED) { movePort.Stop(); return; } CANifier.SetGeneralOutput(directionPort, direction == Direction.FORWARDS, true); movePort.Start(); }
public PwmSpeaker(PWM pwm) { _pwm = pwm; _pwm.Frequency = 50; _pwm.DutyCycle = 0; _pwm.Start(); }
public static void Main() { var pwm0 = new PWM(Cpu.PWMChannel.PWM_0, 300, 0, false); pwm0.Start(); var pwm1 = new PWM(Cpu.PWMChannel.PWM_1, 300, 0, false); pwm1.Start(); var pwm2 = new PWM(Cpu.PWMChannel.PWM_2, 300, 0, false); pwm2.Start(); const int minBright = 0; const int maxBright = 100; int bright = minBright; int step = 1; while (true) { pwm0.DutyCycle = ToDutyCycle(bright); pwm1.DutyCycle = ToDutyCycleExp(bright); pwm2.DutyCycle = ToDutyCycle10(bright); bright += step; if (bright > maxBright || bright < minBright) { bright = bright > maxBright ? maxBright : minBright; step = -step; Thread.Sleep(1000); } Thread.Sleep(40); } }
public override void Set(double frequency, double dutyCycle) { if (frequency < 0) throw new ArgumentException("frequency"); if (dutyCycle < 0 || dutyCycle > 1) throw new ArgumentException("dutyCycle"); if (_port == null) { _port = new Hardware.PWM(_channel, frequency, dutyCycle, _invert); _port.Start(); _started = true; } else { if (_started) _port.Stop(); _port.Frequency = frequency; _port.DutyCycle = dutyCycle; _port.Start(); _started = true; } }
public static void Main() { // write your code here int anaIn = 250; // ADC is 12-bit Resolution //SecretLabs.NETMF.Hardware.AnalogInput pinA4 = new Microsoft.NETMF.Hardware.AnalogInput(Cpu.AnalogChannel.ANALOG_4); SecretLabs.NETMF.Hardware.AnalogInput pinA4 = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A4); OutputPort led = new OutputPort(Pins.ONBOARD_LED, false); //PWM led2 = new PWM(Cpu.PWMChannel.PWM_0, 100, 100, 0); PWM servo = new PWM(Cpu.PWMChannel.PWM_0,20000,1500,PWM.ScaleFactor.Microseconds, false); servo.Start(); servo.DutyCycle = 0; servo.Duration = (uint)1500; while (true) { double anaRead = pinA4.Read(); anaIn = (int)anaRead; //LED stuff //led.Write(true); // turn on the LED //Thread.Sleep(anaIn); // sleep for 250ms //led.Write(false); // turn off the LED //Thread.Sleep(anaIn); // sleep for 250ms servo.Duration = (uint)((1000+anaRead)); } }
private void PlaySound(uint period, uint duration, int length) { var pwm = new PWM(_channel, period, duration, PWM.ScaleFactor.Microseconds, false); pwm.Start(); Thread.Sleep(length); pwm.Stop(); }
internal static void SetUpServo() { uint period = 20000; uint duration = SERVO_NEUTRAL; _servo = new PWM(PWMChannels.PWM_PIN_D5, period, duration, PWM.ScaleFactor.Microseconds, false); _servo.Start(); _servoReady = true; }
public static void Start() { _port = new PWM(PWMChannels.PWM_PIN_D9, 100, 0.5, false); _port.Frequency = 100; _port.DutyCycle = 0.5; _worker.Start(); _port.Start(); }
public static void Main() { PWM speaker = new PWM(PWMChannels.PWM_PIN_D5, 2000, 0.95, true); // Store the notes on the music scale and their associated pulse lengths System.Collections.Hashtable scale = new System.Collections.Hashtable(); // low octave scale.Add("c", 1915u); scale.Add("d", 1700u); scale.Add("e", 1519u); scale.Add("f", 1432u); scale.Add("g", 1275u); scale.Add("a", 1136u); scale.Add("b", 1014u); // upper octave scale.Add("C", 956u); scale.Add("D", 851u); scale.Add("E", 758u); scale.Add("F", 671u); scale.Add("G", 594u); // hold note scale.Add("H", 0u); int beatsPerMinute = 90; int beatTimeInMilliseconds = 60000 / beatsPerMinute; int pauseTimeInMilliseconds = (int)(beatTimeInMilliseconds * 0.1); // Define the song (letter of note followed by length of note) string song = "C1C1C1g1a1a1g2E1E1D1D1C2"; // interpret and play the song for (int i = 0; i < song.Length; i += 2) { //Extract each note and the length in beats string note = song.Substring(i, 1); int beatCount = int.Parse(song.Substring(i + 1, 1)); // look up the note duration in milliseconds uint noteFrequency = (uint)scale[note]; int duration = beatCount * beatTimeInMilliseconds; // play the note for the desired duration speaker.Frequency = noteFrequency; Debug.Print(beatCount + "\t" + beatTimeInMilliseconds + "\t" + pauseTimeInMilliseconds + "\t" + duration + "\t" + speaker.Duration + "\t" + speaker.DutyCycle + "\t" + speaker.Frequency + "\t" + speaker.Period); speaker.Start(); Thread.Sleep(duration); speaker.Stop(); // Pause for 1/10th of one beat Thread.Sleep(pauseTimeInMilliseconds); } Thread.Sleep(Timeout.Infinite); }
public static void Main() { InterruptPort przycisk = new InterruptPort(Pins.GPIO_PIN_A_0, false, Port.ResistorMode.PullDown, Port.InterruptMode.InterruptEdgeLevelHigh);//przycisk var green = new PWM(Cpu.PWMChannel.PWM_0, 300, 0, false);//zielona var orange = new PWM(Cpu.PWMChannel.PWM_1, 300, 0, false);//pomaranczowa var red = new PWM(Cpu.PWMChannel.PWM_2, 300, 0, false); //czerwona var blue = new PWM(Cpu.PWMChannel.PWM_3, 300, 0, false);//niebieska green.Start(); orange.Start(); red.Start(); blue.Start(); int x = 0, y = 0, z = 0; var timer = new System.Threading.Timer(TimerCallback, null, 0, 1000); SPI.Configuration MyConfig = new SPI.Configuration(Pins.GPIO_PIN_E_3, false, 0, 0, true, true, 1000, SPI.SPI_module.SPI1); MySPI = new SPI(MyConfig); Config(); while (true) { red.DutyCycle = 0; green.DutyCycle = 0; blue.DutyCycle = 0; orange.DutyCycle = 0; if((ReadRegister(0x2D)>150)&&(ReadRegister(0x2D)<230)) { red.DutyCycle = 1; green.DutyCycle = 1; blue.DutyCycle = 1; orange.DutyCycle = 1; } if ((ReadRegister(0x29) > 160) && (ReadRegister(0x29) < 230)) blue.DutyCycle = 1; if ((ReadRegister(0x29) < 140) && (ReadRegister(0x29) > 20)) orange.DutyCycle = 1; if ((ReadRegister(0x2B) > 160) && (ReadRegister(0x2B) < 230)) red.DutyCycle = 1; if ((ReadRegister(0x2B) < 140) && (ReadRegister(0x2B) > 20)) green.DutyCycle = 1; x = DateTime.Now.Millisecond; if (x + 200 >= 999) x -= 999; Debug.Print(ReadRegister(0x29).ToString() + " " + ReadRegister(0x2B).ToString() + " " + ReadRegister(0x2D).ToString() + " " + x); while (DateTime.Now.Millisecond<= x + 200) { } } }
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 (); }
public static void Main() { // write your code here var scale = new System.Collections.Hashtable { { "c", 1915u }, { "d", 1700u }, { "e", 1519u }, { "f", 1432u }, { "g", 1275u }, { "a", 1136u }, { "b", 1014u }, { "C", 956u }, { "D", 851u }, { "E", 758u }, { "h", 0u } }; int beatsPerMinute = 90; int beatTimeInMilliseconds = 6000 / beatsPerMinute; int pauseTimeInMillisenconds = (int)(beatTimeInMilliseconds * 0.1); string song = "C1C1C1g1a1a1g2E1E1D1D1C2"; PWM speaker = new PWM(PWMChannels.PWM_PIN_D5, 100, .5, false); speaker.Start(); for (int i = 0; i < song.Length; i += 2) { string note = song.Substring(i, 1); int beatCount = int.Parse(song.Substring(i + 1, 1)); uint noteDuration = (uint)scale[note]; speaker.Duration = noteDuration; speaker.Period = (noteDuration * 2); Thread.Sleep(beatTimeInMilliseconds * beatCount - pauseTimeInMillisenconds); speaker.DutyCycle = 0; Thread.Sleep(pauseTimeInMillisenconds); } speaker.Stop(); Thread.Sleep(Timeout.Infinite); }
protected void InitializePeripherals() { _rtc = new DS3231(0x68, 100); // Run once to adjust the time on the RTC // _rtc.CurrentDateTime = new DateTime(2018, 12, 17, 22, 41, 0); _lcd = new Lcd2004 ( RS: N.Pins.GPIO_PIN_D8, E: N.Pins.GPIO_PIN_D9, D4: N.Pins.GPIO_PIN_D10, D5: N.Pins.GPIO_PIN_D11, D6: N.Pins.GPIO_PIN_D12, D7: N.Pins.GPIO_PIN_D13 ); H.PWM _contrast = new H.PWM(H.Cpu.PWMChannel.PWM_0, 1000, 0.6, false); _contrast.Start(); }
public static void Main() { // write your code here AnalogInput pot = new AnalogInput(Cpu.AnalogChannel.ANALOG_0); PWM pwm = new PWM(PWMChannels.PWM_PIN_D5, 1000.0, 0.1, false); pot.Offset = 0; pot.Scale = 100; double potValue = 0.0; while (true) { potValue = pot.Read(); pwm.DutyCycle = potValue; pwm.Start(); Thread.Sleep(10); } }
public static void Main() { var pwm0 = new PWM(Cpu.PWMChannel.PWM_0, 300, 0, false); pwm0.Start(); var pwm1 = new PWM(Cpu.PWMChannel.PWM_1, 300, 0, false); pwm1.Start(); var pwm2 = new PWM(Cpu.PWMChannel.PWM_2, 300, 0, false); pwm2.Start(); var pwm3 = new PWM(Cpu.PWMChannel.PWM_3, 300, 0, false); pwm3.Start(); using (var analogInput = new AnalogInput(Cpu.AnalogChannel.ANALOG_0)) { analogInput.Scale = 100; analogInput.Offset = 0; double prevVal = Double.MinValue; for (;;) { double currentVal = analogInput.Read(); //int raw = analogInput.ReadRaw(); //Debug.Print("Sample: " + val + " (" + raw + ")"); if (Math.Abs(currentVal - prevVal) >= 1) { pwm0.DutyCycle = pwm1.DutyCycle = pwm2.DutyCycle = pwm3.DutyCycle = ToDutyCycle(currentVal); //int volume = ToVolume(currentVal); //SendXbmcVolume(volume); prevVal = currentVal; } } } }
public static void Main() { var sensor = new HCSR04(Stm32F4Discovery.FreePins.PC2, Stm32F4Discovery.FreePins.PC1); //crash detect: red led on or off var crashLed = new OutputPort(Stm32F4Discovery.LedPins.Red, false); var scanPeriod = new TimeSpan(0, 0, 0, 0, 100);//100ms var detector = new CollisionDetector(sensor, scanPeriod) { Barier = 10 }; //10cm detector.StateChanged += crashLed.Write; //pwm frequency display (green led linear blink): far->lo freq, near->hi freq var distancePwm = new PWM(Cpu.PWMChannel.PWM_0, 1, 0, false); distancePwm.Start(); //print distance every 1s and change pwm freq DateTime nextPrint = DateTime.Now; for(;;) { TimeSpan pulse = sensor.Ping(); if (DateTime.Now > nextPrint) { float cm = HCSR04.ToCentimeters(pulse); string cmStr = cm.Equals(Single.MaxValue) ? "?" : cm.ToString("F1"); float inch = HCSR04.ToInches(pulse); string inStr = inch.Equals(Single.MaxValue) ? "?" : inch.ToString("F1"); Debug.Print("Distance: " + cmStr + " cm = " + inStr + " in"); nextPrint = DateTime.Now.AddSeconds(1); } distancePwm.Frequency = ToFrequency(pulse); distancePwm.DutyCycle = 0.5; Thread.Sleep(200); } }
public static void Main() { const uint period = 20000; //20ms in us const uint minDuration = 530; //0.53ms in us const uint maxDuration = 2350; //2.35ms in us var servo = new PWM(Cpu.PWMChannel.PWM_0, period, minDuration, PWM.ScaleFactor.Microseconds, false); servo.Start(); uint step = 30; for (uint angle = 0;; angle += step) { if (angle > 180) { step = (uint) -step; continue; } servo.Duration = Map(angle, 0, 180, minDuration, maxDuration); Thread.Sleep(2000); } }
public static void Main() { // write your code here PWM LED1 = new PWM(PWMChannels.PWM_ONBOARD_LED, 10000, 0.5, false); bool upside = true; LED1.Frequency = 10000; LED1.DutyCycle = 1; LED1.Start(); while (true) { if (upside == true) { Debug.Print("Plus"); LED1.DutyCycle+=0.01; Debug.Print(LED1.DutyCycle.ToString()); if (LED1.DutyCycle >= 0.90) { upside = false; } } else { Debug.Print("Minus"); LED1.DutyCycle-=0.01; Debug.Print(LED1.DutyCycle.ToString()); if (LED1.DutyCycle <= 0.10) { upside = true; } } Thread.Sleep(10); } }
public override void Set(uint period, uint highTime, SocketInterfaces.PwmScaleFactor factor) { if (_port == null) { _port = new Hardware.PWM(_channel, period, highTime, (Hardware.PWM.ScaleFactor)factor, _invert); _port.Start(); _started = true; } else { if (_started) { _port.Stop(); } _port.Scale = (Hardware.PWM.ScaleFactor)factor; _port.Period = period; _port.Duration = highTime; _port.Start(); _started = true; } }
public static void SendBit(PWM infraredOut, OutputPort led, char c) { if (c == '1') { var startTime = DateTime.Now; infraredOut.Start(); while (startTime.AddMilliseconds(sleep) > DateTime.Now) { led.Write(true); //noop } infraredOut.Stop(); } else { var startTime = DateTime.Now; while (startTime.AddMilliseconds(sleep) > DateTime.Now) { led.Write(false); //noop } startTime = DateTime.Now; } }
public static void Main() { _lcdShield = new DfRobotLcdShield(20, 4); // Create a custom degrees symbol (°), store it on the LCD for later use with the lat/long display _lcdShield.CreateChar(0, new byte[] { 0x0, 0x4, 0xa, 0x4, 0x0, 0x0, 0x0, 0x0 }); // 0 bars are not required as that would just require sending " " _lcdShield.CreateChar(1, new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1F }); _lcdShield.CreateChar(2, new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1F, 0x1F }); _lcdShield.CreateChar(3, new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x1F, 0x1F, 0x1F }); _lcdShield.CreateChar(4, new byte[] { 0x0, 0x0, 0x0, 0x0, 0x1F, 0x1F, 0x1F, 0x1F }); _lcdShield.CreateChar(5, new byte[] { 0x0, 0x0, 0x0, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }); _lcdShield.CreateChar(6, new byte[] { 0x0, 0x0, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }); _lcdShield.CreateChar(7, new byte[] { 0x0, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F }); // 8 bars are not required as that would just require sending byte 255. #if (NETDUINO) _thunderbolt = new ThunderBolt("COM1", AngleUnits.Degrees, AltitudeUnits.Meters, new OutputPort(Pins.GPIO_PIN_D13, false)); #endif #if (FEZLEMUR) _thunderbolt = new ThunderBolt("COM1", AngleUnits.Degrees, AltitudeUnits.Meters, new OutputPort(GHI.Pins.FEZLemur.Gpio.D13, false)); #endif #if (NTP) _ntpServer = new NtpServer(); #endif _lcdShield.OnButtonPressed += LcdshieldOnOnButtonPressed; DisplaySplash(); #if (NETDUINO) var backlight = new Microsoft.SPOT.Hardware.PWM(PWMChannels.PWM_PIN_D10, 10000, LcdBrightness / 100d, false); backlight.Start(); #endif TestLeds(); _thunderbolt.Open(); _thunderbolt.TimingMode = TimingModes.UTC; _thunderbolt.RequestManufacturingParameters(); _thunderbolt.RequestFirmwareVersion(); _thunderbolt.SetupUnitForDisciplining(); _thunderbolt.RequestTrackedSatelliteStatus(); _thunderbolt.TimeChanged += ThunderboltOnTimeChanged; Thread.Sleep(3000); DisplayVersion(); #if (NTP) _ntpServer.Start(); #endif while (true) { if (_thunderbolt.IsSerialDataBeingReceived) { if (!_isSurveyInProgress && _thunderbolt.IsSurveyInProgress()) { // Survey has just started. Jump to the page displaying survey progress. _previousPageNumber = _pageNumber; // Take note of the page we were on so we can switch back later. _isSurveyInProgress = true; _pageNumber = 2; // Set the new page to jump to. } else if (_isSurveyInProgress && !_thunderbolt.IsSurveyInProgress()) { // Survey has just finished. Jump to the previous page we were displaying. _pageNumber = _previousPageNumber; _isSurveyInProgress = false; } switch (_pageNumber) { case 1: DisplayScreenOne(); break; case 2: DisplayScreenTwo(); break; case 3: DisplayScreenThree(); break; case 4: DisplayScreenFour(); break; case 5: DisplaySatelliteSignalScreen(); break; case 6: DisplayPRNScreen(); break; case 7: DisplayDOPScreen(); break; #if (NTP) case 8: DisplayScreenNTP(); break; #endif default: DisplayScreenOne(); break; } UpdateAlarmIndicators(); } else { DisplayNoSerialDataScreen(); } } }
private void Initialise() { _range = _maxPosition - _minPosition; degreesRatio = (float)_range / (float)_maxDegrees; _servoMotor = new PWM(_pin, 100, 0.5, false); _servoMotor.DutyCycle = 0; _servoMotor.Duration = _minPosition; _servoMotor.Start(); //give the servo enough time to swing to _minPosition Util.Delay(250); }
public ContServo(Cpu.PWMChannel servo_pin) { servo = new PWM(servo_pin, 20, 0, false); servo.Start(); }
public static void SendBit(PWM infraredOut, char c) { if (c == '1') { var startTime = DateTime.Now; infraredOut.Start(); while (startTime.AddMilliseconds(sleep) > DateTime.Now) { } infraredOut.Stop(); } else { var startTime = DateTime.Now; while (startTime.AddMilliseconds(sleep) > DateTime.Now) { } startTime = DateTime.Now; } }
protected void SendCommandPulse(double pulseDuration) { //Debug.Print("Sending Command Pulse"); _pwm.DutyCycle = CalculateDutyCycle(pulseDuration); _pwm.Start(); // servo expects to run continuously }
public override void Set(uint period, uint highTime, SocketInterfaces.PwmScaleFactor factor) { if (_port == null) { _port = new Hardware.PWM(_channel, period, highTime, (Hardware.PWM.ScaleFactor)factor, _invert); _port.Start(); _started = true; } else { if (_started) _port.Stop(); _port.Scale = (Hardware.PWM.ScaleFactor)factor; _port.Period = period; _port.Duration = highTime; _port.Start(); _started = true; } }
private void Initialize(UIOMode mode, int select, int hwres, int intParam, bool isDigital, double scale, double offset) { _uioMode = mode; SelPort = (UIOSelector)select; switch (mode) { case UIOMode.UIOModeDigitalInput: break; case UIOMode.UIOModeDigitalOutput: DigitalOut = new DigitalOutput((Output)hwres); break; case UIOMode.UIOModeAnalogInput: _avg = new MovingAverageCalculator(intParam); AnalogIn = new AnalogIn((ADC)hwres, scale, offset, intParam) {Scale = scale, Offset = offset}; break; case UIOMode.UIOModeSoftPwm: if (intParam < 1 || intParam > 1000) throw new ArgumentOutOfRangeException("Il valore deve essere compreso nel range 1...1000 Hz", "freq"); //creo ed avvio il PWM software _softPwm = new SoftPWM(intParam, (Cpu.Pin)hwres); SoftPWM.Start(); break; case UIOMode.UIOModeRealPwm: if (intParam < 1 || intParam > 1000000) throw new ArgumentOutOfRangeException("Il valore deve essere compreso nel range 1...1 MHz", "freq"); //creo ed avvio il PWM hardware _realPwm = new PWM((Cpu.PWMChannel)hwres, intParam, 0, false); _realPwm.Start(); break; case UIOMode.UIOModeSoftDac: if (intParam < 1 || intParam > 1000) throw new ArgumentOutOfRangeException("Il valore deve essere compreso nel range 1...1000 Hz", "freq"); //creo ed avvio il PWM software _softPwm = new SoftPWM(intParam, (Cpu.Pin)hwres); SoftPWM.Start(); break; case UIOMode.UIOModeRealDac: if (intParam < 1 || intParam > 1000000) throw new ArgumentOutOfRangeException("Il valore deve essere compreso nel range 1...1 MHz", "freq"); //creo ed avvio il PWM hardware _realPwm = new PWM((Cpu.PWMChannel)hwres, intParam, 0, false); _realPwm.Start(); break; default: break; } //seleziono sul modulo il tipo di uscita DAC/PWM _pwmSel = new DigitalOutput((Output)SelPort); _pwmSel.Write(isDigital); }
public static void Main() { AnalogInput potentiometer = new AnalogInput(Cpu.AnalogChannel.ANALOG_0); // AnalogInput potentiometer = new AnalogInput(Pins.GPIO_PIN_A0); InputPort button1 = new InputPort(Pins.GPIO_PIN_D0, false, Port.ResistorMode.Disabled); PWM redLED = new PWM(PWMChannels.PWM_PIN_D6, 100, .5, false); PWM greenLED = new PWM(PWMChannels.PWM_PIN_D5, 100, .5, false); PWM blueLED = new PWM(PWMChannels.PWM_PIN_D9, 100, .5, false); /* uint R = 0; uint G = 0; uint B = 0; */ double Rdty = .5; double Gdty = .5; double Bdty = .5; uint Frequency_hz = 400; redLED.Frequency = Frequency_hz; redLED.DutyCycle = .5; redLED.Start(); greenLED.Frequency = Frequency_hz; greenLED.DutyCycle = .5; greenLED.Start(); blueLED.Frequency = Frequency_hz; blueLED.DutyCycle = .5; blueLED.Start(); bool LEDState = false; while (true) { if (button1.Read()) { if (LEDState == true) { LEDState = false; } else { LEDState = true; } } double sensorValue = 0; sensorValue = potentiometer.Read(); double brightness = sensorValue; // string sSensorValue = sensorValue.ToString; // Debug.Print(sensorValue.ToString("F1")); if (LEDState == true) { redLED.DutyCycle = sensorValue; greenLED.DutyCycle = sensorValue; blueLED.DutyCycle = sensorValue; redLED.Frequency = Frequency_hz; greenLED.Frequency = Frequency_hz; blueLED.Frequency = Frequency_hz; } else { redLED.DutyCycle = 0; greenLED.DutyCycle = 0; blueLED.DutyCycle = 0; redLED.Frequency = 0; greenLED.Frequency = 0; blueLED.Frequency = 0; } Thread.Sleep(10); } }
private static void ActivateServo() { uint period = 20; uint duration = 1; PWM servo = new PWM(PWMChannels.PWM_PIN_D5, period, duration, PWM.ScaleFactor.Milliseconds, false); servo.Start(); Thread.Sleep(Timeout.Infinite); }
private static void TestServoFullRange() { uint period = 20000; uint duration = 1500; PWM servo = new PWM(PWMChannels.PWM_PIN_D5, period, duration, PWM.ScaleFactor.Microseconds, false); servo.Start(); Thread.Sleep(2000); servo.Duration = 2500; Thread.Sleep(3000); servo.Duration = 500; Thread.Sleep(3000); servo.Duration = 1500; }
public PWM_AIO_Demo_Main() { //AIO pin connected to arbitrary range potentiometer. AnalogInput pot = new AnalogInput(AnalogChannels.ANALOG_PIN_A0); pot.Scale = 1; //sets range value that is returned by aio read() /* * Spawn task to poll DHT11 temp/humid sensor. * This polling takes time and the quality of the hardware/driver mean the * polling takes inconsistent amounts of time. Also, the read operation is * subject to timeouts which should not be allowed to suspend other tasks. */ Thread analogReadTask = new Thread(new ThreadStart(new AnalogReadClass().PollTempHumidity)); analogReadTask.Start(); //Spin untill task spawn completes while (!analogReadTask.IsAlive) ; //initialize PWM properties before handoff to forever loop double freq = 1000; double duty = .5; OutputPort onboardLed = new OutputPort(Pins.ONBOARD_LED, false); PWM led = new PWM(PWMChannels.PWM_PIN_D5, freq, duty, false); //Another output port to drive transistor, which drives coil of relay. OutputPort relay = new OutputPort(Pins.GPIO_PIN_D0, false); //Starts pwm channel at initialized rate/duty //Will be modified by pollwrite loop led.Start(); LCD_Display Display = new LCD_Display(0x27, 20, 4); Display.writeValue("Good"); //loop forever to get AIO value and set led pwm PollAndWriteLoop(pot, led, relay); }
public void Start() { pwm = new PWM(pwmChannel, frequency, Duty, false); pwm.Start(); }
/// <summary> /// To be called after setting the properties of the object. /// If not called explicitly, it is automatically called when /// the actuator is used for the first time. /// Preconditions /// Actuator is not open /// Channel is set /// Period is set /// if MinValue or MaxValue is set: MinValue lessThan MaxValue /// Postconditions /// Actuator is open /// </summary> public void Open() { Contract.Requires(port == null); // actuator is not open Contract.Requires(Channel >= 0); Contract.Requires(Period > 0); Contract.Requires(MinValue < MaxValue); minValue = MinValue; maxValue = MaxValue; port = new PWM((Cpu.PWMChannel)Channel, (uint)Period, 0, PWM.ScaleFactor.Microseconds, false); port.Start(); }