Mapeamentos máximos de pinos do MinnowBoard
Observação
Para comparar esse mapeamento de pinos com 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 por meio do cabeçalho jp1 de 26 pinos na placa. A funcionalidade inclui:
- 10x – Pinos gpio
- 2x – UARTs serial
- 1x – Barramento SPI
- 1x – Barramento I2C
- 1x – pino de energia de 5V
- 1x – pino de energia de 3,3V
- 2x - Pinos de terra
O MinnowBoard Max usa níveis de lógica de 3,3V em todos os pinos de E/S. Além disso, todos os pinos são armazenados em buffer por shifters de nível TXS0104E , com exceção de pinos de energia e de terra. Esses shifters 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 a E/S estar definida como entrada ou saída.
A natureza do coletor aberto dos shifters de nível significa que os pinos podem gerar um '0' fortemente, mas apenas geram fracamente um '1'. Isso é importante ter em mente ao anexar dispositivos que extraem atuais dos pinos (como um LED). Consulte o Exemplo blinky para obter a maneira correta de interface de um LED para o MinnowBoard Max.
Pinos gpio
Os seguintes pinos gpio são acessíveis 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 inicialização para o BIOS. Certifique-se de que os dispositivos anexados não conduzam esses GPIO baixos durante a inicialização, pois isso poderia impedir que o MBM inicializasse. 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
Há dois UARTS serial disponíveis no MBM: UART1 e UART2
UART1 tem as linhas UART1 TX e UART1 RX padrão, juntamente com os sinais de controle de fluxo UART1 CTS e UART1 RTS.
- Fixar 6 – UART1 TX
- Fixar 8 – UART1 RX
- Fixar 10 – UART1 CTS
- Fixar 12 – UART1 RTS
O UART1 não está funcionando a partir do build 10240. Use UART2 ou um conversor de USB-Serial.
O UART2 inclui apenas as linhas UART2 TX e UART2 RX .
- Fixar 17 – UART2 TX
- Fixar 19 – UART2 RX
O UART2 não dá suporte ao controle de fluxo, portanto, acessar as seguintes propriedades de SerialDevice pode resultar na geração de uma exceção:
- BreakSignalState
- IsDataTerminalReadyEnabled
- IsRequestToSendEnabled
- Handshake – há suporte apenas para SerialHandshake.None
O exemplo a seguir inicializa UART2 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("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 de serialcommunication. Se o appxmanifest adicionar a funcionalidade serialcommunication, a modificação do appxmanifest com o designer corromperá seu appxmanifest (o dispositivo filho xml será perdido). Você pode contornar esse problema editando manualmente o appxmanifest clicando com o botão direito do mouse em seu 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
Vamos examinar 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. 10KΩ resistores de pull-up internos já estão presentes nessas linhas.
- Fixar 15 – SDA I2C5
- Fixar 13 – I2C5 SCL
Exemplo de I2C
O exemplo a seguir inicializa i2C5 e grava dados em um dispositivo I2C com 0x40 de endereço:
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, em determinadas condições, essa confirmação falha ao propagar de volta pelos shifters de nível para o MBM e, como resultado, a CPU acha que o dispositivo não respondeu e cancelou a transação de barramento. O problema parece estar relacionado aos shifters de nível TXS0104E nos pinos de E/S, que podem ser disparados prematuramente devido a picos de tensão na linha. A solução alternativa atual é inserir um resistor de 100 ohm na série com a linha SCK I2C, 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 ônibus. Um dispositivo conhecido por exigir essa solução alternativa é o HTU21D.
Barramento SPI
Vamos examinar o barramento SPI disponível neste dispositivo.
Visão geral do SPI
Há um SPI0 do controlador SPI disponível no MBM:
- Fixar 9 – SPI0 MOSI
- Fixar 7 – SPI0 MISO
- Fixar 11 – SPI0 SCLK
- Fixar 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);
}
}