Asignaciones de patillas máximas de MinnowBoard
Nota
Para comparar esta asignación de patillas con las versiones más recientes de Minnowboard, visite la documentación aquí.
Información general
Las interfaces de hardware para MinnowBoard Max se exponen a través del encabezado JP1 de 26 patillas en la placa. Entre las funcionalidades se incluyen:
- 10x : patillas GPIO
- 2x - UART serie
- 1x : bus SPI
- 1x - Bus I2C
- 1x : pin de alimentación de 5V
- 1x - clavija de alimentación de 3,3V
- 2x - Patillas de suelo
MinnowBoard Max usa niveles de lógica de 3.3V en todas las patillas de E/S. Además, todos los pines están almacenados en búfer por los cambiadores de nivel TXS0104E , a excepción de los pines de alimentación y tierra. Estos desplazamientos de nivel aparecen como salidas de recopilador abiertos con una extracción resistiva de 10KΩ y la extracción está presente independientemente de si la E/S está establecida en entrada o salida.
La naturaleza del recopilador abierto de los desplazamientos de nivel significa que las patillas pueden generar un '0' fuertemente, pero solo genera débilmente un '1'. Esto es importante tener en cuenta al conectar dispositivos que extraen la corriente de los pines (por ejemplo, un LED). Consulte el Ejemplo de Blinky para obtener la manera correcta de interactuar con un LED al MinnowBoard Max.
Patillas GPIO
Las siguientes patillas GPIO son accesibles a través de las API:
GPIO # Pin de encabezado 0 21 1 23 2 25 3 14 4 16 5 18 6 20 7 22 8 24 9 26
Nota: MinnowBoard Max usa GPIO 4 y GPIO 5 como patillas de configuración de arranque para el BIOS. Asegúrese de que los dispositivos conectados no controlan estos GPIO bajo durante el arranque, ya que esto podría impedir que MBM arranque. Después de que MBM haya arrancado más allá del BIOS, estos GPIO se pueden usar normalmente.
Ejemplo de GPIO
Por ejemplo, el código siguiente abre GPIO 5 como salida y escribe un "1" digital en la patilla:
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' */
}
UART serie
Hay dos UARTS serie disponibles en MBM: UART1 y UART2
UART1 tiene las líneas UART1 TX y UART1 RX estándar, junto con señales de control de flujo UART1 CTS y UART1 RTS.
- Patilla 6 - UART1 TX
- Pin 8 - UART1 RX
- Patilla 10 - UART1 CTS
- Pin 12 - UART1 RTS
UART1 no funciona a partir de la compilación 10240. Use UART2 o un convertidor de USB-Serial.
UART2 incluye solo las líneas UART2 TX y UART2 RX .
- Patilla 17 - UART2 TX
- Pin 19 - UART2 RX
UART2 no admite el control de flujo, por lo que el acceso a las siguientes propiedades de SerialDevice puede producir una excepción:
- BreakSignalState
- IsDataTerminalReadyEnabled
- IsRequestToSendEnabled
- Protocolo de enlace: solo se admite SerialHandshake.None
En el ejemplo siguiente se inicializa UART2 y se realiza una escritura seguida de una lectura:
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);
}
Ten en cuenta que debes agregar la siguiente funcionalidad al archivo Package.appxmanifest en tu proyecto de UWP para ejecutar código UART serie:
Visual Studio 2017 tiene un error conocido en el Diseñador de manifiestos (el editor visual para archivos appxmanifest) que afecta a la funcionalidad serialcommunication. Si appxmanifest agrega la funcionalidad serialcommunication, al modificar appxmanifest con el diseñador se dañará el appxmanifest (se perderá el elemento secundario Device xml). Para solucionar este problema, edite manualmente appxmanifest haciendo clic con el botón derecho en appxmanifest y seleccionando Ver código en el menú contextual.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
Bus I2C
Echemos un vistazo al bus I2C disponible en este dispositivo.
Información general de I2C
Hay un controlador I2C I2C5 expuesto en el encabezado de patilla con dos líneas SDA y SCL. 10KΩ resistencias internas de extracción ya están presentes en estas líneas.
- Patilla 15 - I2C5 SDA
- Pin 13 - I2C5 SCL
Ejemplo de I2C
En el ejemplo siguiente se inicializa I2C5 y se escriben datos en un dispositivo I2C con dirección 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
MinnowBoard Max tiene un problema conocido con el bus I2C, lo que provoca problemas de comunicación con determinados dispositivos I2C. Normalmente, un dispositivo I2C confirmará su dirección durante una solicitud de autobús. Sin embargo, en determinadas condiciones, este reconocimiento no se propaga a través de los desplazamientos de nivel al MBM y, como resultado, la CPU cree que el dispositivo no respondió y cancela la transacción de bus. El problema parece estar relacionado con los cambios de nivel TXS0104E en las patillas de E/S, lo que puede desencadenar prematuramente debido a picos de tensión en la línea. La solución alternativa actual es insertar una resistencia de 100 ohm en la serie con la línea I2C SCK, que ayuda a suprimir picos. No todos los dispositivos se ven afectados, por lo que esta solución alternativa solo es necesaria si tiene problemas para obtener una respuesta de bus. Un dispositivo que se sabe que requiere esta solución alternativa es el HTU21D.
Bus SPI
Echemos un vistazo al bus SPI disponible en este dispositivo.
Información general sobre SPI
Hay un SPI controller SPI0 disponible en MBM:
- Pin 9 - SPI0 MOSI
- Patilla 7 - SPI0 MISO
- Patilla 11 - SPI0 SCLK
- Patilla 5 - SPI0 CS0
Ejemplo spi
A continuación se muestra un ejemplo sobre cómo realizar una escritura SPI en el bus SPI0 :
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);
}
}