Mapeamentos de Raspberry Pi 2 & 3 Pinos
As interfaces de hardware para o Raspberry Pi 2 e o Raspberry Pi 3 são expostas através do cabeçalho J8 de 40 pinos na placa. A funcionalidade inclui:
- 24x - Pinos GPIO
- 1x - UARTs seriais (RPi3 inclui apenas mini UART)
- 2x - Barramento SPI
- 1x - Barramento I2C
- 2x - pinos de alimentação de 5V
- 2x - 3.3V pinos de alimentação
- 8x - Pinos moídos
Pinos GPIO
Vejamos o GPIO disponível neste dispositivo.
Visão geral do GPIO Pin
Os seguintes pinos GPIO são acessíveis por meio de APIs:
GPIO# Puxar Power-on Funções alternativas Pino do cabeçalho 2 Puxar I2C1 SDA 3 3 Puxar I2C1 SCL 5 4 Puxar 7 5 Puxar 29 6 Puxar 31 7 Puxar SPI0 CS1 26 8 Puxar 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* Puxar LED de energia vermelho 47* Puxar LED de atividade verde
* = Raspberry Pi 2 APENAS. GPIO 35 & 47 não estão disponíveis no Raspberry Pi 3.
Exemplo de GPIO
Como exemplo, o código a seguir abre o GPIO 5 como uma saída e grava um '1' digital no pino:
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 você abre um pino, ele estará em seu estado de liga, que pode incluir um resistor de tração. Para desconectar os resistores de tração e obter uma entrada de alta impedância, defina o modo de unidade como GpioPinDriveMode.Input:
pin.SetDriveMode(GpioPinDriveMode.Input);
Quando um pino é fechado, ele volta ao seu estado de ativação.
Pin Muxing
Alguns pinos GPIO podem executar várias funções. Por padrão, os pinos são configurados como entradas GPIO. Quando você abre uma função alternativa chamando I2cDevice.FromIdAsync() ou SpiDevice.FromIdAsync() , os pinos exigidos pela função são automaticamente alternados ("muxed") para a função correta. Quando o dispositivo é fechado chamando I2cDevice.Dispose() ou SpiDevice.Dispose(), os pinos voltam para sua função padrão. Se você tentar usar um pino para duas funções diferentes ao mesmo tempo, uma exceção será lançada quando você tentar abrir a função conflitante. Por exemplo,
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
Há um Serial UART disponível no RPi2/3: UART0
- Pino 8 - UART0 TX
- Pino 10 - UART0 RX
O exemplo abaixo inicializa UART0 e executa uma gravação seguida de uma leitura:
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);
}
Observe que você deve adicionar o seguinte recurso ao arquivo Package.appxmanifest em seu projeto UWP para executar o código UART serial:
O Visual Studio 2017 tem um bug conhecido no Designer de Manifesto (o editor visual para arquivos appxmanifest) que afeta o recurso de comunicação serial. Se o appxmanifest adicionar o recurso de comunicação serial, modificar o appxmanifest com o designer corromperá o appxmanifest (o filho xml do dispositivo será perdido). Você pode contornar esse problema editando manualmente o appxmanifest clicando com o botão direito do mouse no appxmanifest e selecionando Exibir código no menu de contexto.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
Barramento I2C
Vejamos o barramento I2C disponível neste dispositivo.
Visão geral do I2C
Há um controlador I2C I2C1 exposto no cabeçalho do pino com duas linhas SDA e SCL. Resistores pull-up internos de 1,8KΩ já estão instalados na placa para este barramento.
Nome do sinal Número do pino do cabeçalho Número Gpio SDA 3 2 SCL 5 3
O exemplo abaixo inicializa I2C1 e grava dados em um dispositivo I2C com endereço 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);
}
}
Barramento SPI
Há dois controladores de barramento SPI disponíveis no RPi2/3.
SPI0
Nome do sinal Número do pino do cabeçalho Número Gpio MOSI 19 10 MISSÔ 21 9 SCLK 23 11 CS0 24 8 CS1 26 7
SPI1
Nome do sinal Número do pino do cabeçalho Número Gpio MOSI 38 20 MISSÔ 35 19 SCLK 40 21 CS0 36 16
Exemplo de SPI
Um exemplo de como executar uma gravação SPI no barramento SPI0 usando chip select 0 é mostrado abaixo:
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);
}
}