public ServoMotor(string controller, int PwmPinNumber)
{
var PWM = PwmController.FromName(controller);
this.servo = PWM.OpenChannel(PwmPinNumber);
PWM.SetDesiredFrequency(1 / 0.020);
}
static void InitBot()
{
var chip = new GHIElectronics.TinyCLR.Drivers.Nxp.PCA9685.PCA9685Controller(
I2cController.FromName(FEZBit.I2cBus.Edge));
var gpioController = GpioController.GetDefault();
var buzzerController = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.PwmChannel.Controller3.EdgeP0Channel);
var frontsensorenable = gpioController.OpenPin(FEZBit.GpioPin.EdgeP9);
var frontsensorvaluecontroller = AdcController.FromName(FEZBit.AdcChannel.Controller1.Id);
var frontvalue = frontsensorvaluecontroller.OpenChannel(FEZBit.AdcChannel.Controller1.EdgeP3);
var lineDetectLeft = AdcController.FromName(FEZBit.AdcChannel.Controller1.Id).OpenChannel(FEZBit.AdcChannel.Controller1.EdgeP2);
var lineDetectRight = AdcController.FromName(FEZBit.AdcChannel.Controller1.Id).OpenChannel(FEZBit.AdcChannel.Controller1.EdgeP1);
var p2remove = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP1);
p2remove.SetDriveMode(GpioPinDriveMode.Input);
bot = new BitBotController(
chip, buzzerChannel,
lineDetectLeft, lineDetectRight,
gpioController.OpenPin(FEZBit.GpioPin.EdgeP14), gpioController.OpenPin(FEZBit.GpioPin.EdgeP15),
frontsensorenable, frontvalue,
gpioController.OpenPin(FEZBit.GpioPin.EdgeP16));
bot.SetHeadlight(200, 50, 0);
bot.SetStatusLeds(false, true, false);
bot.SetColorLeds(0, 0xff, 0, 0);
bot.SetColorLeds(1, 0, 0xff, 0);
bot.SetColorLeds(2, 0, 0, 0xff);
bot.Beep();
}
/// <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>
/// Initializes a new instance of the <see cref="DCMotorClick"/> class.
/// </summary>
/// <param name="socket">The socket on which the DCMotor Click board is plugged on MikroBus.Net</param>
/// <param name="frequency">The frequency of the PWM output. Default value is 1000 Hz</param>
/// <param name="dutyCycle">The initial duty cycle of PWM. Default to 0.0 %, that is : motor stopped</param>
public DCMotorClick(Hardware.Socket socket, Double frequency = 1000.0, Double dutyCycle = 0.0)
{
// Select1/2 : selection of decay modes. Only Fast decay implemented here.
_select1 = GpioController.GetDefault().OpenPin(socket.Rst);
_select1.SetDriveMode(GpioPinDriveMode.Output);
_select1.Write(GpioPinValue.Low);
_select2 = GpioController.GetDefault().OpenPin(socket.Cs);
_select2.SetDriveMode(GpioPinDriveMode.Output);
_select2.Write(GpioPinValue.Low);
_sleep = GpioController.GetDefault().OpenPin(socket.AnPin);
_sleep.SetDriveMode(GpioPinDriveMode.Output);
_sleep.Write(GpioPinValue.High);
var PWM = PwmController.FromName(socket.PwmController);
PWM.SetDesiredFrequency(frequency);
_pwmOut = PWM.OpenChannel(socket.PwmChannel);
_pwmOut.SetActiveDutyCyclePercentage(dutyCycle);
_fault = GpioController.GetDefault().OpenPin(socket.Int);
_fault.SetDriveMode(GpioPinDriveMode.Input);
_fault.ValueChanged += Fault_ValueChanged;
IsMoving = false; // Motor not running
_powerMode = PowerModes.On;
}
static void Main()
{
////////// Set these to match your board //////////////
var clickRstPin = SC20100.GpioPin.PD4;
var clickCsPin = SC20100.GpioPin.PD3;
var clickPwmPin = SC20100.PwmChannel.Controller2.PA15;
var clickPwmController = SC20100.PwmChannel.Controller2.Id;
//var ClickRstPin = SC20100.GpioPin.PD15;
//var ClickCsPin = SC20100.GpioPin.PD14;
//var ClickPwmPin = SC20100.PwmChannel.Controller13.PA6;
//var ClickPwmController = SC20100.PwmChannel.Controller13.Id;
///////////////////////////////////////////////////////
var gpio = GpioController.GetDefault();
var motor = new DCMotor(
gpio.OpenPin(clickRstPin),
gpio.OpenPin(clickCsPin),
PwmController.FromName(clickPwmController).OpenChannel(clickPwmPin));
while (true)
{
motor.Set(90); // Forward at 90% speed
Thread.Sleep(3000);
motor.Set(-70); // Reverse at 70% speed
Thread.Sleep(3000);
}
}
static void Main()
{
// Buzzer is on PA15.
// Use intellisense to determine what controller hosts PC6
var buzzerController = PwmController.FromName(G30.PwmChannel.Controller3.Id);
var buzzer = buzzerController.OpenChannel(G30.PwmChannel.Controller3.PC6);
var freq = 2000.0;
var delta = 100.0;
buzzerController.SetDesiredFrequency(freq);
// we are playing a square wave to make sound. Set duty cycle to 50%.
buzzer.SetActiveDutyCyclePercentage(0.5);
buzzer.Start();
while (true)
{
buzzerController.SetDesiredFrequency(freq);
freq += delta;
if (freq < 1000 || freq > 5000)
{
delta *= -1;
}
Thread.Sleep(20);
}
}
public static void Main()
{
UCMStandard.SetModel(UCMModel.UC5550);
new Thread(Blinker).Start();
var frequency = 1000;
var pwmController = PwmController.FromName(UCMStandard.PwmChannel.A.Id);
var buzzer = pwmController.OpenChannel(UCMStandard.PwmChannel.A.Pin);
pwmController.SetDesiredFrequency(frequency);
buzzer.SetActiveDutyCyclePercentage(0.5);
buzzer.Start();
while (true)
{
pwmController.SetDesiredFrequency(frequency);
if ((frequency += 100) > 5000)
{
frequency = 1000;
}
Thread.Sleep(20);
}
}
static void TestMaqueen()
{
var buzzerController = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.PwmChannel.Controller3.EdgeP0Channel);
var lineDetectLeft = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP13);
var lineDetectRight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP14);
var leftHeadlight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP8);
var rightHeadight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP12);
var bot = new GHIElectronics.TinyCLR.Dfrobot.MicroMaqueen.MaqueenController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
leftHeadlight, rightHeadight,
lineDetectLeft, lineDetectRight,
GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP15)
);
bot.Beep();
bot.SetColorLeds(1, 100, 0, 0);
bot.SetColorLeds(0, 0, 50, 100);
bot.SetHeadlight(true, true);
bot.SetHeadlight(false, true);
bot.SetMotorSpeed(0.5, 0.5);
bot.SetMotorSpeed(0.5, -0.5);
bot.SetMotorSpeed(-0.5, 0.5);
bot.SetMotorSpeed(0, 0);
while (true)
{
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
Thread.Sleep(50);
bot.Beep();
}
}
static void TestCuteBot()
{
var buzzerController = PwmController.FromName(FEZBit.Timer.Pwm.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.Timer.Pwm.Controller3.P0);
var lineDetectLeft = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P13);
var lineDetectRight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P14);
var bot = new GHIElectronics.TinyCLR.Elecfreaks.TinyBit.CuteBotController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
lineDetectLeft, lineDetectRight,
GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P15)
);
bot.Beep();
bot.SetColorLeds(1, 100, 0, 0);
bot.SetColorLeds(0, 0, 50, 100);
bot.SetHeadlight(true, 30, 100, 100);
bot.SetHeadlight(false, 30, 0, 200);
bot.SetMotorSpeed(0.5, 0.5);
bot.SetMotorSpeed(0.5, -0.5);
bot.SetMotorSpeed(-0.5, 0.5);
bot.SetMotorSpeed(0, 0);
while (true)
{
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
Thread.Sleep(50);
bot.Beep();
}
}
public GpioCharacterDisplay(
string PwmControllerName,
int pinV0,
int pinRS,
int pinE,
int pinD4,
int pinD5,
int pinD6,
int pinD7,
ushort rows = 4, ushort columns = 20)
{
/*
* this(
* device.CreatePwmPort(pinV0, 100, 0.5f, true),
* device.CreateDigitalOutputPort(pinRS),
* device.CreateDigitalOutputPort(pinE),
* device.CreateDigitalOutputPort(pinD4),
* device.CreateDigitalOutputPort(pinD5),
* device.CreateDigitalOutputPort(pinD6),
* device.CreateDigitalOutputPort(pinD7),
* rows, columns)
*/
var controller = PwmController.FromName(PwmControllerName);
var pwmPort = controller.OpenChannel(pinV0);
pwmPort.Controller.SetDesiredFrequency(100);
pwmPort.SetActiveDutyCyclePercentage(0.5f);
bool inverted = true;
pwmPort.Polarity = inverted ? PwmPulsePolarity.ActiveHigh : PwmPulsePolarity.ActiveLow;
var gpio = GpioController.GetDefault();
var DpinRS = gpio.OpenPin(pinRS);
DpinRS.SetDriveMode(GpioPinDriveMode.Output);
var DpinE = gpio.OpenPin(pinE);
DpinE.SetDriveMode(GpioPinDriveMode.Output);
var DpinD4 = gpio.OpenPin(pinD4);
DpinD4.SetDriveMode(GpioPinDriveMode.Output);
var DpinD5 = gpio.OpenPin(pinD5);
DpinD5.SetDriveMode(GpioPinDriveMode.Output);
var DpinD6 = gpio.OpenPin(pinD6);
DpinD6.SetDriveMode(GpioPinDriveMode.Output);
var DpinD7 = gpio.OpenPin(pinD7);
DpinD7.SetDriveMode(GpioPinDriveMode.Output);
setDisplay(pwmPort, DpinRS, DpinE, DpinD4, DpinD5, DpinD6, DpinD7, rows, columns);
}
/// <summary>
/// Create a new PiezoSpeaker instance
/// </summary>
/// <param name="pin">PWM Pin connected to the PiezoSpeaker</param>
public PiezoSpeaker(string PwmControllerName, int pin, float frequency = 100, float dutyCycle = 0)
{
var controller = PwmController.FromName(PwmControllerName);
var pwmPort = controller.OpenChannel(pin);
Port.Controller.SetDesiredFrequency(frequency);
Port.SetActiveDutyCyclePercentage(dutyCycle);
}
/// <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();
}
/// <summary>
/// Initializes a new instance of the <see cref="SevenSegClick"/> class.
/// </summary>
/// <param name="socket">The socket on which the 7Seg Click board is plugged on the MBN board</param>
/// <param name="initialBrightness">Initial brightness in the range 0.0 (no display) to 1.0 (full brightness)</param>
public SevenSegClick(Hardware.Socket socket, Double initialBrightness = 1.0)
{
_sevenSeg = SpiController.FromName(socket.SpiBus).GetDevice(new SpiConnectionSettings()
{
ChipSelectType = SpiChipSelectType.Gpio,
ChipSelectLine = GHIElectronics.TinyCLR.Devices.Gpio.GpioController.GetDefault().OpenPin(socket.Cs),
Mode = SpiMode.Mode0,
ClockFrequency = 2000000
});
// Sets initial brightness
var PWM = PwmController.FromName(socket.PwmController);
PWM.SetDesiredFrequency(5000);
_pwm = PWM.OpenChannel(socket.PwmChannel);
Brightness = initialBrightness;
}
static ZumoBot()
{
led = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D13);
led.SetDriveMode(GpioPinDriveMode.Output);
button = GpioController.GetDefault().OpenPin(FEZ.GpioPin.D12);
button.SetDriveMode(GpioPinDriveMode.InputPullUp);
var pwm = PwmController.FromName(FEZ.PwmChannel.Controller3.Id);
pwm.SetDesiredFrequency(4 * 1000);
Buzzer = pwm.OpenChannel(FEZ.PwmChannel.Controller3.D6); // D3 or D6
Buzzer.Stop();
Buzzer.SetActiveDutyCyclePercentage(0.5);
voltage = AdcController.GetDefault().OpenChannel(FEZ.AdcChannel.A1);
}
/// <summary>Initializes a new instance of the <see cref="DCMotor4Click" /> class.</summary>
/// <param name="socket">The socket on which the DCMotor 4 Click board is plugged</param>
/// <param name="frequency">PWM frequency. Depends on the motor.</param>
public DCMotor4Click(Hardware.Socket socket, Double frequency = 1000.0)
{
_enable = GpioController.GetDefault().OpenPin(socket.Cs);
_enable.SetDriveMode(GpioPinDriveMode.Output);
_enable.Write(GpioPinValue.High);
_direction = GpioController.GetDefault().OpenPin(socket.AnPin);
_direction.SetDriveMode(GpioPinDriveMode.Output);
_direction.Write(GpioPinValue.High);
var controller = PwmController.FromName(socket.PwmController);
_pwmOut = controller.OpenChannel(socket.PwmChannel);
controller.SetDesiredFrequency(frequency);
// Motor not running at startup
Stop();
IsMoving = false;
}
static void TestYahboomPiano()
{
var buzzerController = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.PwmChannel.Controller3.EdgeP0Channel);
var piano = new GHIElectronics.TinyCLR.Yahboom.Piano.YahboomPianoController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
FEZBit.GpioPin.EdgeP1);
piano.Beep();
piano.SetColorLeds(0, 50, 100, 0);
piano.SetColorLeds(1, 50, 0, 100);
while (true)
{
var i = piano.ReadTouch();
Thread.Sleep(50);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Bargraph2Click"/> class.
/// </summary>
/// <param name="socket">The socket on which the BarGraph2 Click board is plugged on MikroBus.Net</param>
/// <param name="initialBrightness">Initial brightness in the range 0.0 (no display) to 1.0 (full brightness)</param>
public Bargraph2Click(Hardware.Socket socket, Double initialBrightness = 1.0)
{
// Initialize SPI
_bargraph = SpiController.FromName(socket.SpiBus).GetDevice(new SpiConnectionSettings()
{
ChipSelectType = SpiChipSelectType.Gpio,
ChipSelectLine = GHIElectronics.TinyCLR.Devices.Gpio.GpioController.GetDefault().OpenPin(socket.Cs),
Mode = SpiMode.Mode3,
ClockFrequency = 2000000
});
// Initialize PWM and set initial brightness
var PWM = PwmController.FromName(socket.PwmController);
PWM.SetDesiredFrequency(5000);
_pwm = PWM.OpenChannel(socket.PwmChannel);
_pwm.SetActiveDutyCyclePercentage(initialBrightness);
_pwm.Start();
}
//private bool started;
public LightBulb()
{
//started = false;
var PWM = PwmController.FromName(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller3.Id : G30.PwmChannel.Controller3.Id);
PWM.SetDesiredFrequency(10000);
this.red = PWM.OpenChannel(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller3.PC9 : G30.PwmChannel.Controller3.PC9);
this.green = PWM.OpenChannel(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller3.PC8 : G30.PwmChannel.Controller3.PC8);
this.blue = PWM.OpenChannel(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller3.PC6 : G30.PwmChannel.Controller3.PC7);
// red = new PWM(Peripherals.LightBulb.Red, 10000, 1, false);
// green = new PWM(Peripherals.LightBulb.Green, 10000, 1, false);
//blue = new PWM(Peripherals.LightBulb.Blue, 10000, 1, false);
this.red.Start();
this.green.Start();
this.blue.Start();
TurnColor(0, 0, 0);
}
static void Main()
{
var gpio = GpioController.GetDefault();
var dirA = gpio.OpenPin(FEZ.GpioPin.D2);
var dirB = gpio.OpenPin(FEZ.GpioPin.D4);
dirA.SetDriveMode(GpioPinDriveMode.Output);
dirB.SetDriveMode(GpioPinDriveMode.Output);
var pwm1 = PwmController.FromName(FEZ.PwmChannel.Controller1.Id);
var pwm3 = PwmController.FromName(FEZ.PwmChannel.Controller3.Id);
pwm1.SetDesiredFrequency(5000);
pwm3.SetDesiredFrequency(5000);
var pwmA = pwm1.OpenChannel(FEZ.PwmChannel.Controller1.D3);
var pwmB = pwm3.OpenChannel(FEZ.PwmChannel.Controller3.D11);
pwmA.Start();
pwmB.Start();
// reverse direction every one second!
// Do not foget the shield needs power. Thsi can come from VIN, meaning plug a power pack into your *duino board.
pwmB.SetActiveDutyCyclePercentage(0.9);
while (true)
{
dirA.Write(GpioPinValue.High);
dirB.Write(GpioPinValue.High);
Thread.Sleep(1000);
// Change speed
pwmA.SetActiveDutyCyclePercentage(0.9);
dirA.Write(GpioPinValue.Low);
dirB.Write(GpioPinValue.Low);
Thread.Sleep(1000);
// Cahnge speed
pwmA.SetActiveDutyCyclePercentage(0.5);
}
}
/// <summary>
/// Constructor of MotorDriverL298
/// </summary>
/// <param name="pinDir1">pin of direction for Motor 1, pin 6 of P Socket</param>
/// <param name="pinDir2">pin of direction for Motor 2, pin 7 of P Socket</param>
/// <param name="pinPwm1">pin of Pwm for Motor 1, pin 8 of P Socket</param>
/// <param name="pinPwm2">pin of Pwm for Motor 2, pin 9 of P Socket</param>
/// <param name="idPwmController1">id of Pwm for Motor 1</param>
/// <param name="idPwmController2">id of Pwm for Motor 2</param>
public MotorDriverL298(int pinDir1, int pinDir2, int pinPwm1, int pinPwm2, string idPwmController1, string idPwmController2)
{
_lastSpeeds = new double[] { 0, 0 };
Frequency = 25000;
_controllers = new[]
{
PwmController.FromName(idPwmController1),
PwmController.FromName(idPwmController2),
};
foreach (var controller in _controllers)
{
controller.SetDesiredFrequency(Frequency);
}
_pwms = new[]
{
_controllers[0].OpenChannel(pinPwm1),
_controllers[1].OpenChannel(pinPwm2),
};
foreach (var pwmPin in _pwms)
{
pwmPin.Start();
}
_directions = new[]
{
GpioController.GetDefault().OpenPin(pinDir1),
GpioController.GetDefault().OpenPin(pinDir2),
};
foreach (var dir in _directions)
{
dir.SetDriveMode(GpioPinDriveMode.Output);
dir.Write(GpioPinValue.Low);
}
StopAll();
}
internal Servo(int servo)
{
switch (Board.BoardType)
{
case BoardType.BP2:
this.controller = PwmController.FromName(BrainPadBP2.PwmChannel.Controller2.Id);
break;
case BoardType.Original:
this.controller = PwmController.FromName(servo == 0 ? G30.PwmChannel.Controller1.Id : G30.PwmChannel.Controller2.Id);
break;
default: throw new InvalidOperationException();
}
this.invertServo = false;
this.ConfigurePulseParameters(1.0, 2.0);
this.ConfigureAsPositional(false);
switch (Board.BoardType)
{
case BoardType.BP2:
this.servo = this.controller.OpenChannel(servo == 0 ? BrainPadBP2.PwmChannel.Controller2.PA3 : BrainPadBP2.PwmChannel.Controller2.PA0);
break;
case BoardType.Original:
this.servo = this.controller.OpenChannel(servo == 0 ? G30.PwmChannel.Controller1.PA8 : G30.PwmChannel.Controller2.PA0);
break;
default: throw new InvalidOperationException();
}
this.EnsureFrequency();
}
static void Main()
{
// Use intellisense to determine what controller PE14 belongs to, controller1 in this example.
var pwmCont = PwmController.FromName(G80.PwmChannel.Controller1.Id);
var led1 = pwmCont.OpenChannel(G80.PwmChannel.Controller1.PE14);
pwmCont.SetDesiredFrequency(1000);
var level = 0.5;
var vLevel = 0.1;
led1.SetActiveDutyCyclePercentage(level);
led1.Start();
while (true)
{
level += vLevel;
if (level < 0.1 || level > 0.9)
{
vLevel *= -1;
}
led1.SetActiveDutyCyclePercentage(level);
Thread.Sleep(20);
}
}
static void TestTinyBit()
{
var buzzerController = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.PwmChannel.Controller3.EdgeP0Channel);
var lineDetectLeft = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP13);
var lineDetectRight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP14);
var voiceSensor = AdcController.FromName(FEZBit.AdcChannel.Controller1.Id).OpenChannel(FEZBit.AdcChannel.Controller1.EdgeP1);
var p2remove = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP1);
var distanceTrigger = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP16);
var distanceEcho = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP15);
p2remove.SetDriveMode(GpioPinDriveMode.Input);
var bot = new TinyBitController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
voiceSensor,
lineDetectLeft, lineDetectRight, distanceTrigger, distanceEcho,
FEZBit.GpioPin.EdgeP12
);
bot.SetHeadlight(30, 100, 100);
bot.SetColorLeds(1, 200, 0, 0);
bot.SetMotorSpeed(0.5, 0.5);
bot.SetMotorSpeed(0.5, -0.5);
bot.SetMotorSpeed(-0.5, 0.5);
bot.SetMotorSpeed(0, 0);
while (true)
{
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
var v = bot.ReadVoiceLevel();
Thread.Sleep(50);
bot.Beep();
}
}
static void Main()
{
// Servos have 3 pins The middle one is always power. Then black or brown side is ground.
// The remaining pin is the signal that needs PWM.
var controller = PwmController.FromName(FEZ.PwmChannel.Controller1.Id);
var channel = controller.OpenChannel(FEZ.PwmChannel.Controller1.D3);
var servo = new Servo(controller, channel);
// This is for continous servos
// Speed is anywhere -100 to 100
servo.ConfigureAsContinuous(false);
var speed = 1;
while (true)
{
servo.Set(speed);
if ((speed += 10) > 100)
{
speed = -100;
}
Thread.Sleep(100);
}
/*
* // This is for positional servos
* // Pos is anywhere 0 to 180
* servo.ConfigureAsPositional(false);
* var pos = 1;
* while (true) {
* servo.Set(pos);
* if ((pos += 10) > 180)
* pos = 1;
* Thread.Sleep(100);
* }*/
}
public Buzzer()
{
this.controller = PwmController.FromName(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller4.Id : G30.PwmChannel.Controller4.Id);
this.buzz = this.controller.OpenChannel(Board.BoardType == BoardType.BP2 ? BrainPadBP2.PwmChannel.Controller4.PB8 : G30.PwmChannel.Controller4.PB8);
}
static void Main()
{
new Thread(Blinker).Start();
// disable wifi
var wifien = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.WiFiEn);
wifien.SetDriveMode(GpioPinDriveMode.Output);
wifien.Write(GpioPinValue.High);
var wifireset = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.WiFiReset);
wifireset.SetDriveMode(GpioPinDriveMode.Output);
wifireset.Write(GpioPinValue.High);
var wifics = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.WiFiCs);
wifics.SetDriveMode(GpioPinDriveMode.Output);
wifics.Write(GpioPinValue.High);
//InitDisplay();
//TestTouchPads();
//TestYahboomPiano();
//TestMaqueen();
TestTinyBit();
//TestCuteBot();
//TestScrollBit();
//InitBot();
while (false)
{
//bot.SetMotorSpeed(0.5, 0.5);
//Thread.Sleep(2000);
//bot.SetMotorSpeed(0.5, -0.5);
//Thread.Sleep(500);
//bot.SetMotorSpeed(0, 0);
//Thread.Sleep(500);
var d = bot.ReadLineSensor(false);
bot.Beep();
}
// Buzzer ///////////////////
var pwmController3 = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzer = pwmController3.OpenChannel(FEZBit.PwmChannel.Controller3.BuzzerChannel);
pwmController3.SetDesiredFrequency(500);
buzzer.SetActiveDutyCyclePercentage(0.5);
buzzer.Start();
for (var f = 500; f < 5_000; f += 300)
{
pwmController3.SetDesiredFrequency(f);
Thread.Sleep(1);
}
buzzer.Stop();
bot.SetMotorSpeed(0.5, -0.9);
screen.DrawString("Press A", font12, new SolidBrush(Color.Teal), 50, 90);
screen.Flush();
// wait for A button //////////////////////
var buttonA = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.ButtonA);
buttonA.SetDriveMode(GpioPinDriveMode.InputPullUp);
while (buttonA.Read() == GpioPinValue.High)
{
Thread.Sleep(10);
}
bot.SetMotorSpeed(0, -0);
screen.Clear();
screen.DrawString("TinyCLR OS", font12, new SolidBrush(Color.Teal), 40, 70);
for (var i = 0; i < 128; i += 8)
{
screen.DrawLine(new Pen(Color.Yellow), i, 0, 0, 128 - i);
bot.Beep();
screen.Flush();
}
for (var i = 0; i < 128; i += 8)
{
screen.DrawLine(new Pen(Color.Purple), 160 - i, 0, 160, 128 - i);
bot.Beep();
screen.Flush();
}
Thread.Sleep(-1);
}
static void TestTinyBit()
{
var buzzerController = PwmController.FromName(FEZBit.Timer.Pwm.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.Timer.Pwm.Controller3.P0);
var lineDetectLeft = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P13);
var lineDetectRight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P14);
var voiceSensor = AdcController.FromName(FEZBit.Adc.Controller1.Id).OpenChannel(FEZBit.Adc.Controller1.P1);
var p2remove = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P1);
var distanceTrigger = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P16);
var distanceEcho = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.P15);
p2remove.SetDriveMode(GpioPinDriveMode.Input);
var bot = new TinyBitController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
voiceSensor,
lineDetectLeft, lineDetectRight, distanceTrigger, distanceEcho,
FEZBit.GpioPin.P12
);
new Thread(() => {
while (true)
{
bot.SetHeadlight(100, 0, 0);
Thread.Sleep(200);
bot.SetHeadlight(0, 0, 100);
Thread.Sleep(300);
}
}).Start();
/*new Thread(() => {
* while (true) {
* bot.Beep();
* Thread.Sleep(2_000);
* }
* }).Start();
*/
while (true)
{
bot.SetMotorSpeed(0.5, 0.5);
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
var v = bot.ReadVoiceLevel();
var d = bot.ReadDistance();
if (d < 20)
{
bot.SetMotorSpeed(-0.5, -0.5);
Thread.Sleep(200);
bot.SetMotorSpeed(-0.5, 0.5);
Thread.Sleep(200);
bot.SetMotorSpeed(0, 0);
Thread.Sleep(1000);
bot.Beep();
Thread.Sleep(100);
bot.Beep();
Thread.Sleep(100);
bot.Beep();
Thread.Sleep(100);
}
Thread.Sleep(10);
}
bot.SetHeadlight(30, 100, 100);
bot.SetColorLeds(1, 200, 0, 0);
bot.SetMotorSpeed(0.5, 0.5);
bot.SetMotorSpeed(0.5, -0.5);
bot.SetMotorSpeed(-0.5, 0.5);
bot.SetMotorSpeed(0, 0);
while (true)
{
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
var v = bot.ReadVoiceLevel();
Thread.Sleep(50);
bot.Beep();
}
}
void Initialize()
{
Debug.WriteLine("Initialize hardware...");
var controller = PwmController.FromName(SC20260.Timer.Pwm.Controller3.Id);
var led1 = controller.OpenChannel(SC20260.Timer.Pwm.Controller3.PB0);
var led2 = controller.OpenChannel(SC20260.Timer.Pwm.Controller3.PB1);
var led3 = controller.OpenChannel(SC20260.Timer.Pwm.Controller3.PC6);
onboardLed = new RgbPwmLed(led1, led2, led3,
3.3f, 3.3f, 3.3f,
CommonType.CommonAnode);
//onboardLed = new RgbPwmLed(device: Device,
// redPwmPin: Device.Pins.OnboardLedRed,
// greenPwmPin: Device.Pins.OnboardLedGreen,
// bluePwmPin: Device.Pins.OnboardLedBlue,
// 3.3f, 3.3f, 3.3f,
// Meadow.Peripherals.Leds.IRgbLed.CommonType.CommonAnode);
Debug.WriteLine("Create Display with SPI...");
var cs = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PE4);
var settings = new SpiConnectionSettings()
{
ChipSelectType = SpiChipSelectType.Gpio,
ChipSelectLine = cs,
Mode = SpiMode.Mode1,
ClockFrequency = 4_000_000,
};
var controllerSpi = SpiController.FromName(SC20100.SpiBus.Spi4);
var deviceSpi = controllerSpi.GetDevice(settings);
ssd1309 = new Ssd1309
(
SC20260.SpiBus.Spi2,
SC20260.GpioPin.PE4,
SC20260.GpioPin.PC2,
SC20260.GpioPin.PC3
);
Debug.WriteLine("Create GraphicsLibrary...");
graphics = new GraphicsLibrary(ssd1309)
{
CurrentFont = new Font8x12(),
};
graphics.Clear();
graphics.DrawText(0, 0, "Loading Menu");
graphics.Show();
CreateMenu(graphics);
Debug.WriteLine("Create buttons...");
up = new PushButton(SC20260.GpioPin.PC6, GpioPinDriveMode.InputPullDown);
up.Clicked += Up_Clicked;
left = new PushButton(SC20260.GpioPin.PC7, GpioPinDriveMode.InputPullDown);
left.Clicked += Left_Clicked;
right = new PushButton(SC20260.GpioPin.PC8, GpioPinDriveMode.InputPullDown);
right.Clicked += Right_Clicked;
down = new PushButton(SC20260.GpioPin.PC9, GpioPinDriveMode.InputPullDown);
down.Clicked += Down_Clicked;
menu.Enable();
}
static void TestTpBot()
{
var buzzerController = PwmController.FromName(FEZBit.PwmChannel.Controller3.Id);
var buzzerChannel = buzzerController.OpenChannel(FEZBit.PwmChannel.Controller3.EdgeP0Channel);
var lineDetectLeft = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP13);
var lineDetectRight = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP14);
var voiceSensor = AdcController.FromName(FEZBit.Adc.Controller1.Id).OpenChannel(FEZBit.Adc.Controller1.EdgeP1);
var p2remove = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP1);
var distanceTrigger = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP16);
var distanceEcho = GpioController.GetDefault().OpenPin(FEZBit.GpioPin.EdgeP15);
p2remove.SetDriveMode(GpioPinDriveMode.Input);
var bot = new TpBotController(
I2cController.FromName(FEZBit.I2cBus.Edge),
buzzerChannel,
lineDetectLeft, lineDetectRight);//, distanceTrigger, distanceEcho);
new Thread(() => {
while (true)
{
bot.SetHeadlight(100, 0, 0);
Thread.Sleep(200);
bot.SetHeadlight(0, 0, 100);
Thread.Sleep(300);
}
}).Start();
/*new Thread(() => {
* while (true) {
* bot.Beep();
* Thread.Sleep(2_000);
* }
* }).Start();
*/
while (true)
{
bot.SetMotorSpeed(0.9, 0.9);
var l = bot.ReadLineSensor(true);
var r = bot.ReadLineSensor(false);
//var v = bot.ReadVoiceLevel();
/*var d = bot.ReadDistance();
* if (d < 20) {
* bot.SetMotorSpeed(-0.9, -0.9);
* Thread.Sleep(200);
* bot.SetMotorSpeed(-0.9, 0.9);
* Thread.Sleep(200);
* bot.SetMotorSpeed(0, 0);
* Thread.Sleep(1000);
*
*
* bot.Beep();
* Thread.Sleep(100);
* bot.Beep();
* Thread.Sleep(100);
* bot.Beep();
* Thread.Sleep(100);
* }*/
Thread.Sleep(10);
}
}