Mapping dei pin Raspberry Pi 2 e 3
Le interfacce hardware per Raspberry Pi 2 e Raspberry Pi 3 vengono esposte tramite l'intestazione A 40 pin J8 sulla scheda. Le funzionalità includono:
- 24x - Pin GPIO
- 1x - UARTs seriali (RPi3 include solo mini UART)
- 2x - Bus SPI
- 1x - Bus I2C
- 2x - Pin di alimentazione 5V
- 2x - Pin di alimentazione 3.3V
- 8x - Pin terra
Pin GPIO
Esaminiamo il GPIO disponibile in questo dispositivo.
Panoramica del pin GPIO
I pin GPIO seguenti sono accessibili tramite le API:
GPIO# Power-on Pull Funzioni alternative Pin intestazione 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 LED di alimentazione rossa 47* PullUp LED attività verde
* = SOLO Raspberry Pi 2. GPIO 35 & 47 non sono disponibili in Raspberry Pi 3.
Esempio GPIO
Ad esempio, il codice seguente apre GPIO 5 come output e scrive un '1' digitale sul pin:
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
}
Quando si apre un pin, si trova nello stato di accensione, che può includere un resistore di pull. Per disconnettere i resistori pull e ottenere un input ad alta impedenza, impostare la modalità di unità su GpioPinDriveMode.Input:
pin.SetDriveMode(GpioPinDriveMode.Input);
Quando un pin viene chiuso, viene ripristinato lo stato di accensione.
Multiplexing dei pin
Alcuni pin GPIO possono eseguire più funzioni. Per impostazione predefinita, i pin sono configurati come input GPIO. Quando si apre una funzione alternativa chiamando I2cDevice.FromIdAsync() o SpiDevice.FromIdAsync() , i pin richiesti dalla funzione vengono automaticamente spostati ("muxed") alla funzione corretta. Quando il dispositivo viene chiuso chiamando I2cDevice.Dispose() o SpiDevice.Dispose(), i pin tornano alla funzione predefinita. Se si tenta di usare un pin per due funzioni diverse contemporaneamente, viene generata un'eccezione quando si tenta di aprire la funzione in conflitto. ad esempio:
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 seriale
C'è un UART seriale disponibile in RPi2/3: UART0
- Pin 8 - UART0 TX
- Pin 10 - UART0 RX
L'esempio seguente inizializza UART0 ed esegue una scrittura seguita da una lettura:
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);
}
Tieni presente che devi aggiungere la funzionalità seguente al file Package.appxmanifest nel progetto UWP per eseguire il codice UART seriale:
Visual Studio 2017 presenta un bug noto in Progettazione manifesto (l'editor visivo per i file appxmanifest) che influisce sulla funzionalità serialcommunication. Se appxmanifest aggiunge la funzionalità serialcommunication, la modifica dell'appxmanifest con la finestra di progettazione danneggia l'appxmanifest (l'elemento figlio xml del dispositivo andrà perso). È possibile risolvere questo problema modificando a mano l'appxmanifest facendo clic con il pulsante destro del mouse sull'appxmanifest e scegliendo Visualizza codice dal menu di scelta rapida.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
Bus I2C
Esaminiamo il bus I2C disponibile in questo dispositivo.
Panoramica di I2C
Esiste un controller I2C I2C1 esposto nell'intestazione del pin con due righe SDA e SCL. 1.8K KPI resistori interni pull-up sono già installati sulla scheda per questo autobus.
Nome segnale Numero pin intestazione Numero Gpio SDA 3 2 SCL 5 3
L'esempio seguente inizializza I2C1 e scrive i dati in un dispositivo I2C con indirizzo 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
Nella RPi2/3 sono disponibili due controller del bus SPI.
SPI0
Nome segnale Numero pin intestazione Numero Gpio MOSI 19 10 MISO 21 9 SCLK 23 11 CS0 24 8 CS1 26 7
SPI1
Nome segnale Numero pin intestazione Numero Gpio MOSI 38 20 MISO 35 19 SCLK 40 21 CS0 36 16
Esempio SPI
Di seguito è riportato un esempio di come eseguire una scrittura SPI sul bus SPI0 usando chip select 0:
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);
}
}