Mappages de broches maximales MinnowBoard
Notes
Pour comparer ce mappage d’épingles à des versions plus récentes de Minnowboard, consultez la documentation ici.
Vue d’ensemble
Les interfaces matérielles pour MinnowBoard Max sont exposées via l’en-tête à 26 broches JP1 sur la carte. Les fonctionnalités incluent :
- 10x - Broches GPIO
- 2x - UART série
- 1x - bus SPI
- 1x - Bus I2C
- Broche d’alimentation 1x - 5V
- Broche d’alimentation 1x - 3,3 V
- 2x - Broches au sol
MinnowBoard Max utilise des niveaux logiques de 3,3 V sur toutes les broches d’E/S. En outre, toutes les broches sont mises en mémoire tampon par des shifters de niveau TXS0104E , à l’exception des broches d’alimentation et de mise au sol. Ces shifters de niveau apparaissent sous forme de sorties de collecteur ouvertes avec un pull-up résistif de 10KΩ, et le pull-up est présent, que l’E/S soit définie sur entrée ou sortie.
La nature open-collector des shifters de niveau signifie que les broches peuvent générer un « 0 » fortement, mais seulement faiblement générer un « 1 ». Il est important de garder à l’esprit lors de l’attachement d’appareils qui tirent le courant des broches (par exemple, une LED). Consultez l’exemple Blinky pour connaître la façon correcte d’interface d’une LED avec MinnowBoard Max.
Broches GPIO
Les broches GPIO suivantes sont accessibles via les API :
GPIO # En-tête pin 0 21 1 23 2 25 3 14 4 16 5 18 6 20 7 22 8 24 9 26
Remarque :GPIO 4 et GPIO 5 sont utilisés par MinnowBoard Max comme broches de configuration de démarrage pour le BIOS. Assurez-vous que les appareils attachés ne pilotent pas ces GPIO bas pendant le démarrage, car cela pourrait empêcher le mbM de démarrer. Une fois que le mbM a démarré au-delà du BIOS, ces GPIO peuvent être utilisés normalement.
Exemple GPIO
Par exemple, le code suivant ouvre GPIO 5 en tant que sortie et écrit un « 1 » numérique sur l’épingle :
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 série
Deux UARTS série sont disponibles sur le mbM : UART1 et UART2
UART1 a les lignes STANDARD UART1 TX et UART1 RX , ainsi que les signaux de contrôle de flux UART1 CTS et UART1 RTS.
- Broche 6 - UART1 TX
- Broche 8 - UART1 RX
- Broche 10 - UART1 CTS
- Broche 12 - UART1 RTS
UART1 ne fonctionne pas à partir de la build 10240. Utilisez UART2 ou un convertisseur USB-Serial.
UART2 inclut uniquement les lignes UART2 TX et UART2 RX .
- Broche 17 - UART2 TX
- Broche 19 - UART2 RX
UART2 ne prend pas en charge le contrôle de flux. Par conséquent, l’accès aux propriétés suivantes de SerialDevice peut entraîner la levée d’une exception :
- BreakSignalState
- IsDataTerminalReadyEnabled
- IsRequestToSendEnabled
- Négociation : seul SerialHandshake.None est pris en charge
L’exemple ci-dessous initialise UART2 et effectue une écriture suivie d’une lecture :
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);
}
Notez que vous devez ajouter la fonctionnalité suivante au fichier Package.appxmanifest dans votre projet UWP pour exécuter le code UART série :
Visual Studio 2017 présente un bogue connu dans le Concepteur de manifeste (l’éditeur visuel pour les fichiers appxmanifest) qui affecte la capacité de communication en série. Si votre appxmanifest ajoute la fonctionnalité de communication en série, la modification de votre appxmanifest avec le concepteur endommagera votre appxmanifest (l’enfant xml de l’appareil sera perdu). Vous pouvez contourner ce problème en modifiant manuellement l’appxmanifest en cliquant avec le bouton droit sur votre appxmanifest et en sélectionnant Afficher le code dans le menu contextuel.
<Capabilities>
<DeviceCapability Name="serialcommunication">
<Device Id="any">
<Function Type="name:serialPort" />
</Device>
</DeviceCapability>
</Capabilities>
Bus I2C
Examinons le bus I2C disponible sur cet appareil.
Vue d’ensemble de L’I2C
Il existe un contrôleur I2C I2C5 exposé sur l’en-tête d’épingle avec deux lignes SDA et SCL. Des résistances de traction interne de 10KΩ sont déjà présentes sur ces lignes.
- Broche 15 - I2C5 SDA
- Broche 13 - I2C5 SCL
Exemple I2C
L’exemple ci-dessous initialise I2C5 et écrit des données sur un appareil I2C avec adresse 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);
}
}
Problèmes I2C
MinnowBoard Max rencontre un problème connu avec le bus I2C, qui provoque des problèmes de communication avec certains appareils I2C. Normalement, un appareil I2C accuse réception de son adresse lors d’une demande de bus. Toutefois, dans certaines conditions, cet accusé de réception ne parvient pas à se propager par le biais des shifters de niveau au mbM, et par conséquent, le processeur pense que l’appareil n’a pas répondu et annule la transaction de bus. Le problème semble être lié aux shifters de niveau TXS0104E sur les broches d’E/S, qui peuvent se déclencher prématurément en raison de pics de tension sur la ligne. La solution de contournement actuelle consiste à insérer une résistance de 100-millisecondes en série avec la ligne SCK I2C, ce qui permet de supprimer les pics. Tous les appareils ne sont pas affectés. Cette solution de contournement n’est donc requise que si vous rencontrez des difficultés pour obtenir une réponse de bus. Un appareil connu pour exiger cette solution de contournement est le HTU21D.
Bus SPI
Examinons le bus SPI disponible sur cet appareil.
Vue d’ensemble de SPI
Un contrôleur SPI0 est disponible sur le mbM :
- Broche 9 - SPI0 MOSI
- Broche 7 - SPI0 MISO
- Broche 11 - SPI0 SCLK
- Broche 5 - SPI0 CS0
Exemple SPI
Voici un exemple sur la façon d’effectuer une écriture SPI sur le 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);
}
}