Bonjour,
Dans le cadre de mon robot spéléo, je vais avoir beaucoup de moteurs DC à commander (16 à priori : 8 pour les roues, 8 pour les élastiques qui tendent les bras (ou pour contrôler directement les bras et "simuler" l’élasticité)). Parmi ces moteurs, au moins 8 (ceux des roues) seront muni d'un encodeur à quadrature, et au moins 8 (ceux des bras) seront muni d'un contrôle en courant (donc en couple).
Il est possible que je décidé d'ajouter la mesure du courant sur les moteurs des roues et/ou la mesure de position sur les moteurs des bras (pour ce dernier c'est même quasi sur, mais je ne sais pas encore si ce sera un encodeur sur le moteur de l'élastique et/ou un encodeur sur l'axe du bras et/ou un simple potentiomètre sur l'axe du bras).
Donc pour résumer :
- 16 moteurs DC (donc 16PWM + 16 sorties digitales)
- 8 ou 16 encodeurs à quadrature (donc 16 ou 32 interruptions à compter)
- 8 ou 16 mesures de courant (probablement résistance shunt donc 8 entrées analogique)
- 0 ou 8 mesures de position par potentiomètre (donc 8 entrées analogiques)
- quelques autres éléments en plus petit nombre (probablement 4 servos, 2 télémètres (I2C ou UART), mesure de tension de batterie, probablement 2 PWM pour gérer l'éclairage (avant et arrière), peut-être des moteurs en plus pour tourner 1 ou 2 caméras.
Bref, un grand nombre d'I/O, dont 16 ou 32 signaux interruptions.
Je me demandais donc quelle était la meilleur manière de gérer tout ça (sachant que j'aurais un raspberry pi comme maître)?
Pour l'instant, je vois :
- réseau d'Atmega328P (ceux des Arduinos Uno, nano, ...) en minimaliste (juste le circuit intégré et 2 condensateurs, donc environ 2€/microcontroleur), à 8MHz (au delà il faut un quartz). L’inconvénient est qu'il n'y a que 2 pins d'interruption par microcontrôleur, donc il m'en faudrait 8 ou 16 pour gérer toutes les interruptions. L'ensemble serait connecté en I2C au raspi (on aurait donc un Atmega par ensemble {bras+roue} voir un par bras et un par roue
- idem, mais en utilisant "boostant" le nombre d'interruption possible : on met un circuit logique xor entre tous les signaux des encodeurs, et seul la sortie du xor vas sur le pin d'interruption : quand l'interruption survient, on va lire tous les signaux d'interruption (qui sont sur des pins I/O normaux). On peut optimiser un peu la lecture en groupant 8 signaux sur un port. L’inconvénient est que la détection du signal se fait en soft, donc risque de rater des signaux le temps d'aller lire.
- idem, mais en utilisant "Pin change interrupts" qui permet de détecter un changement sur une entrée d'un port (ie groupe de 8 I/O) : même problème qu'au dessus, il faut aller lire en soft de quel pin il s'agit.
- utiliser un/des microcontrôleurs gérant plus de pin d'interruption : des suggestions?
- ne pas gérer le comptage des fronts montant/descendants des encodeurs depuis un micro-controleur mais avec des circuits logiques + compteur, et on ne vas que lire le compteur de temps en temps.
- utiliser une carte dédiée à la gestion d'un grand nombre d'encodeurs : vous en connaissez?
- utiliser un FPGA pour gérer le contrôle des moteurs (avec un ADC ou un arduino pour gérer les entrées numériques). Est-ce que vous connaissez une carte FPGA pas trop chère, avec beaucoup d'IO, fonctionnant en 3.3 ou 5V?
Nb : je peux probablement me permettre de ne pas profiter pleinement de la résolution des encodeurs et de n'utiliser qu'un des signaux en interruption et l'autre que pour la direction (ie renoncer à la multiplication par 2 de la résolution qu'on obtient en exploitant les fronts du second signal)
Merci d'avance
Sandro
