Mapeamentos máximos de pinos MinnowBoard
Observação
Para comparar esse mapeamento de pinos com as versões mais recentes do Minnowboard, visite a documentação aqui.
Visão geral
As interfaces de hardware para o MinnowBoard Max são expostas através do cabeçalho JP1 de 26 pinos na placa. A funcionalidade inclui:
- 10x - Pinos GPIO
- 2x - UARTs seriais
- 1x - Barramento SPI
- 1x - barramento I2C
- 1x - pino de alimentação de 5V
- 1x - pino de alimentação de 3,3 V
- 2x - Pinos de aterramento
O MinnowBoard Max usa níveis lógicos de 3.3 V em todos os pinos de E/S. Além disso, todos os pinos são armazenados em buffer por deslocadores de nível TXS0104E , com exceção dos pinos de alimentação e terra. Esses deslocadores de nível aparecem como saídas de coletor aberto com um pull-up resistivo de 10KΩ, e o pull-up está presente independentemente de o IO estar definido para entrada ou saída.
A natureza de coletor aberto dos deslocadores de nível significa que os pinos podem produzir um '0' fortemente, mas apenas fracamente produzir um '1'. É importante ter isso em mente ao conectar dispositivos que extraem corrente dos pinos (como um LED). Consulte o Blinky Sample para obter a maneira correta de fazer a interface de um LED com o MinnowBoard Max.
Pinos GPIO
Os seguintes pinos GPIO podem ser acessados por meio de APIs:
GPIO# Pino de cabeçalho 0 21 1 23 2 25 3 14 4 16 5 18 6 20 7 22 8 24 9 26
Observação: GPIO 4 e GPIO 5 são usados pelo MinnowBoard Max como pinos de configuração de bootstrap para o BIOS. Certifique-se de que os dispositivos conectados não deixem esses GPIO baixos durante a inicialização, pois isso pode impedir a inicialização do MBM. Depois que o MBM for inicializado após o BIOS, esses GPIO poderão ser usados normalmente.
Exemplo de GPIO
Por 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()
{
GpioController Controller = GpioController.GetDefault(); /* Get the default GPIO controller on the system */
GpioPin Pin = Controller.OpenPin(5); /* Open GPIO 5 */
Pin.SetDriveMode(GpioPinDriveMode.Output); /* Set the IO direction as output */
Pin.Write(GpioPinValue.High); /* Output a digital '1' */
}
Serial UART
Existem dois UARTS seriais disponíveis no MBM: UART1 e UART2
O UART1 possui as linhas padrão UART1 TX e UART1 RX , juntamente com os sinais de controle de fluxo UART1 CTS e UART1 RTS.
- Pino 6 - UART1 TX
- Pino 8 - UART1 RX
- Pino 10 - UART1 CTS
- Pino 12 - UART1 RTS
O UART1 não está funcionando a partir da compilação 10240. Por favor, use UART2 ou um conversor USB-Serial.
O UART2 inclui apenas as linhas UART2 TX e UART2 RX .
- Pino 17 - UART2 TX
- Pino 19 - UART2 RX
O UART2 não dá suporte ao controle de fluxo, portanto, acessar as seguintes propriedades de SerialDevice pode resultar em uma exceção sendo lançada:
- Estado de Sinal de Interrupção
- IsDataTerminalReadyEnabled
- IsRequestToSendEnabled
- Handshake - apenas SerialHandshake.None é suportado
O exemplo abaixo inicializa o UART2 e executa uma gravação seguida por uma leitura:
using Windows.Storage.Streams;
using Windows.Devices.Enumeration;
using Windows.Devices.SerialCommunication;
public async void Serial()
{
string aqs = SerialDevice.GetDeviceSelector("UART2"); /* 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;
SerialPort.Parity = SerialParity.None;
SerialPort.StopBits = SerialStopBitCount.One;
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 a funcionalidade serialcommunication. Se o appxmanifest adicionar o recurso serialcommunication, 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 I2C5 exposto no cabeçalho do pino com duas linhas : SDA e SCL. Resistores pull-up internos de 10KΩ já estão presentes nessas linhas.
- Pino 15 - I2C5 SDA
- Pino 13 - I2C5 SCL
Exemplo de I2C
O exemplo abaixo inicializa o I2C5 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);
}
}
Problemas de I2C
O MinnowBoard Max tem um problema conhecido com o barramento I2C, que causa problemas de comunicação com determinados dispositivos I2C. Normalmente, um dispositivo I2C reconhecerá seu endereço durante uma solicitação de barramento. No entanto, sob certas condições, esse reconhecimento não se propaga de volta pelos deslocadores de nível para o MBM e, como resultado, a CPU pensa que o dispositivo não respondeu e cancela a transação de barramento. O problema parece estar relacionado aos deslocadores de nível de TXS0104E nos pinos IO, que podem ser acionados prematuramente devido a picos de tensão na linha. A solução atual é inserir um resistor de 100 ohms em série com a linha I2C SCK, que ajuda a suprimir picos. Nem todos os dispositivos são afetados, portanto, essa solução alternativa só será necessária se você estiver tendo problemas para obter uma resposta de barramento. Um dispositivo conhecido por exigir essa solução alternativa é o HTU21D.
Barramento SPI
Vejamos o barramento SPI disponível neste dispositivo.
Visão geral do SPI
Há um controlador SPI SPI0 disponível no MBM:
- Pino 9 - SPI0 MOSI
- Pino 7 - SPI0 MISO
- Pino 11 - SPI0 SCLK
- Pino 5 - SPI0 CS0
Exemplo de SPI
Um exemplo de como executar uma gravação SPI no barramento SPI0 é 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;
// Create an SpiDevice with the specified Spi settings
var controller = await SpiController.GetDefaultAsync();
using (SpiDevice device = controller.GetDevice(settings))
{
byte[] writeBuf = { 0x01, 0x02, 0x03, 0x04 };
device.Write(writeBuf);
}
}