Quel bus pour faire communiquer 10+ arduino ? I²C ? SPI ?

[invite0e8d0cbd]

Bonjour à tous,

Mon projet consiste à fabriquer une mallette, contenant plusieurs mini-jeux à résoudre. Chaque mini-jeu contient un certains nombre de composants (boutons, affichages, etc..). La mallette contiendrait une dizaine de ces mini-jeux, sous forme de modules séparés...

Comme j'ai pas l'impression d'être très clair, je vais détailler: Imaginez une mallette (vous savez, celle avec les liasses de billets dans les films). Cette mallette est divisée en 10 zones rectangulaires. Chaque zone accueille un module, permettant de jouer à un mini-jeu.

Le tout doit être contrôlé par une unique arduino, qui gère difficulté des niveaux, temps limité, etc..

Il est évident que je n'aurais jamais assez de ports sur un seul arduino. J'ai donc pensé utiliser un arduino par module, qui contrôlerait le déroulement du mini-jeu, et renverrais des informations quant au succès ou à l’échec du joueur. Un arduino "central" permettrait de traiter toutes ces infos et contrôler l'ensemble de la partie.

Comment donc faire dialoguer ensemble tous ces arduino ? (ou du moins, comment les faire tous communiqués avec le "central")

J'ai pensé à utilisé le bus I²C, mais je ne suis pas sur que ça conviennent. En effet, le module "mini-jeu" doit prévenir le "central" dès que le mini-jeu est fini (succès ou echec). Hors dans un fonctionnement Maître-esclave, l'esclave ne peut prendre la parole sans que le maître ne lui ait demandé. Et je trouve ça assez dégueu de demander en permanence "hé les gars, il a fini votre mini-jeu ?"
De plus, j'ignore si le I²C fonctionne correctement avec autant d’esclaves.

Je me suis aussi renseigné sur le SPI. Il a le mérite de ne pas avoir de pb de collision et communication en full-duplex, mais le manque d'acquittement et le nombre ne fils supplémentaires me gène, ça semble pas convenir non-plus. En plus, c'est encore du maitre esclave donc impossible pour le maitre d'attendre un message provenant de n'importe quel esclave...

Enfin, j'aimerais utiliser une communication avec peu de fils, le but étant de garder le plus de ports pour les composants à piloter, et si possible, d'utiliser les micro-contrôleurs les plus petits possibles (réduction des coûts). Dans l'idéal, le boitier serait modulable, avec la possibilité de rajouter ou d'enlever des modules. Ils viendraient alors se "clipser" sur la malette, et se connecter via RJ11 ou autre connecteur petit et pratique.


Merci d'avance et n'hésitez pas à demander des détails si besoin.
-----

[invite936c567e]

Bonsoir

Avant de tirer des conclusions, il me semble utile (sinon absolument nécessaire) de déterminer le besoin réel résultant de la conception des jeux, et le cas échéant, des échanges à réaliser entre les systèmes si on doit les multiplier.

Par exemple, je ne suis pas sûr que les 70 entrées-sorties (dont 16 entrée analogiques) d'un Arduino Mega ne suffise pas à ce type d'application, surtout quand des techniques de multiplexage permettent d'en augmenter virtuellement le nombre.

Ensuite, SPI et I2C ne sont pas les seules interfaces permettant d'échanger des informations doivent être échangées, notamment quand ces informations se résument à la survenue d'un événement ou à l'expression d'un état binaire.

Par exemple, si cela était vraiment nécessaire, on pourrait limiter les échanges entre un système maître et ses systèmes esclaves aux seuls moments où un esclave signale au maître sa volonté de communiquer grâce à un niveau de sortie logique. Ce signalement peut être global et anonyme (entrée unique sur le maître pour plusieurs sorties sur les esclaves), ou bien individuel et identifié (autant d'entrées sur le maître que de sorties sur les esclaves).

[invite0e8d0cbd]

Bonsoir,
Merci pour ta réponse

Par exemple, je ne suis pas sûr que les 70 entrées-sorties (dont 16 entrée analogiques) d'un Arduino Mega ne suffise pas à ce type d'application, surtout quand des techniques de multiplexage permettent d'en augmenter virtuellement le nombre.

Alors en pratique il y aurais entre 8 et 12 modules "mini-jeu". Ces modules peuvent contenir 1 bouton et quelques leds, comme ils peuvent contenir une matrice led RGB 9x9 avec ses boutons ou un afficheur 16x2 + keypad.

Bref, la diversité est grande, mais il y aurait en moyenne bien 10 pins par module (VCC et GND exclus)
De plus, j'ai mentionné vouloir faire quelque chose de modulable, c'est pourquoi un bus aurait grandement simplifié les choses en permettant un raccord du module au système via une simple connectique 4 broches.

Je ne connaissait pas les possibilités de multiplexage. Je pourrais me pencher dessus, en dernier recours, mais j’espère vraiment trouver un moyen de le faire sans multiplier les fils entre le maitre et les modules.

Ensuite, SPI et I2C ne sont pas les seules interfaces permettant d'échanger des informations doivent être échangées, notamment quand ces informations se résument à la survenue d'un événement ou à l'expression d'un état binaire.

Par exemple, si cela était vraiment nécessaire, on pourrait limiter les échanges entre un système maître et ses systèmes esclaves aux seuls moments où un esclave signale au maître sa volonté de communiquer grâce à un niveau de sortie logique. Ce signalement peut être global et anonyme (entrée unique sur le maître pour plusieurs sorties sur les esclaves), ou bien individuel et identifié (autant d'entrées sur le maître que de sorties sur les esclaves).

Il est vrai que je peux effectivement gérer moi-même mon propre protocole de communication, spécifique et adapté, mais j’espérais simplifier les choses en m'appuyant sur un protocole existant

Un compromis serait également de contrôler ce que je peux en I²C (afficheurs, etc.) afin de libérer des ports pour le reste, mais encore une fois, si je peux avoir des modules "plug & play" c'est mieux.

[jojo150393]

Salut!
Le plus simple, le RS485 ou beaucoup plus complexe, le CAN.
Après, comme expliqué plus haut, si les informations a transmettre sont toujours pareil (genre, début du jeu, fin du jeu...), utiliser des IO classiques serait plus simple.

Après, devoir constamment demander ou en est l'état du jeu n'est à mon sens pas vraiment un problème.

[A voir en vidéo sur Futura]

[Seb.26]

Une boucle UART : tu relies chaque Tx au Rx du module suivant.

[mag1]

Bonjour,

Si les jeux sont utilisés individuellement, c'est à dire jamais deux ensembles, la solution d'une simple liaison RS232 me semble la plus simple.

Chaque jeu ayant un identifiant, permettant de lui attribuer un traitement spécifique. Les jeux en attente ont leur sortie en haute impédance ( càd en entrée), tous les jeux peuvent se partager la même entrée sur le µC central.

Maintenant, si tous les jeux peuvent être utilisés en même temps, c'est une autre histoire..

MM