Raspberry Pi 2 & 3 Pin-Zuordnungen
Hardwareschnittstellen für die Raspberry Pi 2 und Raspberry Pi 3 werden über den 40-Pin-Header J8 auf der Tafel verfügbar gemacht. Zu den Funktionen gehören:
- 24x - GPIO-Pins
- 1x - Serielle UARTs (RPi3 enthält nur Mini-UART)
- 2x - SPI Bus
- 1x - I2C Bus
- 2x - 5V Power Pins
- 2x - 3.3V Power Pins
- 8x - Gemahlene Pins
GPIO-Pins
Sehen wir uns die GPIO an, die auf diesem Gerät verfügbar ist.
GPIO-Pin –Übersicht
Auf die folgenden GPIO-Pins kann über APIs zugegriffen werden:
GPIO # Power-On-Pull Alternative Funktionen Kopfzeilenheft 2 PullUp I2C1 SDA 3 3 PullUp I2C1 SCL 5 4 PullUp 7 5 PullUp 29 6 PullUp 31 7 PullUp SPI0 CS1 26 8 PullUp SPI0 CS0 24 9 PullDown SPI0 MISO 21 10 PullDown SPI0 MOSI 19 11 PullDown SPI0 SCLK 23 12 PullDown 32 13 PullDown 33 16 PullDown SPI1 CS0 36 17 PullDown 11 18 PullDown 12 19 PullDown SPI1 MISO 35 20 PullDown SPI1 MOSI 38 21 PullDown SPI1 SCLK 40 22 PullDown 15 23 PullDown 16 24 PullDown 18 25 PullDown 22 26 PullDown 37 27 PullDown 13 35* PullUp Rote Netz-LED 47* PullUp Grüne Aktivitäts-LED
* = Raspberry Pi 2 ONLY. GPIO 35 & 47 ist auf Raspberry Pi 3 nicht verfügbar.
GPIO-Beispiel
Als Beispiel öffnet der folgende Code GPIO 5 als Ausgabe und schreibt ein digitales "1" auf dem Pin aus:
using Windows.Devices.Gpio;
public void GPIO()
{
// Get the default GPIO controller on the system
GpioController gpio = GpioController.GetDefault();
if (gpio == null)
return; // GPIO not available on this system
// Open GPIO 5
using (GpioPin pin = gpio.OpenPin(5))
{
// Latch HIGH value first. This ensures a default value when the pin is set as output
pin.Write(GpioPinValue.High);
// Set the IO direction as output
pin.SetDriveMode(GpioPinDriveMode.Output);
} // Close pin - will revert to its power-on state
}
Wenn Sie einen Pin öffnen, befindet es sich in seinem Power-On-Zustand, der einen Pull-Widerstand enthalten kann. Um die Pull-Widerstände zu trennen und eine Eingabe mit hoher Impedanz zu erhalten, legen Sie den Laufwerksmodus auf GpioPinDriveMode.Input fest:
pin.SetDriveMode(GpioPinDriveMode.Input);
Wenn eine Pin geschlossen wird, wird sie auf den Status "Power-On" zurückgesetzt.
Pin-Muxing
Einige GPIO-Pins können mehrere Funktionen ausführen. Standardmäßig werden Pins als GPIO-Eingaben konfiguriert. Wenn Sie eine alternative Funktion durch Aufrufen oder SpiDevice.FromIdAsync() Öffnen I2cDevice.FromIdAsync() einer anderen Funktion öffnen, werden die von der Funktion erforderlichen Pins automatisch in die richtige Funktion umgeschaltet ("muxed"). Wenn das Gerät durch Aufrufen oder SpiDevice.Dispose()Schließen I2cDevice.Dispose() des Geräts geschlossen wird, werden die Pins wieder auf ihre Standardfunktion zurückgesetzt. Wenn Sie versuchen, eine Pin für zwei verschiedene Funktionen gleichzeitig zu verwenden, wird eine Ausnahme ausgelöst, wenn Sie versuchen, die konfliktierende Funktion zu öffnen. Beispiel:
var controller = GpioController.GetDefault();
var gpio2 = controller.OpenPin(2); // open GPIO2, shared with I2C1 SDA
var dis = await DeviceInformation.FindAllAsync(I2cDevice.GetDeviceSelector());
var i2cDevice = await I2cDevice.FromIdAsync(dis[0].Id, new I2cConnectionSettings(0x55)); // exception thrown because GPIO2 is open
gpio2.Dispose(); // close GPIO2
var i2cDevice = await I2cDevice.FromIdAsync(dis[0].Id, new I2cConnectionSettings(0x55)); // succeeds because gpio2 is now available
var gpio2 = controller.OpenPin(2); // throws exception because GPIO2 is in use as SDA1
i2cDevice.Dispose(); // release I2C device
var gpio2 = controller.OpenPin(2); // succeeds now that GPIO2 is available
Serial UART
Es gibt eine serielle UART auf der RPi2/3: UART0
- Pin 8 - UART0 TX
- Pin 10 - UART0 RX
Das folgende Beispiel initialisiert UART0 und führt einen Schreibzugriff gefolgt von einem Lesevorgang aus:
using Windows.Storage.Streams;
using Windows.Devices.Enumeration;
using Windows.Devices.SerialCommunication;
public async void Serial()
{
string aqs = SerialDevice.GetDeviceSelector("UART0"); /* Find the selector string for the serial device */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the serial device with our selector string */
SerialDevice SerialPort = await SerialDevice.FromIdAsync(dis[0].Id); /* Create an serial device with our selected device */
/* Configure serial settings */
SerialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
SerialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
SerialPort.BaudRate = 9600; /* mini UART: only standard baud rates */
SerialPort.Parity = SerialParity.None; /* mini UART: no parities */
SerialPort.StopBits = SerialStopBitCount.One; /* mini UART: 1 stop bit */
SerialPort.DataBits = 8;
/* Write a string out over serial */
string txBuffer = "Hello Serial";
DataWriter dataWriter = new DataWriter();
dataWriter.WriteString(txBuffer);
uint bytesWritten = await SerialPort.OutputStream.WriteAsync(dataWriter.DetachBuffer());
/* Read data in from the serial port */
const uint maxReadLength = 1024;
DataReader dataReader = new DataReader(SerialPort.InputStream);
uint bytesToRead = await dataReader.LoadAsync(maxReadLength);
string rxBuffer = dataReader.ReadString(bytesToRead);
}
Beachten Sie, dass Sie der Datei "Package.appxmanifest " in Ihrem UWP-Projekt die folgende Funktion hinzufügen müssen, um seriellen UART-Code auszuführen:
Visual Studio 2017 hat einen bekannten Fehler im Manifest-Designer (der visuelle Editor für Appxmanifest-Dateien), der sich auf die serialkommunikationsfunktion auswirkt. Wenn Ihre Appxmanifest die serialkommunikationsfunktion hinzufügt, beschädigt das Ändern Ihrer Appxmanifest mit dem Designer Ihre Appxmanifest (das Untergeordnete Gerät xml wird verloren). Sie können dieses Problem umgehen, indem Sie das Appxmanifest hand bearbeiten, indem Sie mit der rechten Maustaste auf Ihr appxmanifest klicken und im Kontextmenü "Code anzeigen" auswählen.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
I2C-Bus
Sehen wir uns den I2C-Bus an, der auf diesem Gerät verfügbar ist.
I2C-Übersicht
Es gibt einen I2C-Controller I2C1 , der auf der Pinkopfzeile mit zwei Zeilen SDA und SCL verfügbar gemacht wird. 1.8KΩ interne Pull-Up-Widerstander sind bereits auf dem Board für diesen Bus installiert.
Signalname Kopfzeilenheftnummer Gpio-Nummer SDA 3 2 SCL 5 3
Das folgende Beispiel initialisiert I2C1 und schreibt Daten in ein I2C-Gerät mit der Adresse 0x40:
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;
public async void I2C()
{
// 0x40 is the I2C device address
var settings = new I2cConnectionSettings(0x40);
// FastMode = 400KHz
settings.BusSpeed = I2cBusSpeed.FastMode;
// Create an I2cDevice with the specified I2C settings
var controller = await I2cController.GetDefaultAsync();
using (I2cDevice device = controller.GetDevice(settings))
{
byte[] writeBuf = { 0x01, 0x02, 0x03, 0x04 };
device.Write(writeBuf);
}
}
SPI-Bus
Es gibt zwei SPI-Buscontroller auf der RPi2/3.
SPI0
Signalname Kopfzeilenheftnummer Gpio-Nummer MOSI 19 10 MISO 21 9 SCLK 23 11 CS0 24 8 CS1 26 7
SPI1
Signalname Kopfzeilenheftnummer Gpio-Nummer MOSI 38 20 MISO 35 19 SCLK 40 21 CS0 36 16
SPI-Beispiel
Ein Beispiel für die Ausführung eines SPI-Schreibvorgangs auf Bus SPI0 mithilfe der Chipauswahl 0 finden Sie unten:
using Windows.Devices.Enumeration;
using Windows.Devices.Spi;
public async void SPI()
{
// Use chip select line CS0
var settings = new SpiConnectionSettings(0);
// Set clock to 10MHz
settings.ClockFrequency = 10000000;
// Get a selector string that will return our wanted SPI controller
string aqs = SpiDevice.GetDeviceSelector("SPI0");
// Find the SPI bus controller devices with our selector string
var dis = await DeviceInformation.FindAllAsync(aqs);
// Create an SpiDevice with our selected bus controller and Spi settings
using (SpiDevice device = await SpiDevice.FromIdAsync(dis[0].Id, settings))
{
byte[] writeBuf = { 0x01, 0x02, 0x03, 0x04 };
device.Write(writeBuf);
}
}