public void Initialize(int PinIn1, int PinIn2, int PinPWM)
{
if (gpioController == null)
{
return;
}
if (pwmController == null)
{
return;
}
gpioPinIn1 = gpioController.OpenPin(PinIn1);
gpioPinIn1.SetDriveMode(GpioPinDriveMode.Output);
gpioPinIn1.Write(GpioPinValue.Low);
gpioPinIn2 = gpioController.OpenPin(PinIn2);
gpioPinIn2.SetDriveMode(GpioPinDriveMode.Output);
gpioPinIn2.Write(GpioPinValue.Low);
// Open pin 5 for pulse width modulation
servoGpioPinEn = pwmController.OpenPin(PinPWM);
}
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);
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
GpioController gpc = GpioController.GetDefault();
GpioPin ledOccupe = gpc?.OpenPin(24);
_appareilPhoto = new AppareilPhoto(ledOccupe);
if (await _appareilPhoto.Initialiser(1280, 960, "MJPG"))
{
PrendrePhotoBTN.Visibility = Visibility.Visible;
if (gpc != null)
{
_poussoirDecl = gpc.OpenPin(18);
_poussoirDecl.SetDriveMode(GpioPinDriveMode.InputPullUp);
_poussoirDecl.DebounceTimeout = new TimeSpan(0, 0, 0, 0, 5);
_poussoirDecl.ValueChanged += _poussoirDecl_ValueChanged;
_ledEnMarche = gpc.OpenPin(23);
_ledEnMarche.SetDriveMode(GpioPinDriveMode.Output);
_ledEnMarche.Write(GpioPinValue.High);
}
}
}
private static void OnPinValueChanged2(object sender, PinValueChangedEventArgs e)
{
s_currentLedValue = s_currentLedValue == PinValue.High ? PinValue.Low : PinValue.High;
Console.WriteLine($"Button pressed! Led value {s_currentLedValue}");
if (sender is GpioDriver)
{
GpioDriver driver = sender as GpioDriver;
driver.Output(s_ledPinNumber, s_currentLedValue);
}
else if (sender is GpioPin)
{
GpioPin button = sender as GpioPin;
GpioController controller = button.Controller;
GpioPin led = controller[s_ledPinNumber];
led.Write(s_currentLedValue);
}
else
{
throw new ArgumentException(nameof(sender));
}
}
public DisplayTftSpiBase(string SpiControllerName, int chipSelectPin, int dcPin, int resetPin,
uint width, uint height)
{
this.width = width;
this.height = height;
var gpio = GpioController.GetDefault();
chipSelectPort = gpio.OpenPin(chipSelectPin);
chipSelectPort.SetDriveMode(GpioPinDriveMode.Output);
chipSelectPort.Write(GpioPinValue.Low);
var settings = new SpiConnectionSettings()
{
ChipSelectType = SpiChipSelectType.Gpio,
ChipSelectLine = chipSelectPort,
Mode = SpiMode.Mode1,
ClockFrequency = 4_000_000,
};
var controller = SpiController.FromName(SpiControllerName);
spi = controller.GetDevice(settings);
spiBuffer = new byte[this.width * this.height * sizeof(ushort)];
spiReceive = new byte[this.width * this.height * sizeof(ushort)];
dataCommandPort = gpio.OpenPin(dcPin);
dataCommandPort.SetDriveMode(GpioPinDriveMode.Output);
dataCommandPort.Write(GpioPinValue.Low);
resetPort = gpio.OpenPin(resetPin);
resetPort.SetDriveMode(GpioPinDriveMode.Output);
resetPort.Write(GpioPinValue.High);
chipSelectPort = gpio.OpenPin(chipSelectPin);
chipSelectPort.SetDriveMode(GpioPinDriveMode.Output);
chipSelectPort.Write(GpioPinValue.Low);
}
private void ButtonPressed(GpioPin sender, GpioPinValueChangedEventArgs args)
{
if (args.Edge != GpioPinEdge.FallingEdge)
{
return;
}
_isDead = !_isDead;
if (_isDead)
{
LightBulb(TrafficLightState.Broken);
_signalRConnection.Stop();
_signalRHub.Dispose();
NotifyState(TrafficLightState.Broken).Wait();
}
else
{
NotifyState(TrafficLightState.Green).Wait();
StartSignalR().Wait();
}
}
public Ssr(ComponentId id, IBeerFactoryEventHandler eventHandler, ILoggerFactory loggerFactory)
{
Logger = loggerFactory.CreateLogger <Ssr>();
_eventHandler = eventHandler;
CurrentState = new SsrState {
Id = id
};
Enum.TryParse(id.ToString(), out SsrPin ssrPin);
_pinNumber = (int)ssrPin;
var gpio = GpioController.GetDefault();
if (gpio != null)
{
_pin = gpio.OpenPin(_pinNumber);
_pin.SetDriveMode(GpioPinDriveMode.Output);
_pin.Write(GpioPinValue.Low);
}
_eventHandler.SubscribeToComponentStateRequest <SsrRequestState>(SsrStateRequestOccured);
}
private void OnFrontIRChange(GpioPin sender, GpioPinValueChangedEventArgs args)
{
switch (args.Edge)
{
case GpioPinEdge.FallingEdge: //low value
FrontTotalCountInt--;
FrontDownCountInt++;
break;
case GpioPinEdge.RisingEdge: //high value
FrontTotalCountInt++;
FrontUpCountInt++;
break;
}
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
FrontEdge.Text = args.Edge.ToString();
FrontDownCount.Text = "Down: " + FrontDownCountInt.ToString();
FrontUpCount.Text = "Up: " + FrontUpCountInt.ToString();
FrontTotalCount.Text = "Total: " + FrontTotalCountInt.ToString();
});
}
private void TriggerPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
switch (args.Edge)
{
case GpioPinEdge.FallingEdge: //low value
SideTotalCount--;
SideDownCountInt++;
break;
case GpioPinEdge.RisingEdge: //high value
SideTotalCount++;
SideUpCountInt++;
break;
}
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
SideEdge.Text = args.Edge.ToString();
SideDownCount.Text = "Down: " + SideDownCountInt.ToString();
SideUpCout.Text = "Up: " + SideUpCountInt.ToString();
SideTotalCout.Text = "Total: " + SideTotalCount.ToString();
});
}
private void grip_step_pin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
{
try
{
if (grip_step_pin.Read() == GpioPinValue.High)
{
if (grip_close_pin.Read() == GpioPinValue.High)
{
grip_act++;
}
else if (grip_open_pin.Read() == GpioPinValue.Low)
{
grip_act--;
}
}
}
catch
{
StopAll();
throw;
}
}
public static void Main()
{
Debug.WriteLine("Welcome to WiFI Soft AP world!");
GpioPin setupButton = GpioController.GetDefault().OpenPin(SETUP_PIN);
setupButton.SetDriveMode(GpioPinDriveMode.InputPullUp);
// If Wireless station is not enabled then start Soft AP to allow Wireless configuration
// or Button pressed
if (!Wireless80211.IsEnabled() || (setupButton.Read() == GpioPinValue.Low))
{
Wireless80211.Disable();
if (WirelessAP.Setup() == false)
{
// Reboot device to Activate Access Point on restart
Debug.WriteLine($"Setup Soft AP, Rebooting device");
Power.RebootDevice();
}
Debug.WriteLine($"Running Soft AP, waiting for client to connect");
Debug.WriteLine($"Soft AP IP address :{WirelessAP.GetIP()}");
// Link up Network event to show Stations connecting/disconnecting to Access point.
NetworkChange.NetworkAPStationChanged += NetworkChange_NetworkAPStationChanged;;
}
else
{
Debug.WriteLine($"Running in normal mode, connecting to Access point");
string IpAdr = Wireless80211.WaitIP();
Debug.WriteLine($"Connected as {IpAdr}");
}
// Just wait for now
// Here you would have the reset of your program using the client WiFI link
Thread.Sleep(Timeout.Infinite);
}
public RegisterManager RegisterManager = null; // Future refactor this will be made private
public Rfm9XDevice(byte chipSelectPin, byte resetPin, byte interruptPin)
{
RegisterManager = new RegisterManager(chipSelectPin);
// Setup the reset and interrupt pins
GpioController gpioController = GpioController.GetDefault();
// Reset pin configuration then strobe briefly to factory reset
GpioPin resetGpioPin = gpioController.OpenPin(resetPin);
resetGpioPin.SetDriveMode(GpioPinDriveMode.Output);
resetGpioPin.Write(GpioPinValue.Low);
Task.Delay(10);
resetGpioPin.Write(GpioPinValue.High);
Task.Delay(10);
// Interrupt pin for RX message, TX done etc. notifications
InterruptGpioPin = gpioController.OpenPin(interruptPin);
InterruptGpioPin.SetDriveMode(GpioPinDriveMode.Input);
InterruptGpioPin.ValueChanged += InterruptGpioPin_ValueChanged;
}
public RGBLed(int redPinNumber, int greenPinNumber, int bluePinNumber)
{
var gpio = GpioController.GetDefault();
_redPin = gpio.OpenPin(redPinNumber);
_redPin.SetDriveMode(GpioPinDriveMode.Output);
_greenPin = gpio.OpenPin(greenPinNumber);
_greenPin.SetDriveMode(GpioPinDriveMode.Output);
_bluePin = gpio.OpenPin(bluePinNumber);
_bluePin.SetDriveMode(GpioPinDriveMode.Output);
_redPinValue = GpioPinValue.Low;
_redPin.Write(_redPinValue);
_greenPinValue = GpioPinValue.Low;
_greenPin.Write(_greenPinValue);
_bluePinValue = GpioPinValue.Low;
_bluePin.Write(_bluePinValue);
}
private void OnInterrupt(GpioPin sender, GpioPinValueChangedEventArgs e)
{
if (e.Edge != GpioPinEdge.RisingEdge)
{
return;
}
var ports = this.ReadRegisters(Register.InterruptPort0, 8);
for (byte i = 0; i < 8; i++)
{
for (byte j = 0; j < 8; j++)
{
var pin = new Pin(i, j);
if (this.interruptRegistrations.ContainsKey(pin) && (ports[i] & (1 << j)) != 0)
{
this.interruptRegistrations[pin](this.ReadDigital(pin));
}
}
}
}
private async Task InitGPIO()
{
// Get the GPIO controller
try
{
gpioController = await GpioController.GetDefaultAsync();
}
catch (Exception ex)
{
throw new Exception("GPIO Initialization failed.", ex);
}
// Setup the GPIO pins for the display
pinReset = CreateWritePin(RESET_PIN);
pinPanel = CreateWritePin(PANEL_PIN);
pinDischarge = CreateWritePin(DISCHARGE_PIN);
pinBorder = CreateWritePin(BORDER_PIN);
// Setup the Busy pin as a read
pinBusy = gpioController.OpenPin(BUSY_PIN, GpioSharingMode.Exclusive);
pinBusy.SetDriveMode(GpioPinDriveMode.Input);
}
private async void buttonPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs e)
{
if (e.Edge == GpioPinEdge.FallingEdge)
{
// need to invoke UI updates on the UI thread because this event
// handler gets invoked on a separate thread.
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// toggle the state of the LED every time the button is pressed
BeltConnected = true;
});
try
{
SetSeatBeltStatusAsync(SeatBeltId, true);
}
catch (Exception)
{
// nothing to do
}
}
if (e.Edge == GpioPinEdge.RisingEdge)
{
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
BeltConnected = false;
});
try
{
SetSeatBeltStatusAsync(SeatBeltId, false);
}
catch (Exception)
{
// nothing to do
}
}
}
private void InitGPIO()
{
var gpio = GpioController.GetDefault();
// Show an error if there is no GPIO controller
if (gpio == null)
{
greenPin = null;
redPin = null;
return;
}
redPin = gpio.OpenPin(RED_LED_PIN);
redPinValue = GpioPinValue.High;
redPin.Write(redPinValue);
redPin.SetDriveMode(GpioPinDriveMode.Output);
greenPin = gpio.OpenPin(GREEN_LED_PIN);
greenPinValue = GpioPinValue.High;
greenPin.Write(greenPinValue);
greenPin.SetDriveMode(GpioPinDriveMode.Output);
}
private void DoorSensor_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
var client = new PiServer.ServiceSoapClient();
if (sender.Read() == GpioPinValue.High)
{
client.UpdateStatusAsync("GarageDoor", "Open");
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
el_GarageDoor.Fill = grayBrush;
});
}
else
{
client.UpdateStatusAsync("GarageDoor", "Closed");
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
el_GarageDoor.Fill = redBrush;
});
}
}
void StopScenario()
{
// Stop the timer.
if (timer != null)
{
timer.Stop();
timer = null;
}
// Release the GPIO pins.
if (setPin != null)
{
setPin.Dispose();
setPin = null;
}
if (listenPin != null)
{
listenPin.ValueChanged -= Pin_ValueChanged;
listenPin.Dispose();
listenPin = null;
}
}
public PancakeDrive()
{
// Initialize GPIO Controller
var gpio = GpioController.GetDefault();
// Set X motor pins
stepperXPulse = GpioController.GetDefault().OpenPin(23);
stepperXPulse.SetDriveMode(GpioPinDriveMode.Output);
stepperXPulse.Write(GpioPinValue.Low);
stepperXDir = gpio.OpenPin(24);
stepperXDir.SetDriveMode(GpioPinDriveMode.Output);
stepperXDir.Write(GpioPinValue.Low);
stepperXEn = GpioController.GetDefault().OpenPin(18);
stepperXEn.SetDriveMode(GpioPinDriveMode.Output);
stepperXEn.Write(GpioPinValue.Low);
// Set Y motor pins
stepperYPulse = GpioController.GetDefault().OpenPin(12);
stepperYPulse.SetDriveMode(GpioPinDriveMode.Output);
stepperYPulse.Write(GpioPinValue.Low);
stepperYDir = gpio.OpenPin(16);
stepperYDir.SetDriveMode(GpioPinDriveMode.Output);
stepperYDir.Write(GpioPinValue.Low);
stepperYEn = GpioController.GetDefault().OpenPin(1);
stepperYEn.SetDriveMode(GpioPinDriveMode.Output);
stepperYEn.Write(GpioPinValue.Low);
// Set stepper motor pin
servoPulse = GpioController.GetDefault().OpenPin(27);
servoPulse.SetDriveMode(GpioPinDriveMode.Output);
servoPulse.Write(GpioPinValue.Low);
// Initialize X-Y pulse timer
tmrPulse = new Timer(new TimerCallback(PulseTimerTick), null, 1000, 10);
}
public MainPage()
{
InitializeComponent();
var gpio = GpioController.GetDefault();
pin0 = gpio.OpenPin(LED_RED);
pin1 = gpio.OpenPin(LED_GREEN);
pin2 = gpio.OpenPin(LED_YELLOW);
pin3 = gpio.OpenPin(LED_BLUE);
pin4 = gpio.OpenPin(LED_WHITE);
pin0.SetDriveMode(GpioPinDriveMode.Output);
pin1.SetDriveMode(GpioPinDriveMode.Output);
pin2.SetDriveMode(GpioPinDriveMode.Output);
pin3.SetDriveMode(GpioPinDriveMode.Output);
pin4.SetDriveMode(GpioPinDriveMode.Output);
pinValue = GpioPinValue.Low;
pinValue1 = GpioPinValue.High;
while (true)
{
pin0.Write(pinValue);
Task.Delay(100).Wait();
pin0.Write(pinValue1);
pin1.Write(pinValue);
Task.Delay(100).Wait();
pin1.Write(pinValue1);
pin2.Write(pinValue);
Task.Delay(100).Wait();
pin2.Write(pinValue1);
pin3.Write(pinValue);
Task.Delay(100).Wait();
pin3.Write(pinValue1);
pin4.Write(pinValue);
Task.Delay(100).Wait();
pin4.Write(pinValue1);
}
}
/// <summary>
/// initialize GPIO
/// </summary>
/// <returns></returns>
private async Task <bool> InitGpio()
{
GpioController IoController = await GpioController.GetDefaultAsync();
if (IoController == null)
{
Debug.WriteLine("GPIO does not exist on the current system");
return(false);
}
_pinDataCmd = IoController.OpenPin(SPI_DATA_COMMAND_PIN);
_pinDataCmd.Write(GpioPinValue.High);
_pinDataCmd.SetDriveMode(GpioPinDriveMode.Output);
/* Initialize a pin as output for the hardware Reset line on the display */
_pinReset = IoController.OpenPin(SPI_RESET_PIN);
_pinReset.Write(GpioPinValue.High);
_pinReset.SetDriveMode(GpioPinDriveMode.Output);
Debug.WriteLine("GPIO initialized");
return(true);
}
//Method to initialize the TCS34725 sensor
public async Task Initialize()
{
Debug.WriteLine("TCS34725::Initialize");
try
{
//Instantiate the I2CConnectionSettings using the device address of the TCS34725
I2cConnectionSettings settings = new I2cConnectionSettings(TCS34725_Address);
//Set the I2C bus speed of connection to fast mode
settings.BusSpeed = I2cBusSpeed.FastMode;
//Use the I2CBus device selector to create an advanced query syntax string
string aqs = I2cDevice.GetDeviceSelector(I2CControllerName);
//Use the Windows.Devices.Enumeration.DeviceInformation class to create a
//collection using the advanced query syntax string
DeviceInformationCollection dis = await DeviceInformation.FindAllAsync(aqs);
//Instantiate the the TCS34725 I2C device using the device id of the I2CBus
//and the I2CConnectionSettings
colorSensor = await I2cDevice.FromIdAsync(dis[0].Id, settings);
//Create a default GPIO controller
gpio = GpioController.GetDefault();
//Open the LED control pin using the GPIO controller
LedControlGPIOPin = gpio.OpenPin(LedControlPin);
//Set the pin to output
LedControlGPIOPin.SetDriveMode(GpioPinDriveMode.Output);
//Initialize the known color list
initColorList();
}
catch (Exception e)
{
Debug.WriteLine("Exception: " + e.Message + "\n" + e.StackTrace);
throw;
}
}
SparkfunArdumoto(int PinD2, int PinD4, int PinD3, int PinD11, string PWM1Id, string PWM3Id)
{
var GPIO = GpioController.GetDefault();
MotorA.SetDriveMode(GpioPinDriveMode.Output);
MotorB.SetDriveMode(GpioPinDriveMode.Output);
MotorA = GPIO.OpenPin(PinD2);
MotorB = GPIO.OpenPin(PinD4);
var PWM1 = PwmController.FromId(PWM1Id);
var PWM3 = PwmController.FromId(PWM3Id);
SpeedA = PWM1.OpenPin(PinD3);
SpeedB = PWM3.OpenPin(PinD11);
PWM1.SetDesiredFrequency(5000);
PWM3.SetDesiredFrequency(5000);
SpeedA.Start();
SpeedB.Start();
ChangeSpeed(0.0, 0.0);
ChangeDirection(MoveDirection.Forward);
}
static void Main(string[] args)
{
foreach (GpioPin pin in Pi.Gpio.OrderBy(x => x.BcmPinNumber))
{
Console.WriteLine(pin.Name);
Console.WriteLine(pin.BcmPinNumber);
Console.WriteLine(pin.PinMode);
Console.WriteLine(pin.ReadValue());
}
GpioPin gpioPin = Pi.Gpio.GetGpioPinByBcmPinNumber(2);
gpioPin.PinMode = GpioPinDriveMode.Output;
while (true)
{
gpioPin.Write(GpioPinValue.Low);
Thread.Sleep(500);
gpioPin.Write(GpioPinValue.High);
Thread.Sleep(500);
}
}
private GpioPin InitializeInputGPIO(GpioPin gpioPin, int PinID)
{
gpioPin = gpioController.OpenPin(PinID);
if (gpioPin == null)
{
return(null);
}
gpioPin.DebounceTimeout = TimeSpan.FromMilliseconds(25);
if (gpioPin.IsDriveModeSupported(GpioPinDriveMode.InputPullUp))
{
// Take advantage of built in pull-up resistors of Raspberry Pi 2 and DragonBoard 410c
//利用树莓派内置的上拉电阻
gpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
}
else
{
gpioPin.SetDriveMode(GpioPinDriveMode.Input);
}
return(gpioPin);
}
private async void MainPage_Loaded(object sender, RoutedEventArgs e)
{
// initialize the ping pong controller and choose GPIO 23 and GPIO 24
// as the switches for the players
gpio = await GpioController.GetDefaultAsync();
btn1 = gpio.OpenPin(22);
btn2 = gpio.OpenPin(18);
// add event handlers so we can listen for button presses
btn1.ValueChanged += Btn1_ValueChanged;
btn2.ValueChanged += Btn2_ValueChanged;
// setup the pins for the leds
ledPins = new int[] { 2, 3, 4, 17, 27, 23 }.Select(a => gpio.OpenPin(a)).ToArray();
// add ellipses to the gui and save them so we can show them on screen
ellipses = ledPins.Select(a =>
{
var ellipse = new Ellipse()
{
Margin = new Thickness(10),
Width = 20,
Height = 20,
Fill = new SolidColorBrush(Colors.Red)
};
ledPanel.Children.Add(ellipse);
return(ellipse);
}).ToArray();
// set the led pins as outputs
foreach (var p in ledPins)
{
p.SetDriveMode(GpioPinDriveMode.Output);
p.Write(GpioPinValue.Low);
}
// start the ping pong loop
PingPongLoop();
}
public Rfm9XDevice(int busId, int chipSelectPin, int resetPin)
{
var settings = new SpiConnectionSettings(busId, chipSelectPin)
{
ClockFrequency = 500000,
//DataBitLength = 8,
Mode = SpiMode.Mode0,// From SemTech docs pg 80 CPOL=0, CPHA=0
SharingMode = SpiSharingMode.Shared,
};
rfm9XLoraModem = new SpiDevice(settings);
// Factory reset pin configuration
GpioController gpioController = new GpioController();
GpioPin resetGpioPin = gpioController.OpenPin(resetPin);
resetGpioPin.SetPinMode(PinMode.Output);
resetGpioPin.Write(PinValue.Low);
Thread.Sleep(10);
resetGpioPin.Write(PinValue.High);
Thread.Sleep(10);
}
public void InitGPIO()
{
var gpio = GpioController.GetDefault();
stepPin = gpio.OpenPin(STEP_PIN);
stepPin.SetDriveMode(GpioPinDriveMode.Output);
stepPinValue = GpioPinValue.Low;
stepPin.Write(stepPinValue);
directionPin = gpio.OpenPin(DIR_PIN);
directionPin.SetDriveMode(GpioPinDriveMode.Output);
directionPinValue = GpioPinValue.Low;
directionPin.Write(directionPinValue);
if (ENABLE_PIN != 0)
{
enablePin = gpio.OpenPin(ENABLE_PIN);
enablePin.SetDriveMode(GpioPinDriveMode.Output);
enablePinValue = GpioPinValue.High;
enablePin.Write(enablePinValue);
}
}
private void InitGPIO()
{
// init LEDs
ledPins = new List <GpioPin>()
{
GpioController.GetDefault().OpenPin(PIN_RED),
GpioController.GetDefault().OpenPin(PIN_BLUE),
GpioController.GetDefault().OpenPin(PIN_GREEN)
};
foreach (var pin in ledPins)
{
// designate pins for Output
pin.SetDriveMode(GpioPinDriveMode.Output);
// Turn LED off, initially
pin.Write(GpioPinValue.Low);
}
// init Photo cell
photoPin = GpioController.GetDefault().OpenPin(PIN_PHOTO);
}
