Est-il possible d'avoir plus de 14 broches de sortie sur arduino?

Est-il possible d'avoir plus de 14 broches de sortie sur l'Arduino, je travaille sur un projet dans lequel j'ai besoin d'allumer plusieurs LED individuellement. Je n'ai qu'un Arduino Uno et je ne veux pas avoir un Mega.

Un moyen courant d’élargir l’ensemble des broches de sortie disponibles sur l’Arduino consiste à utiliser des registres à décalage tels que le CI 74HC595 ( lien vers la fiche technique ).

Vous avez besoin de 3 broches pour contrôler ces puces:

1. L'horloge
2. Loquet
3. Les données

Dans un programme, vous transmettez les données bit par bit au registre à décalage à l'aide de la commande shiftOut () , comme suit :

shiftOut(dataPin, clockPin, data); 

Avec cette commande, vous définissez chacune des 8 sorties du 595 IC avec les 8 bits de la datavariable.

Avec un 595, vous gagnez 5 broches (8 sur le circuit intégré, mais vous en passez 3 à lui parler). Pour obtenir davantage de sorties, vous pouvez chaîner une série de 595 unités en connectant sa broche de sortie série à la broche de données de la suivante. Vous devez également connecter ensemble les broches d’horloge et de verrouillage de l’ensemble des 595 circuits intégrés.

Le circuit résultant (en utilisant un 595) ressemblerait à ceci:

Le chiffre ci-dessus est tiré de cette page Web codeproject.com :

• Plateforme Arduino - Travailler avec des registres à décalage

La broche de verrouillage sert à maintenir les 595 sorties stables pendant que vous y transférez des données, comme suit:

digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, data); 
digitalWrite(latchPin, HIGH);

Il existe deux manières d’obtenir plus de broches d’un arduino.

La première consiste à utiliser les broches analogiques en tant que broches de sortie numérique, ce qui est très facile à faire. Il suffit de consulter A0-A5 en tant que broches 14,15,16,17,18,19. Par exemple, pour écrire haut sur la broche A0, utilisez simplement digitalWrite (14, HIGH).

L’autre moyen d’extraire plus de broches de l’Arduino est d’utiliser un registre à décalage. Pour ce faire, je vous recommande d'utiliser le bouclier EZ-Expander , qui vous permet d'utiliser digitalWrite ([20-35], HIGH) lorsque vous importez la bibliothèque EZ-Expander. Ce blindage ne permet cependant que l'utilisation des broches comme sorties et utilise les broches 8, 12 et 13 pour contrôler les registres à décalage.

Le grand avantage est que vous pouvez utiliser les deux méthodes ci-dessus ensemble, sans aucun problème.

Si vous souhaitez piloter des LED, vous pouvez également utiliser un MAX7219 pouvant piloter 64 LED, sans circuit supplémentaire (aucun transistor n'est nécessaire pour amplifier le signal).

Conduire un MAX7219 ne nécessite que 3 broches de sortie sur Arduino. En outre, vous pouvez trouver quelques bibliothèques Arduino pour cela.

Vous pouvez également en chaîner plusieurs si vous devez alimenter plus de 64 LED.

Je l'ai utilisé avec succès pour plusieurs écrans LED à 7 segments.

Inconvénient: c'est cher (environ 10 $).

Vous pouvez utiliser Charlieplexing . Avec cette technique, vous pouvez piloter directement des n*(n-1)LED à partir de n broches. Donc, avec 3 broches, vous pouvez piloter 6 DEL, 4 broches - 12 DEL, 5 broches - 20 DEL, etc.

Exemple:

Six LED sur 3 pins

PINS        LEDS
0 1 2   1 2 3 4 5 6
0 0 0   0 0 0 0 0 0
0 1 Z   1 0 0 0 0 0
1 0 Z   0 1 0 0 0 0
Z 0 1   0 0 1 0 0 0
Z 1 0   0 0 0 1 0 0
0 Z 1   0 0 0 0 1 0
1 Z 0   0 0 0 0 0 1
0 0 1   0 0 1 0 1 0
0 1 0   1 0 0 1 0 0
0 1 1   1 0 0 0 1 0
1 0 0   0 1 0 0 0 1
1 0 1   0 1 1 0 0 0
1 1 0   0 0 0 1 0 1
1 1 1   0 0 0 0 0 0

Vous pouvez voir un meilleur tutoriel ici .

I ² C (Fil)

Vous pouvez utiliser le protocole I ² C (bibliothèque filaire) pour vous connecter à d'autres périphériques tels que des expandeurs de ports. Par exemple, le MCP23017.

J'ai utilisé l'une de ces puces pour me connecter à un tableau LCD. Le MCP23017 dispose de 16 ports pouvant être configurés en tant qu’entrées ou sorties. En tant qu'entrées, elles peuvent déclencher des interruptions si vous le souhaitez.

Exemple de connexion de 13 de ces 16 à l’écran LCD:

Nous nous connectons maintenant à l’Arduino en utilisant seulement 2 fils (SDA / SCL) plus l’alimentation et la terre:

Certains fabricants tiers ont fabriqué des cartes avec 4 x MCP23017, ce qui vous donne 64 entrées / sorties:

Multiplexeurs

Vous pouvez utiliser des multiplexeurs analogiques tels que le 74HC4051 (8 ports) ou le 74HC4067 (16 ports) pour connecter une broche à l'un des 8/16 ports (mais un seul à la fois), comme ceci:

Celles-ci sont bidirectionnelles, elles peuvent donc être utilisées comme expandeur d’entrée ou de sortie.

SPI avec 74HC595

SPI vous permet d’envoyer des données série rapides à un registre à décalage, tel que le 74HC595. Ceux-ci peuvent être chaînés ensemble. Dans cet exemple, je contrôle 32 LED avec seulement 3 broches d'E / S (MOSI / MISO / SCK), ainsi que l'alimentation et la masse.

J'ai trouvé à l'intérieur d'un panneau LED indiquant que les 72 LED étaient alimentées par des puces 74HC595.

Il y avait 9 puces pilotant les colonnes (9 x 8 = 72 LED) et une puce pilotant les rangées, dans une configuration multiplexée.

SPI avec MAX7219

Si vous souhaitez uniquement piloter des voyants, vous pouvez généralement les multiplexer. Le MAX7219 simplifie cela en étant conçu pour piloter des matrices de LED, par exemple des écrans à 7 segments:

Ou matrices 64 LED:

Dans les deux cas, ceux-ci peuvent être chaînés, par exemple:

Tous ces exemples utilisent uniquement 3 broches de l'Arduino (MOSI / MISO / SCK) plus l'alimentation et la terre.

SPI avec MCP23S17

Le module d'extension de port à 16 ports mentionné précédemment (MCP23017) est également proposé dans une variante SPI (MCP23S17), qui effectue des tâches pratiquement identiques. Il utilise un fil de plus, mais serait plus rapide.

Autres protocoles

Les bandes de LED (comme celles de NeoPixel) ont leurs propres protocoles. Josh Levine avait publié un post sur Youtube où l'auteur avait parcouru plus de 1000 pixels avec un Duemilanove!

Références

• I2C et MCP23017
• MCP23017 et LCD graphique
• Multiplexeur / démultiplexeur 74HC4051
• SPI
• Pirater une bande de défilement LED
• Utilisation d'un registre à décalage de sortie 74HC595 comme expanseur de port
• Interfaçage des écrans à LED avec le pilote MAX7219

Les registres à décalage ont été mentionnés dans d'autres réponses et ils constituent un excellent choix pour de nombreux projets. Ils sont peu coûteux, simples, moyennement rapides et peuvent généralement être chaînés pour ajouter davantage de sorties. Cependant, ils ont l’inconvénient de nécessiter l’utilisation exclusive de plusieurs broches (entre 2 et 4, selon la configuration choisie).

Une alternative consiste à utiliser des expandeurs de port plus avancés, tels que les MCP23017 et MCP23S17 16 bits . Ceux-ci supportent respectivement I2C et SPI, ce qui signifie que vous pouvez les placer sur un bus avec plusieurs autres périphériques (potentiellement de types différents). Chaque périphérique du bus peut être adressé individuellement, ce qui signifie que vous n’avez besoin que de 2 ou 3 broches pour communiquer avec chacun d’eux. Les vitesses de mise à jour sont généralement extrêmement rapides, il est donc peu probable que vous rencontriez une latence importante (c.-à-d. Des retards de transmission) dans un projet Arduino.

À un niveau bas, utiliser I2C ou SPI est nettement plus compliqué qu'un simple registre à décalage. Cependant, Arduino a un code de bibliothèque pour s’occuper de cela pour vous. Voir cette question, par exemple: Comment utiliser des périphériques I2C avec Arduino?

En plus de la réponse de Ricardo , ce que Wikipedia dit dans les registres à décalage :

L'une des utilisations les plus courantes d'un registre à décalage est la conversion entre interfaces série et parallèle. Les registres SIPO sont généralement attachés à la sortie des microprocesseurs lorsque le nombre de broches d'entrée / sortie à usage général requises est supérieur au nombre disponible. Cela permet à plusieurs périphériques binaires d'être contrôlés à l'aide de deux ou trois broches, mais plus lentement que les E / S parallèles.

Dans l' article lié Ricardo, vous pouvez voir le schéma du registre à décalage.

Ce qui se passe ici, c’est que vous mettez les données des 8 broches dans une séquence et que, pour chaque horloge, le registre à décalage se décale (déplace les données binaires de chaque bascule vers le suivant) jusqu’à ce qu’il forme un cercle, c’est-à-dire le premier bit. arrive à la dernière broche. Les registres à décalage ont également une entrée où vous pouvez activer / désactiver le décalage afin que l’état puisse être conservé une fois les données décalées. Pour une démonstration simple, voir l'animation suivante.

Ici, le feu rouge est l’entrée série et les verts indiquent l’état des bascules dans ce registre à décalage SIPO simplifié . Une fois les données décalées, vous pouvez désactiver le décalage et lire les broches. Dans cet exemple, je suis sorti 10101011.

À partir de ces exemples, vous pouvez vous rendre compte que le transfert en série sera plus lent que le transfert en parallèle, car vous devez attendre que le registre à décalage mette les bits à leur place. Vous devrez attendre le même nombre d’heures que vous souhaitez charger. C'est l'une des nombreuses raisons pour lesquelles vous ne pouvez pas les chaîner indéfiniment, car le chargement prendrait une éternité.

Comme vous l'avez déjà écrit, vous pouvez utiliser toutes les broches, y compris TX et RX, comme sortie numérique. Je l'ai fait il y a quelque temps pour un démonstrateur et j'ai enregistré une vidéo - 20 LEDS sur 20 broches - de ce projet plutôt absurde.

Comme décrit par Peter R. Bloomfield ici , vous devez déconnecter TX et RX pour le téléchargement. De plus, vous êtes à court d’éléments pour lire les capteurs d’interactivité et devez vous assurer que la limite de courant totale n’est pas atteinte. Ne pas oublier que vous êtes limité à 5V leds si vous les conduisez directement avec votre Arduino.

L’utilisation des registres à décalage en général et du 595, décrite par Ricardo, est donc vivement recommandée.

• Ils ne coûtent pas cher!
• Il est plutôt facile de les cascade.
• Vous pouvez gagner beaucoup de vitesse en utilisant hardware-SPI.

Je les utilisais il y a quelque temps lorsque j'ai réalisé la partie de Kawaii me concernant la soudure et la programmation (le texte du lien est en allemand) de l'artiste upcycling Dominik Jais .

Ici, seuls 595 pilotes ont été utilisés pour piloter un affichage de 8x11 leds. Étant donné que les voyants ont été découpés dans une bande de voyants SMD 12V, une alimentation supplémentaire et des baies UDN2803A Darlington, raccordées aux broches de sortie des registres à décalage, étaient nécessaires.

D'autres méthodes générales incluent l'utilisation d'extendeurs de ports PCF8574 (A) 8 bits, contrôlés via le bus I2C.

Quoi qu'il en soit, je commencerais par essayer les registres à décalage 595.

Si vous avez besoin de contrôler quelques voyants RVB, vous pouvez rechercher des solutions plus spécialisées. Certaines LED RVB sont livrées avec leur propre WS2812 . Ces pièces fines peuvent être mises en cascade (bus à 1 fil) et sont adressées via leur position dans la chaîne.

S'il ne s'agit que de LED, qu'en est-il des bandes de LED WS2812B ou uniquement des puces de pilote? Vous pouvez contrôler un nombre pratiquement illimité de LED en utilisant une seule broche!

Bien que les gens s’y habituent en bandes, ils sont disponibles sous forme de DEL autonomes (connues sous le nom de néo pixels sur Adafruit). Ou, si vous ne conduisez que par une seule couleur, chaque puce WS2811 peut contrôler 3 DEL en utilisant chacune des sorties RVB pour une seule DEL.

Je viens de créer un projet qui utilise 5 LED: Porte1 ouverte / fermée, Porte2 ouverte / fermée, moteur1 actif, moteur2 actif et alimentation. Les voyants "actifs" ont un double objectif car j'ai le rouge comme entrée du moteur actif et le vert indiquant le statut actif à l'intérieur de l'Arduino.

Avec 1 broche et la bibliothèque installée, vous pouvez contrôler un nombre illimité de DEL

Je ne réclame pas cette méthode pour moi-même, mais j’ai trouvé cette astuce intéressante sur la page Web MUX-DEMUX: Trucs pour le salon CD4051

Quelle que soit la méthode que vous choisissez pour piloter les sorties ou pour lire les entrées (registres à décalage, multiplexeurs ou utilisation directe directe des broches Arduino elles-mêmes), vous pouvez DOUBLER le nombre de sorties ou d’entrées par une utilisation intelligente de paires de circuits parallèles (pour former un circuit double). entrée ou de sortie banque ), en utilisant des diodes en sens opposées sur chaque branche parallèle, et la commutation des entrées / sorties à haute et basse.

Pour illustrer la méthode des sorties (les LED dans ce cas, notez que les diodes supplémentaires ne sont pas nécessaires):

Si vous considérez la paire de voyants dans cet exemple comme une "banque" et que vous souhaitez allumer le voyant LED_0, vous devez définir le code PIN 17 sur HIGH et le code PIN 18 sur LOW. (Les numéros de broche sont déroutants, mais ils correspondent à l'exemple ultérieur si nu avec moi). Pour allumer LED_1, il suffit d'inverser les NIP. La nature des diodes des LED empêche le courant de circuler dans la direction opposée tout en maintenant l’autre hors tension.

Pour illustrer la méthode des entrées (les CdS dans ce cas, notez que les diodes supplémentaires sont nécessaires):

Cela devient un peu plus compliqué si vous souhaitez effectuer une lecture analogique sur un capteur de lumière CdS. Tout d'abord, vous devez ajouter une diode à chaque capteur pour contrôler le flux. Deuxièmement, puisque vous lisez des valeurs, vous devez tirer les entrées haut ou bas pour les empêcher de flotter. Étant une personne paresseuse, je vais les tirer haut en utilisant les résistances internes. Pour lire CdS_0, définissez le mode PIN 17 sur OUTPUT et réglez-le sur BAS. Cela en fait le terrain. Ensuite, vous définissez le mode PIN 18 sur INPUT et réglez-le sur HIGH pour activer la résistance de rappel. Vous êtes maintenant prêt à lire le code PIN 18 (également appelé broche analogique 4). Pour accéder à l'autre capteur, il suffit de changer les modes et les sorties.

Ainsi, si vous avez un multiplexeur CD4051 à 8 ports, en utilisant 5 broches sur l’Arduino (au lieu de 3), vous pouvez obtenir 16 entrées ou sorties, ou un mélange des deux.

De même, si vous avez un multiplexeur 4067 à 16 ports, vous pouvez obtenir 32 entrées ou sorties, ou une combinaison des deux.

Un exemple d'esquisse serait:

/*
 * Example of getting 16 i/o from 5 pins using a CD4051
 *
 * Based on tutorial and code by david c. and tomek n.* for k3 / malmö högskola
 * http://www.arduino.cc/playground/Learning/4051?action=sourceblock&ref=1
 */ 


int selPin[] = { 14, 15, 16 }; // select pins on 4051 (analog A0, A1, A2)
int commonPin[] = { 17, 18};   // common in/out pins (analog A3, A4)
int led[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW };  // stores eight LED states
int CdSVal[] = { 0, 0, 0, 0 }; // store last CdS readings
int cnt = 0;  // main loop counter
int persistDelay = 100; // LED ontime in microseconds


void setup(){
  Serial.begin(9600);  // serial comms for troubleshooting (always)
  for(int pin = 0; pin < 3; pin++){ // setup select pins
    pinMode(selPin[pin], OUTPUT);
  } 
}


void loop(){
  flashLEDs();
  if (cnt == 0){
    for(int x; x < 8; x++){
      led[x] = random(2);
    }
  }
  cnt++;
  if (cnt > 100) { cnt = 0; }
}


void flashLEDs() {
  for(int pin = 0; pin < 2; pin++) {  // set common pins low
    pinMode(commonPin[pin], OUTPUT);
    digitalWrite(commonPin[pin], LOW);
  } 
  for (int bank = 0; bank < 4; bank++) {
    for(int pin = 0; pin < 3; pin++) { // parse out select pin bits
      int signal = (bank >> pin) & 1;  // shift  & bitwise compare
      digitalWrite(selPin[pin], signal);
    }
    if (led[bank * 2]){        // first LED
      digitalWrite(commonPin[0], HIGH);  // turn common on
      delayMicroseconds(persistDelay);   // leave led lit
      digitalWrite(commonPin[0], LOW);   // turn common off
    } 
    if (led[bank * 2 + 1]){     // repeat for second LED
      digitalWrite(commonPin[1], HIGH);
      delayMicroseconds(persistDelay);
      digitalWrite(commonPin[1], LOW); 
    }
  } 
}

Comme je l'ai dit dans la première ligne, l'explication complète se trouve sur MUX-DEMUX: Les astuces de salon CD4051

Pour un projet de classe, j'ai utilisé un CD4024 et deux broches Arduino pour piloter un affichage à 7 segments.

Il y a quelques mises en garde à cette approche. Par exemple, écrire une highvaleur sur la première sortie d’un compteur d’ondes n’a besoin que de faire resetbasculer la broche d’horloge deux fois. Mais si vous voulez écrire highsur toutes les n broches, vous devez activer la broche 2 ⁿ fois et pendant ce temps, toutes les autres broches sont constamment activées et désactivées.

Si votre application peut gérer ces limitations et que les broches sont courtes, c'est une autre option.

Réponse en prime: il y a beaucoup d'exemples d'entrées de multiplexage ici , dont beaucoup s'appliquent également aux sorties de multiplexage.

Avec un peu de travail (installation d'un chargeur de démarrage différent), sept lignes d'E / S supplémentaires sont disponibles sur Uno, sur les en-têtes ICSP1 et JP2. Le chargeur de démarrage de remplacement s'appelle HoodLoader2 . Il vous permet d'installer des esquisses sur Atmega328 et Atmega16U2 sous Uno. Traiter avec plusieurs processeurs serait la principale complication de l’utilisation de cette méthode.

Sur un Uno, les en-têtes ICSP1 et JP2 se connectent aux broches PB1 ... PB7 de l’Atmega16U2. De plus, l’Atmega16U2 a environ 9 broches d’E / S sans connexion à la carte de circuit imprimé. Une personne travaillant sous un microscope pourrait peut-être connecter des fils à un total de 18 broches d'E / S sur le 16U2, tout en laissant trois autres broches d'E / S attachées à leurs connexions ordinaires.

HoodLoader2 fonctionne également sur les cartes Mega.

Il y a une foule de bonnes réponses ici, mais si vous perdiez votre temps, vous auriez trouvé moins cher d'acheter un Mega.

Mon 3/2-d vaut la peine.