Mappages de broches Raspberry Pi 2 &3
Les interfaces matérielles pour Raspberry Pi 2 et Raspberry Pi 3 sont exposées via l’en-tête J8 de 40 broches sur la carte. Les fonctionnalités incluent :
- 24x - Broches GPIO
- 1x - UARTs série (RPi3 inclut uniquement mini UART)
- 2x - Bus SPI
- 1x - Bus I2C
- 2x - Broches d’alimentation 5V
- 2x - Broches d’alimentation 3,3V
- 8x - Broches au sol
Broches GPIO
Examinons le GPIO disponible sur cet appareil.
Vue d’ensemble du code pin GPIO
Les broches GPIO suivantes sont accessibles via des API :
GPIO# Extraction de l’alimentation Autres fonctions Épingle d’en-tête 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 Déroulant SPI0 MISO 21 10 Déroulant SPI0 MOSI 19 11 Déroulant SPI0 SCLK 23 12 Déroulant 32 13 Déroulant 33 16 Déroulant SPI1 CS0 36 17 Déroulant 11 18 Déroulant 12 19 Déroulant SPI1 MISO 35 20 Déroulant SPI1 MOSI 38 21 Déroulant SPI1 SCLK 40 22 Déroulant 15 23 Déroulant 16 24 Déroulant 18 25 Déroulant 22 26 Déroulant 37 27 Déroulant 13 35* Pullup LED d’alimentation rouge 47* Pullup LED d’activité verte
* = Raspberry Pi 2 UNIQUEMENT. GPIO 35 &47 ne sont pas disponibles sur Raspberry Pi 3.
Exemple GPIO
Par exemple, le code suivant ouvre GPIO 5 en tant que sortie et écrit un « 1 » numérique sur la broche :
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
}
Lorsque vous ouvrez une broche, elle sera dans son état d’alimentation, ce qui peut inclure une résistance d’extraction. Pour déconnecter les résistances de tirage et obtenir une entrée à impedance élevée, définissez le mode lecteur sur GpioPinDriveMode.Input :
pin.SetDriveMode(GpioPinDriveMode.Input);
Lorsqu’une broche est fermée, elle revient à son état d’alimentation.
Broche Muxing
Certaines broches GPIO peuvent effectuer plusieurs fonctions. Par défaut, les broches sont configurées en tant qu’entrées GPIO. Lorsque vous ouvrez une autre fonction en appelant ou en appelant I2cDevice.FromIdAsync() ou SpiDevice.FromIdAsync() , les broches requises par la fonction sont automatiquement basculées (« muxed ») vers la fonction correcte. Lorsque l’appareil est fermé en appelant I2cDevice.Dispose() ou SpiDevice.Dispose(), les broches reviennent à leur fonction par défaut. Si vous essayez d’utiliser une broche pour deux fonctions différentes à la fois, une exception est levée lorsque vous essayez d’ouvrir la fonction en conflit. Par exemple,
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
UART série
Il existe un UART série disponible sur le RPi2/3 : UART0
- Épingler 8 - UART0 TX
- Épingle 10 - UART0 RX
L’exemple ci-dessous initialise UART0 et effectue une écriture suivie d’une lecture :
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);
}
Notez que vous devez ajouter la fonctionnalité suivante au fichier Package.appxmanifest dans votre projet UWP pour exécuter le code UART série :
Visual Studio 2017 a un bogue connu dans le Concepteur de manifeste (l’éditeur visuel pour les fichiers appxmanifest) qui affecte la fonctionnalité de communication en série. Si votre appxmanifest ajoute la fonctionnalité de communication en série, la modification de votre appxmanifest avec le concepteur endommage votre appxmanifest (l’enfant xml de l’appareil est perdu). Vous pouvez contourner ce problème en modifiant manuellement l’appxmanifest en cliquant avec le bouton droit sur votre appxmanifest et en sélectionnant Afficher le code dans le menu contextuel.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
Bus I2C
Examinons le bus I2C disponible sur cet appareil.
Vue d’ensemble d’I2C
Il existe un contrôleur I2C1 exposé sur l’en-tête de broche avec deux lignes SDA et SCL. 1,8KΩ résistance interne pull-up sont déjà installés sur la carte pour ce bus.
Nom du signal Numéro de broche d’en-tête Numéro Gpio SDA 3 2 SCL 5 3
L’exemple ci-dessous initialise I2C1 et écrit des données sur un appareil I2C avec l’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);
}
}
Bus SPI
Il existe deux contrôleurs de bus SPI disponibles sur le RPi2/3.
SPI0
Nom du signal Numéro de broche d’en-tête Numéro Gpio MOSI 19 10 MISO 21 9 SCLK 23 11 CS0 24 8 CS1 26 7
SPI1
Nom du signal Numéro de broche d’en-tête Numéro Gpio MOSI 38 20 MISO 35 19 SCLK 40 21 CS0 36 16
Exemple SPI
Un exemple d’exécution d’une écriture SPI sur bus SPI0 à l’aide de la puce select 0 est illustré ci-dessous :
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);
}
}