Mise en œuvre d’un microcontrôleur

Serial Peripheral Interface (source Wikipédia)

Dans le cas de la convention de nommage SDI/SDO, le SDO du maître doit être relié au SDI de l'esclave et vice versa. Pour éviter les confusions au moment du câblage, il est donc souvent recommandé d'utiliser les dénominations MISO-MOSI qui évitent une certaine ambiguïté ; pour exemple, une librairie graphique[1] écrite par Adafruit, prend en charge plusieurs références de contrôleurs d'écrans qui, malgré leurs actions similaires, ne possède pas toujours les mêmes noms de broches. Afin d'éviter ce "problème" les développeurs ont renommé les broches MISO/MOSI par RD et WR signifiant respectivement ReaD (lire) et WRite (écrire) ; en conclusion, on se demande si la broche Lire permet au Microcontrôleur de Lire le Module LCD ou alors si elle permet au Module de Lire et donc au Microcontrôleur de lui Écrire une donnée ?

Fonctionnement

Une transmission SPI typique est une communication simultanée entre un maître et un esclave :

• Le maître génère l'horloge et sélectionne l'esclave avec qui il veut communiquer par l'utilisation du signal SS
• L'esclave répond aux requêtes du maître

À chaque coup d'horloge le maître et l'esclave s'échangent un bit. Après huit coups d'horloges le maître a transmis un octet à l'esclave et vice versa. La vitesse de l'horloge est réglée selon des caractéristiques propres aux périphériques.

Sous Flowcode, pour utiliser le Bus SPI, à l'aide d'un microcontrôleur, il faut ajouter au "Panneau tableau de bord" un composant de type "SPI Master" qui se trouve dans la "Boîte Outils Composants"   pictogramme "Comms"

Aide Flowcode

https://www.flowcode.co.uk/wikiv9/index.php?title=Component:_SPI_Master_(Comms:_Interface)

Composant SPI Master (Composant SPI Master)

Routines de bas niveau pour contrôler ou interagir avec une interface SPI. SPI (Serial Peripheral Interface) est un bus utilisé pour les communications entre périphériques au niveau de la carte. Un microcontrôleur cible intègre généralement au moins un périphérique SPI matériel. Si les broches SPI matérielles sont utilisées ou si davantage de canaux SPI sont nécessaires, un mode logiciel est également disponible. 

Pack de composants

COMMSA 

Description détaillée

Aperçu

Le bus SPI est un bus de communication haut débit, généralement idéal pour la communication entre des périphériques situés sur un même circuit imprimé. En raison de sa nature numérique haute fréquence, il est important de maintenir les pistes aussi courtes que possible et d'éviter autant que possible toute source de bruit. Un bus SPI typique se compose de quatre signaux : sélection de puce, sortie de données, entrée de données et horloge. Il est généralement composé d'un seul périphérique maître et d'un ou plusieurs périphériques esclaves. 

Étant donné que les signaux de données entrantes et sortantes sont subjectifs en termes de qui envoie et reçoit les données, il existe des noms alternatifs pour aider à clarifier la connexion. 

La sortie de données (SDO) est également connue sous le nom de MOSI, qui signifie Master Out Slave In. 

Les données entrantes (SDI) sont également connues sous le nom de MISO, qui signifie Master In Slave Out. 

Chaque transaction SPI est constituée d'un octet composé de 8 cycles d'horloge permettant de transférer les 8 bits de l'octet. 

Sélection de puce CS / Sélection d'esclave SS

Chaque périphérique connecté au bus SPI est connecté en parallèle aux trois broches SPI principales : sortie de données, entrée de données et horloge. La quatrième broche, la broche CS, doit être unique pour chaque périphérique SPI présent sur le bus, ce qui permet de n'adresser qu'un seul périphérique à la fois. Chaque périphérique esclave du bus SPI nécessitant un signal CS individuel du maître SPI, un bon moyen d'ajouter des périphériques sans occuper davantage les broches du maître SPI est d'utiliser des circuits intégrés multiplexeurs de 3 à 8 broches, par exemple. Le signal CS active le périphérique esclave lorsqu'il est bas et le désactive lorsqu'il est haut. 

L'ajout d'une résistance de rappel d'environ 10K - 100K entre le signal CS et VCC permet de désactiver le périphérique esclave SPI chaque fois que le microcontrôleur n'est pas prêt à exécuter la fonctionnalité du maître SPI, par exemple pendant la reprogrammation ou lorsque le périphérique est maintenu en réinitialisation. 

SPI à trois fils

Le SPI à trois fils est une version du SPI où le maître peut envoyer des données à l'appareil esclave mais ne peut pas relire les données, par exemple un DAC ou un écran LCD graphique. 

SPI à quatre fils

Le protocole SPI à quatre fils est la version complète du protocole SPI, permettant au maître d'envoyer des données au périphérique et d'en recevoir en retour. Une opération SPI unique transfère simultanément un octet du maître vers l'esclave via le signal MOSI et un octet de l'esclave vers le maître via le signal MISO. En général, seul l'un de ces octets est exploitable ; le protocole du périphérique esclave détermine donc la méthode d'écriture et de lecture.

Exemples

More information on SPI can be found here,

Matrix Flowcode Blog: Simplified communications I2C and SPI

Description

This library allows you to communicate with SPI devices, with the Arduino board as the controller device. This library is bundled with every Arduino platform (avr, megaavr, mbed, samd, sam, arc32), so you do not need to install the library separately.

To use this library #include <SPI.h>

To read more about Arduino and SPI, you can visit the Arduino & Serial Peripheral Interface (SPI) guide.

Functions

• SPISettings
• begin()
• beginTransaction()
• endTransaction()
• end()
• setBitOrder()
• setClockDivider()
• setDataMode()
• transfer()
• usingInterrupt()
• 
  

SPI Library

The SPI Library is included in every Arduino core/platform, so you do not need to install it externally. You can read more about SPI functions in the links below:

• SPI Library
• GitHub (ArduinoCore-avr)
• 
  

Serial Peripheral Interface (SPI)

With an SPI connection there is always one Controller device (usually a microcontroller) which controls the peripheral devices. Typically there are three lines common to all the devices:

• CIPO (Controller In Peripheral Out) - The Peripheral line for sending data to the Controller
• COPI (Controller Out Peripheral In) - The Controller line for sending data to the peripherals
• SCK (Serial Clock) - The clock pulses which synchronize data transmission generated by the Controller and one line specific for every device
• CS (Chip Select) - the pin on each device that the Controller can use to enable and disable specific devices. When a device's Chip Select pin is low, it communicates with the Controller. When it's high, it ignores the Controller. This allows you to have multiple SPI devices sharing the same CIPO, COPI, and SCK lines.

To write code for a new SPI device you need to note a few things:

• What is the maximum SPI speed your device can use? This is controlled by the first parameter in SPISettings. If you are using a chip rated at 15 MHz, use 15000000. Arduino will automatically use the best speed that is equal to or less than the number you use with SPISettings.
• Is data shifted in Most Significant Bit (MSB) or Least Significant Bit (LSB) first? This is controlled by second SPISettings parameter, either MSBFIRST or LSBFIRST. Most SPI chips use MSB first data order.
• Is the data clock idle when high or low? Are samples on the rising or falling edge of clock pulses? These modes are controlled by the third parameter in SPISettings.
• The SPI standard is loose and each device implements it a little differently. This means you have to pay special attention to the device's datasheet when writing your code.

Generally speaking, there are four modes of transmission. These modes control whether data is shifted in and out on the rising or falling edge of the data clock signal (called the clock phase), and whether the clock is idle when high or low (called the clock polarity). The four modes combine polarity and phase according to this table:

Once you have your SPI parameters, use SPI.beginTransaction()  to begin using the SPI port. The SPI port will be configured with your all of your settings. The simplest and most efficient way to use SPISettings is directly inside  SPI.beginTransaction() . For example:

If other libraries use SPI from interrupts, they will be prevented from accessing SPI until you call  SPI.endTransaction() . The SPI settings are applied at the begin of the transaction and  SPI.endTransaction()  doesn't change SPI settings. Unless you, or some library, calls beginTransaction a second time, the setting are maintained. You should attempt to minimize the time between before you call SPI.endTransaction() , for best compatibility if your program is used together with other libraries which use SPI.

With most SPI devices, after SPI.beginTransaction() , you will write the Chip Select pin LOW, call SPI.transfer()  any number of times to transfer data, then write the CS pin HIGH, and finally call SPI.endTransaction() .

For more on SPI, see Wikipedia's page on SPI.

Créé avec HelpNDoc Personal Edition: Ajoutez facilement le cryptage et la protection par mot de passe à vos PDF