Comment obtenir plus d'une interface uart

Ok, j'ai une interface uart (TXD GPIO 14, RXD GPIO 15). Je veux au moins une autre interface uart.

Solutions possibles:

• Frappe de bits: utilisez deux GPIO de rechange non liés. Je comprends que le timing est un problème sur un linux standard. Serait-il fiable avec un débit en bauds très faible?

• Commutation: RPI décide quand parler à quel appareil. Utiliser par exemple CD4066BC .

• spi à 2 x uart bridge: Vous n'avez pas trouvé de pièce appropriée (disponibilité, prix, package dil)

• usb à uart: cher

Y a-t-il d'autres options? Je suis enclin à changer, si cela peut être fait. Que conseilleriez-vous?

Un UART USB, tel que FTDI, n'est pas vraiment cher. Toutes vos autres options semblent vous coûter plus cher en pièces et en temps que les ~ 13 $ que cela pourrait vous coûter, et ne sont pas fiables ou lentes. Optez simplement pour l'option rapide et sans problème, telle que:

http://www.dfrobot.com/index.php?route=product/product&product_id=147#.UOamLG-sh8E

Sparkfun en vend un aussi. En fait, vous pouvez peut-être simplement en retirer un d'un ancien périphérique USB ou en acheter un dans un magasin indésirable qui ne sait pas ce qu'il fait.

J'ai joué avec un adaptateur SPI vers UART pour un projet Arduino, il n'y avait pas de bibliothèque existante, j'ai donc écrit la mienne. En fin de compte, cela a bien fonctionné, mais si j'aurais pu déposer une partie de 15 $, j'aurais. En fait, compte tenu du temps que cela m'a coûté, j'aurais dû obtenir un méga avec 4 ports série.

Alternativement, si vous voulez beaucoup de ports série, vous pouvez regarder la série RS485, qui est similaire à 232 (bien que non compatible), qui prend en charge le multipoint, c'est-à-dire plusieurs interfaces sur la même ligne.

Si vous décidez de ne pas ajouter de matériel supplémentaire et de suivre la voie du bit banging, ce n'est pas aussi difficile que certains l'imaginent.

Tout d'abord, votre fil de communication doit passer en temps réel:

#include<sched.h>

struct sched_param param;               
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
if( sched_setscheduler( 0, SCHED_FIFO, &param ) == -1 )
{
        perror("sched_setscheduler");
        return -1;
}

À partir de maintenant, votre thread ne sera pas préempté pendant 950 ms sur chaque seconde ^* , à moins qu'il ne retourne volontairement le contrôle (via sched_yield()ou usleep()) en temps opportun, ce qui ne le rendra jamais préempté. Avec un processeur à 850 MHz, votre boucle de frappe sera inactive la plupart du temps, même à des vitesses plus rapides.

Désormais, malheureusement, l'obligation de rendre le contrôle de temps en temps signifie que votre fil est en veille, quoi que vous envoie votre «partie adverse», serait définitivement perdue. Mais à cette fin, vous pouvez utiliser le contrôle de transmission. Soit allouez un peu plus de GPIO pour la ligne CTS que vous tirez vers le bas avant de céder et sauvegardez lors de la restauration du contrôle:

  bcm2835_gpio_write(CTS_PIN, LOW);
  usleep(10);
  bcm2835_gpio_write(CTS_PIN, HIGH);

ou (à mon humble avis de préférence) utilisez le contrôle de transmission XON / XOFF - envoyez le caractère XOFF sur RS232 avant de dormir, XON après avoir repris l'opération. Les codes ASCII par défaut pour ceux-ci sont '\x13'pour XOFF / "arrêter l'envoi" et '\x11'pour XON / "reprendre l'envoi".

Bien sûr, votre appareil distant doit respecter ces conditions. Si ce n'est pas le cas, certaines données seront perdues.

J'ai trouvé ce que vous cherchiez: un pont esclave I2C / SPI vers UART / IrDA / GPIO.

Ils sont disponibles en version simple et double (donc 1 ou 2 UART supplémentaires). Ils (NXP) ont également (pour l'autre côté en cas de besoin) des ponts maître I2C / SPI vers UART / IrDA / GPIO.

Plus d'informations sur ces puces ici et sur l' homologue maître .

Maxim a également des puces qui font exactement la même chose.

Les ponts USB vers UART sont bon marché et facilement disponibles, mais ont des caractéristiques de synchronisation vraiment minables. Newark vend une carte «Embedded Pi» dotée d'un processeur ARM STM32F sur lequel vous pouvez écrire du code nu. Cette puce a trois UART dessus, et je pense qu'ils peuvent aller assez vite; si vous deviez en utiliser un pour communiquer avec le Raspberry Pi, cela en laisserait deux disponibles à d'autres fins. Avis de non-responsabilité: j'ai acheté l'une de ces cartes, mais je n'ai encore utilisé que le Raspberry Pi lui-même pour gérer directement les besoins d'E / S.

Si vous voulez beaucoup d'UART plus lents, le STM32F sur la carte Embedded Pi pourrait probablement gérer un bon nombre, surtout si vous êtes prêt à écrire un langage d'assemblage de bras. S'il y a deux groupes de 16 broches d'E / S disponibles sur une seule carte, il pourrait être possible d'avoir 16 UART logiciels simultanés fonctionnant tous à la fois à une vitesse de transmission assez décente (avoir une interruption périodique à 3x ou 5x la vitesse de transmission qui stocke Valeurs verrouillées 16 bits du port de réception vers un tampon et sorties de valeurs précalculées 16 bits d'un tampon vers le port de transmission; si vous faites cela, alors la durée moyenne de maintenance des UART logiciels n'est pas trop longue, elle n'a pas d'importance s'il y a un coup occasionnel dans le pire des cas (par exemple, les seize ports reçoivent un octet simultanément).

Cette approche peut en fait fonctionner de manière remarquablement efficace pour la réception, car le code "cas commun" n'a même pas à regarder les UART individuels. Supposons que vous échantillonnez des données à 5x et que les 47 derniers octets du tampon soient dupliqués juste avant. En supposant que les données sont écrites dans le tampon dans l'ordre croissant, vous pouvez ensuite vérifier si un octet a été entièrement reçu sur l'un des 16 canaux en disant simplement:

bytes_ready = (armed_flag & data[rxptr] & ~data[rxptr-47] & ~data[rxptr-46] & ~data[rxptr-45] & ~data[rx_ptr-44]);

Si bytes_readyest zéro, aucune donnée n'a été reçue. Sinon, si par exemple le bit 2 de bytes_readyest défini, cela signifie qu'un octet de données reçu peut être trouvé dans le bit 2 des données [rx_ptr-40], des données [rx_ptr-35], des données [rx_ptr-30], etc. les données, effacez le bit 2 d'armed_flag et faites en sorte qu'il soit réinitialisé après environ 44 échantillons.

Cette approche nécessitera un peu de travail sur les échantillons où un octet de données est entièrement reçu (et potentiellement beaucoup de travail si les 16 canaux ont un octet de données arrivent en même temps) mais sur la plupart des échantillons, la quantité de travail sera très léger. Si l'on avait 64 broches d'E / S, on pourrait gérer jusqu'à 32 UART en utilisant cette approche sans ajouter de travail supplémentaire au cas «commun».

Un microcontrôleur comme un Picaxe pourrait prendre des données série sur une broche et produire des données série sur une certaine broche de manière appropriée. Cela vous donnerait effectivement plus de sorties série si vous étiez prêt à dire au Picaxe sur quelle broche sortir. Il pourrait également faire la même chose, mais à l'inverse, il pourrait donc recevoir des données série de plusieurs appareils et les envoyer au Raspberry Pi. Une autre option pourrait être de faire en sorte que les appareils connectés nécessitent un qualificatif . Cela signifie que le périphérique 1 devrait recevoir les données «d1», par exemple avant d'écouter d'autres données sur la ligne série. Le périphérique 2 pourrait avoir «d2» comme qualificatif. Cela signifierait que pour dire «bonjour» au périphérique 1, il vous suffirait d'envoyer «d1hello» sur la ligne UART.

Les Picax sont assez bon marché, vous pouvez les obtenir sur http://www.techsupplies.co.uk/ et ils existent en plusieurs tailles avec différents nombres de broches et ainsi de suite.

Si la communication avec plusieurs périphériques esclaves UART n'a pas besoin de se produire en parallèle, vous pouvez partager le seul port UART disponible entre eux. Vous pouvez utiliser des transistors pour activer uniquement les connexions RxD / TxD à l'appareil auquel vous souhaitez actuellement parler. Ces transistors peuvent être contrôlés par d'autres broches GPIO du Raspberry Pi.

Le Raspberry Pi 4 prend désormais en charge jusqu'à 4 interfaces UART qui doivent être activées au moyen d'une superposition d'arborescence de périphériques. Vous pouvez trouver comment faire cela et quelles broches sont utilisées ici pour l'instant:

https://www.raspberrypi.org/forums/viewtopic.php?t=244827

La fondation RPi prépare toujours la documentation à ce sujet.

J'ai eu le même problème. Je dois me connecter à 2-4 modules GSM et j'ai trouvé une solution matérielle: http://www.instructables.com/id/SPI-to-4-x-UART-Bridge-MULTIUART/

Cette solution est basée sur PIC24FJ64GA306. Vous pouvez remplacer PIC par Atmel mcu, mais vous devez créer un nouveau PCB :)

J'utilise SC16IS752 IC qui est un convertisseur SPI en 2xUART. Cela fonctionne bien avec Raspbian Stretch.

C'est un peu plus cher que la puce FTDI, mais il y a deux uarts et je n'ai pas besoin d'utiliser un précieux port USB.

Jetez un œil sur https://www.kickstarter.com/projects/1915118535/uart-hat-for-raspberry-pi j'espère que cela peut résoudre votre problème