Introduction au bit banging: communication SPI via bit banging

Les interfaces de communication sont l'un des facteurs pris en compte lors de la sélection d'un microcontrôleur à utiliser pour un projet. Le concepteur s'assure que le microcontrôleur sélectionné dispose de toutes les interfaces nécessaires pour communiquer avec tous les autres composants à utiliser pour le produit. L'existence de certaines de ces interfaces telles que SPI et I2C sur un microcontrôleur augmente invariablement le coût de ces microcontrôleurs et, en fonction du budget de la nomenclature, il peut rendre un microcontrôleur souhaité non abordable. Dans des situations comme celles-ci, les techniques comme Bit Banging entrent en jeu.

Qu'est-ce que Bit Banging?

Le Bit banging est une technique de communication série dans laquelle l'ensemble du processus de communication est géré via un logiciel au lieu d'un matériel dédié. Pour transmettre des données, la technique implique l'utilisation d'un logiciel pour coder les données en signaux et impulsions qui sont utilisés pour manipuler l'état d'une broche d'E / S d'un microcontrôleur qui sert de broche Tx pour envoyer des données au dispositif cible. Pour recevoir des données, la technique consiste à échantillonner l'état de la broche Rx après certains intervalles qui sont déterminés par le débit en bauds de communication. Le logiciel définit tous les paramètres nécessaires pour réaliser cette communication, y compris la synchronisation, la synchronisation, les niveaux, etc., qui sont généralement décidés par un matériel dédié lorsque le bit banging n'est pas utilisé.

Quand utiliser Bit Banging

Le Bit-Banging est généralement utilisé dans les situations où un microcontrôleur avec l'interface requise n'est pas disponible ou lorsque le passage à un microcontrôleur avec l'interface requise peut être trop coûteux. Il offre ainsi un moyen peu coûteux de permettre à un même appareil de communiquer en utilisant plusieurs protocoles. Un microcontrôleur qui est précédemment activé pour la communication UART uniquement, peut être équipé pour communiquer en utilisant SPI et 12C via le bit banging.

Algorithme de communication série via Bit Banging

Alors que le code pour implémenter le bit banging peut différer d'un microcontrôleur à l'autre et peut également varier pour différents protocoles série, la procédure / algorithme pour implémenter le bit banging est le même sur toutes les plates-formes.

Pour envoyer des données par exemple, le pseudo-code ci-dessous est utilisé;

1. Début
2. Envoyer le bit de début
3. Attendez que la synchronisation corresponde à la vitesse de transmission du récepteur
4. Envoyer un bit de données
5. Attendez que la durée corresponde à nouveau à la vitesse de transmission du récepteur
6. Vérifiez si tous les bits de données ont été envoyés. Si non, passez à 4. Si oui, allez à 7
7. Envoyer un bit d'arrêt
8. Arrêtez

La réception de données a tendance à être un peu plus complexe, généralement une interruption est utilisée pour déterminer quand les données sont disponibles sur la broche du récepteur. Cela permet de garantir que le microcontrôleur ne gaspille pas trop de puissance de traitement. Bien que certaines implémentations utilisent l'une des broches d'E / S des microcontrôleurs, les risques de bruit et d'erreurs, s'ils ne sont probablement pas traités, sont plus élevés. L'algorithme pour recevoir des données à l'aide d'interruptions est expliqué ci-dessous.

1. Début
2. Activer l'interruption sur la broche Rx
3. Lorsque l'interruption est déclenchée, obtenir le bit de démarrage
4. Attendre la synchronisation en fonction de la vitesse de transmission
5. Lire la broche Rx
6. Répétez de 4 jusqu'à ce que toutes les données aient été reçues
7. Attendre la synchronisation en fonction de la vitesse de transmission
8. Vérifier le bit d'arrêt
9. Arrêtez

Bit Banging sur SPI

Comme mentionné ci-dessus, le bit bang pour différents protocoles fonctionne différemment et il est donc important de lire sur chaque protocole, de comprendre le cadrage et la synchronisation des données avant d'essayer de l'implémenter. En prenant le mode SPI 1 comme exemple, la valeur de base de l'horloge est toujours 0 et les données sont toujours envoyées ou reçues sur le front montant de l'horloge. Le chronogramme du protocole de communication SPI Mode 1 est illustré ci-dessous.

Pour implémenter cela, l'algorithme suivant peut être utilisé;

1. Début
2. Réglez la broche SS bas pour commencer la communication
3. Réglez la broche pour Master Out Slave In (MOSI) sur le premier bit des données à envoyer
4. Réglez la broche d'horloge (SCK) sur une valeur élevée pour que les données soient transmises par le maître et reçues par l'esclave
5. Lire l'état du maître en sortie esclave (MISO) pour recevoir le premier bit de données de l'esclave
6. Réglez SCK Low, afin que les données puissent être envoyées au prochain front montant
7. Passez à 2 jusqu'à ce que tous les bits de données aient été transmis.
8. Réglez la broche SS High pour arrêter la transmission.
9. Arrêtez

Exemple de Bit Banging: communication SPI dans Arduino

À titre d'exemple, implémentons l'algorithme de communication SPI via le bit banging dans Arduino pour montrer comment les données peuvent être bit-banged via SPI en utilisant le code ci-dessous.

Nous commençons par déclarer les broches de l'Arduino à utiliser.

const int SSPin = 11; const int SCKPin = 10; const int MISOPin = 9; const int MOSIPin = 8; octet sendData = 64; // Valeur à envoyer octet slaveData = 0; // pour stocker la valeur envoyée par l'esclave

Ensuite, nous passons à la fonction void setup () où l'état des broches est déclaré. Seule la broche Master in Slave out (MISO) est déclarée comme entrée car c'est la seule broche qui reçoit des données. Toutes les autres broches sont déclarées comme sortie. Après avoir déclaré les modes de broche, la broche SS est réglée sur HIGH. La raison en est de s'assurer que le processus est sans erreur et que la communication ne démarre que lorsqu'elle est réglée sur faible.

void setup () { pinMode (MISOPin, INPUT); pinMode (SSPin, OUTPUT); pinMode (SCKPin, OUTPUT); pinMode (MOSIPin, SORTIE); DigitalWrite (SSPin, HIGH); }

Ensuite, nous commençons la boucle pour envoyer des données. Notez que cette boucle continuera d'envoyer les données à plusieurs reprises.

Nous commençons la boucle en écrivant la broche SS bas, pour initier le début de la communication, et appelons la fonction bitbangdata qui divise les données prédéfinies en bits et les envoie. Cela fait, nous écrivons ensuite la broche SS HIGH pour indiquer la fin de la transmission de données.

boucle vide () { digitalWrite (SSPin, LOW); // SS bas slaveData = bitBangData (sendData); // transmission de données digitalWrite (SSPin, HIGH); // SS encore haut }

Le bitbangdata () fonction est écrit ci - dessous. La fonction prend les données à envoyer et les décompose en bits et les transmet en bouclant le code pour la transmission comme indiqué à l'étape 7 de l'algorithme.

byte bitBangData (byte _send) // Cette fonction transmet les données via bitbanging { byte _receive = 0; for (int i = 0; i <8; i ++) // 8 bits dans un octet { digitalWrite (MOSIPin, bitRead (_send, i)); // Définit MOSI digitalWrite (SCKPin, HIGH); // SCK high bitWrite (_receive, i, digitalRead (MISOPin)); // Capture MISO digitalWrite (SCKPin, LOW); // SCK bas } return _receive; // Renvoie les données reçues }

Inconvénients du Bit Banging

L'adoption du bit banging devrait cependant être une décision bien pensée car il y a plusieurs inconvénients au bit banging qui peuvent le rendre non fiable pour l'implémentation dans certaines solutions. Les coups de bits augmentent la puissance consommée par le microcontrôleur en raison de la puissance de traitement élevée consommée par le processus. Par rapport au matériel dédié, plus d'erreurs de communication telles que des pépins et des tremblements se produisent lorsque le bit bang est utilisé, en particulier lorsque la communication de données est effectuée par le microcontrôleur en même temps que d'autres tâches. La communication via le bit banging se produit à une fraction de la vitesse à laquelle elle se produit lorsqu'un matériel dédié est utilisé. Cela peut être important dans certaines applications et peut faire du bit bang un choix «pas si bon».

Bit banging est utilisé pour toutes sortes de communications série, y compris RS-232, communication série asynchrone, UART, SPI et I2C.

UART via Bit banging dans Arduino

L'une des implémentations populaires du bit banging est la bibliothèque série logicielle Arduino qui permet à l'Arduino de communiquer via UART sans utiliser les broches UART matérielles dédiées (D0 et D1). Cela donne beaucoup de flexibilité car les utilisateurs peuvent connecter autant de périphériques série que le nombre de broches sur la carte Arduino peut prendre en charge.