Archives de catégorie : Arduino

L’afficheur A LEDs

Tout flipper qui se respecte a son afficheur de score. Et aujourd’hui, on utilise des afficheurs à matrice de LEDs (dot matrix). Ca tombe bien, j’en avais un petit d’avance :

L’afficheur LCD

Il s’agit d’un assemblage de 4 modules à LEDs déjà tout prêt et accessible en SPI. A terme, j’aimerais en avoir 4 autres. Pour le manipuler, on va le connecter sur l’Arduino :

  • VCC au +5V de l’Arduino,
  • GND au neutre,
  • CLK à une broche “clock”
  • DIN (ou MOSI) à une broche “données”
  • CS à une broche de sélection de l’esclave SPI avec lequel le maître souhaite discuter.

Il ne s’agit pas d’I2C, donc pas besoin a priori d’utiliser des broches spécifiques.

Pour coder l’affichage, j’ai utilisé MD_MAX72xx qui est téléchargeable dans la liste des bibliothèques d’Arduino. Elle permet de manipuler mon afficheur en ayant déjà prévu un jeu de caractères en matrice de points. Du coup, le code se limite à ceci :

1. L’initialisation du module en indiquant les pins utilisées et le nombre d’écrans connectés (ici 4).

MD_MAX72XX mx = MD_MAX72XX(DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);
...
mx.begin();

2. L’affichage de texte.

printText(0, MAX_DEVICES-1, "Salut !");

“printText” n’est pas disponible par défaut, mais vous avez un exemple sur le GitHub du projet.

Et voilà !

Vous pouvez intégrer des animations (scrolling, variation d’intensité), mais attention à ce qu’elles ne bloquent pas la boucle le temps qu’elles s’exécutent. Ce serait dommage de ne pas pouvoir lever un flipper parce qu’un texte scrolle. Il existe des bibliothèques comme “VariableTimedAction” qui sont censées permettre un simili multi-thread. J’ai testé rapidement, mais ça me semblait sortir l’artillerie lourde pour pas grand chose.

Vu qu’AliExpress fonctionne de nouveau, j’ai commandé un autre lot de 4 écrans. 8 est la maximum que commande la bibliothèque et ça permettra d’avoir un affichage lisible.

Arduino Due

Pour avoir un maximum d’I/O disponibles, j’ai acheté un clone d’Arduino Due qui remplacera mon Uno. Dans cet article, je vais conserver quelques notes utiles sur le Due.

Configuration de l’IDE Arduino

Dans votre IDE Arduino, allez dans Outils > Type de carte > Gestionnaire de carte, puis tapez “Due”. Sélectionnez ensuite “Arduino SAM Boards” et installez la dernière version (la 1.6.12 au moment où j’écris ces lignes).

Points d’attention quand vous développerez avec votre Due :

  • Le Due fonctionne en 3.3 V et non 5V comme le Uno. il accepte cependant le même chargeur standard que le Uno (7 à 12 V).
  • Il dispose aussi d’une sortie 5 V sur ses pins.
  • CURA peut occuper vos ports COM (USB). Fermez le avant de programmer un Arduino sous peine d’avoir un “accès refusé” au port sinon.

Pour tester votre carte, utilisez un code d’exemple. Par exemple “Blink”, qui fera clignoter la diode orange du Due.

Et voilà, notre remplaçant est prêt à… remplacer le Uno !

Contrôle des flippers avec l’Arduino

Hello tout le monde ! Je m’attaque aujourd’hui à mon premier test de l’Arduino. Je l’ai déjà manipulé pour des projets persos, mais j’avais alors très peu d’électronique “brute”. Donc mon challenge là tout de suite, c’est de bien comprendre ce que je vais faire et de ne rien cramer ! Je sais, c’est ambitieux. Et au delà de ça, c’est de voir aussi si mon circuit est suffisamment réactif : l’appui sur le bouton d’un flipper doit déclencher immédiatement l’alimentation du solénoïde et la levée du flipper. Allez, je me lance.

Modélisation du circuit

Pour monter ma configuration, je suis basé sur un tuto du site Arduino Transistor Motor Control, quelques vidéos que vous verrez plus bas ainsi que le simulateur de circuit TinkerCad.

Vous remarquerez que sur la maquette, faute de trouver mieux, l’alimentation PC de 12V est remplacée par une pile 9 V et le solénoïde par un moteur. Voici le résultat :

Schéma d’alimentation d’un moteur

Une alimentation externe indispensable

Mais d’ailleurs, pourquoi une pile 9V en plus de l’alimentation de l’Arduino ? Et bien parce que les plus gros solénoïdes vont consommer 12 V / 8 A en pointe et qu’un Arduino est totalement incapable de fournir une telle puissance. J’aurais donc deux circuits avec des tensions différentes.

Un transistor pour faire le “pont”

Je vais utiliser un transistor TIP 120 qui va me permettre de manipuler le courant de l’alimentation PC (il supporte 5 A en continue et 8 A en pointe). Ici, l’Arduino envoie un courant sur sa pin 9 lorsque l’on presse le bouton, ce qui permet de laisser passer le courant vers le solénoïde.

De gauche à droite: la base, le collecteur et l’émetteur.

La planche à pain

Je vais faire mes tests sur une breadboard (une planche de maquettage) sur laquelle :

  • les trous des lignes + sont connectés ensemble, idem pour les -,
  • les trous des colonnes sont connectés ensemble.

Et oui, je pars de loin. ^^

Simuler un bouton de flipper

Je vais connecter un bouton à l’Arduino. Je tire donc deux fils de l’alimentation 5 V de l’Arduino pour alimenter mon “breadboard”, puis j’alimente le bouton. Je relie aussi la pin “digital” 2 de l’Arduino à ce circuit qui regardera si un courant passe. Lorsque ce sera le cas, l’Arduino alimentera le moteur.

Deux choses importantes à noter sur ce bouton :

1. la présence d’une résistance qui est là pour éviter un court-circuit. Un circuit fermé sans aucune résistance va tout simplement brûler.

2. l’emplacement de la connexion de la pin 2 de l’Arduino sur la board n’est pas anodine. Je vous invite à regarder cette vidéo explicative :

Programmer l’Arduino

J’ai “téléversé” le code ci-dessous sur l’Arduino. En gros il dit : si le bouton est appuyé, le moteur est alimenté via le transistor et tourne.

int pinButton = 2;
int pinMotor = 9;
int valueButton = LOW;

void setup()
{
  // Init Serial
  Serial.begin(256000);
  while(!Serial); // Waiting for serial...
  Serial.println("Starting...");  
  
  // Set pin mode
  pinMode(pinButton, INPUT);
  pinMode(pinMotor, OUTPUT);
}

void loop()
{
  // Read pin 2
  valueButton = digitalRead(pinButton);

  // Write on pin 9
  if (valueButton == HIGH) {
    digitalWrite(pinMotor, HIGH);
  }
  else {
    digitalWrite(pinMotor, LOW);
  }
  
  Serial.println(valueButton); 

  delay(10);
}

Pour plus de détail, voici une vidéo expliquant comment connecter un moteur :

Le circuit en vrai

Mon circuit théorique fonctionne, on va voir maintenant ce que ça donne en vrai.

Compilation et mise à jour de l’Arduino

J’ai mis à jour l’Arduino, il n’y a plus qu’à faire les branchements :

Bon, et bien, il ne reste plus qu’à allumer l’alim de 12V et voir ce que ça donne :

Victoire partielle… Le principe fonctionne et le solénoïde me semble assez réactif. Seulement, ça ne marche pas avec le gros solénoïde de 8 A qui reste immobile, sauf si je le connecte directement à l’alimentation. Je vais creuser ça.

Un circuit final entièrement fonctionnel

Et bien voilà, j’ai vaincu la bête. J’ai finalement utilisé une planche de 4 MOSFETs que j’ai commandée chez Ali Express. Elle repose sur le même principe, mais elle a plusieurs avantages :

  1. Elle évite un bordel de fil et des soudures + joint 4 canaux.
  2. Les fils sont mieux fixés.
  3. Elle contient non pas des transistors TIP 120 qui fonctionnent avec un maximum de 8A mais des IRF 540 qui peuvent atteindre les 23 A.

Voici le nouveau montage :

Vous pouvez déjà remarquer que la breadboard ne contient plus que l’électronique nécessaire au bouton (qui ne change pas).

Sur la planche des transistors, notez à droite la connexion de :

  • la base (fil blanc)
  • l’entrée des 5 V de l’Arduino (en rouge)
  • la masse (en noir)

Et à gauche, vous avez l’interface avec le “circuit de puissance”, avec :

  • la connexion de l’alimentation 12 V en jaune et noir,
  • la sortie vers le solénoïde sur le bornier vert (les deux fils noirs).

Pour bien comprendre le schéma de câblage et comme j’ai galéré à le trouver, le voici :

Et le résultat en vidéo :

Ca c’est fait ! Youhou !
(par contre j’ai perdu mon pari en cramant un TIP120… 😉 )

Tu ne chaufferas pas !

Je pense également avoir résolu le problème de surchauffe du solénoïde. Je vais tout bêtement utiliser le PWM, la simulation de sortie analogique de l’Ardnuino. Par exemple, le code suivant fait que le flipper se lève avec force (100%) pendant 500ms, puis est à peine maintenu pendant encore 500ms (60%).

analogWrite(9, 255);
delay(500);
analogWrite(9, 150);
delay(500); 

A moins que le PWM soit connu pour endommager les solénoïdes, je vais partir là dessus.

A bientôt ! 🙂