public static void Main()
{
var led = new OutputPort(Pins.ONBOARD_LED, false);
while(true)
{
led.Write(false);
var requestUri = "http://dev3.aquepreview.com/helicoptersurface";
Debug.Print("Setup");
using (var request = (HttpWebRequest)WebRequest.Create(requestUri))
{
request.Method = "GET";
Debug.Print("Requesting");
// send request and receive response
using (var response = (HttpWebResponse)request.GetResponse())
{
HttpStatusCode status = response.StatusCode;
if (status == HttpStatusCode.OK)
{
var pwm = new PWM(Pins.GPIO_PIN_D5);
Debug.Print("200, all ok");
pwm.SetDutyCycle(1000);
led.Write(true);
}
}
}
Thread.Sleep(2000);
}
}
public HS6635HBServo(Cpu.Pin pwmPin, uint minPulse = 900, uint centerPulse = 1500, uint maxPulse = 2100) {
_servo = new PWM((Cpu.Pin)pwmPin);
_servo.SetDutyCycle(0);
MinRangePulse = minPulse;
CenterRangePulse = centerPulse;
MaxRangePulse = maxPulse;
PulseRefreshRateMs = 20;
}
public PiezoSpeaker(Cpu.Pin pin)
{
_pin = new PWM(pin);
// take the pin low, so the speaker
// doesn't make any noise until we
// ask it to
_pin.SetDutyCycle(0);
}
/// <summary>
/// Create the PWM pin, set it low and configure timings
/// </summary>
/// <param name="pin"></param>
public Servo(Cpu.Pin pin)
{
// Init the PWM pin
servo = new PWM((Cpu.Pin)pin);
servo.SetDutyCycle(0);
// Typical settings
range[0] = 1000;
range[1] = 2000;
}
public ServoController(Cpu.Pin pin, int minDuration, int maxDuration, uint period = 20000, int startDegree = 0)
{
_minDuration = minDuration;
_maxDuration = maxDuration;
_range = maxDuration - minDuration;
_period = period;
_servo = new PWM(pin);
_servo.SetDutyCycle(0);
if (startDegree > 0)
Rotate(startDegree);
}
public static void Main()
{
// write your code here
PWM led = new PWM(Pins.GPIO_PIN_D5);
AnalogInput pot = new AnalogInput(Pins.GPIO_PIN_A0);
pot.SetRange(0, 100);
int potValue = 0;
while (true)
{
potValue = pot.Read();
led.SetDutyCycle((unit)potValue);
}
}
public static void Main()
{
uint watchdogTimer = 1000;
PWM umbrella = new PWM(Pins.GPIO_PIN_D10); //Right controller
Socket receiveSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
receiveSocket.Bind(new IPEndPoint(IPAddress.Any, 4444));
byte[] rxData = new byte[10]; // Incoming data buffer
double raw_speed = 0;
while (true) /* Main program loop */
{
/* Try to receive new data - spend 100uS waiting */
if (receiveSocket.Poll(100, SelectMode.SelectRead))
{
int rxCount = receiveSocket.Receive(rxData);
watchdogTimer = 0;
}
if (watchdogTimer < 200) // Only enable the robot if data was received recently
{
// 900 (full rev) to 2100 (full fwd), 1500 is neutral
raw_speed += (rxData[0] - 127.5) * .001; // Add the value of the stick to the current speed
// Mediate added speed to negative if it's below center line(on ipgamepad). Make the added speed very little because the mount of UDP packets is large.
// map function only accept input between 0-255
if (raw_speed < 0)
{
raw_speed = 0;
}
else if (raw_speed > 255)
{
raw_speed = 255;
}
// Stick maintains speed unless calibrate changes.
umbrella.SetPulse(20000, map((uint)raw_speed, 0, 255, 1500, 2100)); // Right controller 1500-2100 -- only positive
watchdogTimer++;
}
else
{
// Disable the robot
umbrella.SetDutyCycle(0);
}
}
}
/// <summary>
/// Create the PWM pin, set it low and configure timings
/// </summary>
/// <param name="pin"></param>
public Servo(Cpu.Pin pin)
{
// Init the PWM pin
// servo = new PWM((Cpu.Pin)pin);
servo = new PWM((Cpu.PWMChannel)pin, 10000, 0.1, false);
servo.Period((uint)0);
servo.SetDutyCycle(0);
// Typical settings
range[0] = 1000;
range[1] = 2000;
// jha v1.2
forwardRange = 100;
reverseRange = -100;
}
/// <summary>
/// Create the PWM pin, set it low and configure timings
/// </summary>
/// <param name="pin"></param>
public ServoControl(Cpu.Pin pin)
{
try
{
// Init the PWM pin
servo = new PWM(pin);
servo.SetDutyCycle(0);
// Typical settings
range[0] = 1000;
range[1] = 2000;
}
catch(Exception ex)
{
}
}
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 = "C1C1C1g1a1a1g2E1E1D1D1C2u";
PWM speaker = new PWM(Pins.GPIO_PIN_D5);
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.SetPulse(noteDuration * 2, noteDuration);
Thread.Sleep(beatTimeInMilliseconds * beatCount - pauseTimeInMillisenconds);
speaker.SetDutyCycle(0);
Thread.Sleep(pauseTimeInMillisenconds);
}
Thread.Sleep(Timeout.Infinite);
}
private OutputPort MotorLatch, MotorEnable, MotorClk, MotorData; // 74HCT595 commands
#endregion Fields
#region Constructors
// Steper sequences for each stepper. Have a look here : http://www.stepperworld.com/Tutorials/pgBipolarTutorial.htm
//private byte[][] BipolarSteppingWaveDrive = new byte[][] { new byte [] {4,2,8,16},
// new byte [] {1,128,64,32}};
//private byte[][] BipolarSteppingHiTorque = new byte[][] { new byte [] {20,24,10,6},
// new byte [] {129,192,96,33}};
//private byte[][] BipolarSteppingHalfStep = new byte[][] { new byte [] {4,20,16,24,8,10,2,6},
// new byte [] {1,129,128,192,64,96,32,33}};
/// <summary>
/// Constructor
/// </summary>
/// <param name="driver"> Which driver to initialize : 1=driver 1, 2=driver 2, 3=both</param>
public Mshield()
{
//UsedDriver = driver;
//if (driver == Drivers.Driver1 || driver == Drivers.Both)
//{
// Motor1A = new OutputPort(Pins.GPIO_PIN_D11, false);
// Motor1B = new OutputPort(Pins.GPIO_PIN_D3, false);
//}
//if (driver == Drivers.Driver2 || driver == Drivers.Both)
//{
Motor2A = new PWM(Pins.GPIO_PIN_D5);
Motor2A.SetDutyCycle(0);
Motor2B = new PWM(Pins.GPIO_PIN_D6);
Motor2B.SetDutyCycle(0);
//}
MotorLatch = new OutputPort(Pins.GPIO_PIN_D12, true);
MotorEnable = new OutputPort(Pins.GPIO_PIN_D7, false);
MotorClk = new OutputPort(Pins.GPIO_PIN_D4, true);
MotorData = new OutputPort(Pins.GPIO_PIN_D8, true);
latch_state = 0;
latch_tx();
}
/// <summary>
/// Create a tlc device, and configure it to communicate on the SPI interface. Set the SPI settings to neutral:
/// new SPI.Configuration(Pins.GPIO_PIN_D8, false, 0, 0, ... , where the pin number can be the latch pin
///
/// </summary>
/// <param name="config">The SPI configuration. </param>
/// <param name="PWMchannel1">Channel for the GSCLK pin</param>
/// <param name="PWMChannel2">Channel for the BLANK pin</param>
/// <param name="LATCHpin">Required output channel</param>
/// <param name="channelCount">Must be max Channelcount provided by the Tlc5940</param>
public Tlc5940(SPI.Configuration config, PWM gsclk, PWM blank, OutputPort LATCHport, uint channelCount)
{
useSPIInterface = true;
SPIDevice = config;
SPIBus = new SPI(SPIDevice);
GSCLKPin = gsclk;
BLANKPin = blank;
XLATpin = LATCHport;
ValidateChannelCount(channelCount);
writeBuffer = CreateBuffer(channelCount);
// Clear the channels, and disable the output
GSCLKPin.SetDutyCycle(0);
BLANKPin.SetDutyCycle(0);
XLATpin.Write(false);
GSCLKPin.SetPulse(gsclk_period, 1);
//BLANKPin.SetPulse((gsclk_period * 4096), 1);
BLANKPin.SetPulse((gsclk_period)*(4096/2), 1);
//BLANKPin.SetPulse((gsclk_period + 1)*(4096/2), 1);
// THis is the arduino formula:
}
public static void Main()
{
var dummyTest = true;
//Connect real Input Ports to ground !
//3 Examples:
// 1. "normal"
// 2. interrupt driven
// 3. PWM driven on port D5 !!
var runSample = 1;
switch (runSample)
{ // "normal"
case 1:
switchPort = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);
while (dummyTest)
{
if (!switchPort.Read() || !realSwitchPort.Read() || !realSwitchPort1.Read() || !realSwitchPort2.Read())
{
ledPort.Write(true);
realLedPort.Write(true);
sleepTime = 500;
if (!realSwitchPort1.Read()) sleepTime = 300;
if (!realSwitchPort2.Read()) sleepTime = 100;
}
Thread.Sleep(sleepTime);
ledPort.Write(false);
realLedPort.Write(false);
Thread.Sleep(sleepTime);
}
break;
case 2:
// Interrupt Sample:
interruptPort = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);
interruptPort.OnInterrupt += new NativeEventHandler(interruptPort_OnInterrupt);
while (dummyTest)
{
}
break;
case 3:
// use PWM Port ..
var realLedPortPWM = new PWM(Pins.GPIO_PIN_D5);
uint outPWM = 0; bool up = true;
while (dummyTest)
{
if (up)
{
outPWM++;
if (outPWM >= 100)
{
up = false;
}
}
else
{
outPWM--;
if (outPWM <= 0)
{
up = true;
}
}
realLedPortPWM.SetDutyCycle(outPWM);
Thread.Sleep(8);
}
break;
default:
Debug.Print("This is no choice -- you are doomed!");
break;
}
}
public Servo(Cpu.Pin pin)
{
servo = new PWM(pin);
servo.SetDutyCycle(dutyCycle: 0);
}