vendredi 13 octobre 2017

Mise à jour du minuteur LED

Cette année, les membres de la commission règlement ne nous ont pas gâtés pour la ré-utilisation du minuteur. Certes j'en ai fait partie, mais je n'avais pas vu cet effet de bord.

Alors pour remédier à cet oubli, voici une petite mise à jour de la fabrication du minuteur LED (voir un-minuteur-base-led-multicolores.html).

Compte tenu du fait que le temps de match passe de 90s à 100s, il faut rajouter quelques LED.
La solution idéale consisterait à rajouter un digit complet devant les deux existants. On pourrait alors aller jusqu'à 999s de match (ou de tout ce qu'on veut chronométrer d'ailleurs).
Dans le but de réduire le budget et de se limiter au strict nécessaire, j'ai décidé d'opter pour le rajout d'un "1" supplémentaire. On gagne ainsi 20 LED, mais on se limite à 199s (ce qui est déjà pas mal)
 

Tout d'abord, il va falloir revoir un peu la dimension de la planche pour y intégrer ce nouveau chiffre. Mais on peut aussi opter pour un resserrage des LED existantes et conserver la taille de panneau... c'est au choix.

Le matériel reste sinon le même, à 8 LED près. Le schéma électronique avec l'Arduino, le déclencheur et le bandeau de LED reste identique.
En revanche, le schéma des LED est différent. Le 1 est inséré devant les 2 autres digit (c'est un choix personnel, on aurait pu le câbler après...)

Il faut ensuite modifier le code pour prendre en compte les valeurs entre 91 et 100 qui n'étaient pas prévu dans le programme initial.
J'en ai profité pour rajouter des définitions de couleurs, des changements de couleur vers la fin du match et pendant la funny action (même s'il n'y en a pas cette année, on conserve cette possibilité)


// Mise à jour pour prise en comte du passage à 100s
// suppression du temps de funny action
// coupe 2018 : Robot Cities
#include <Adafruit_NeoPixel.h>

//#define FUNNY_ACTION
// Which pin on the Arduino is connected to the NeoPixels?
#define PIN_PIXELS            6

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      64
// how many pixels per branch of the digits
#define NUM_PIX_PER_BRANCH  4

#define VAL_INIT  100
// the pin for launching counter
#define PIN_LAUNCH        7
// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN_PIXELS, NEO_GRB + NEO_KHZ800);
// colors defined for lignhtened (or not) pixels

uint32_t coul_on = pixels.Color(200, 200, 200);
uint32_t coul_red = pixels.Color(200, 0, 0);
uint32_t coul_off = pixels.Color(0, 0, 0);
uint32_t coul_blu = pixels.Color(0, 0, 200);
uint32_t coul_hi = pixels.Color(0, 0, 255);
uint32_t coul_green = pixels.Color(0,150,0);

int chiffres[10] = {0x77, 0x44, 0x3E, 0x6E, 0x4D, 0x6B, 0x7B, 0x46, 0x7F, 0x6F};

int go_counter = 1;
int val_counter = VAL_INIT; // number of seconds
void setup() {
  // put your setup code here, to run once:
  pixels.begin(); // This initializes the NeoPixel library.
  pinMode(PIN_LAUNCH, INPUT_PULLUP); // input is set as pullup to avoid having three wires
  Affiche(VAL_INIT, coul_green); // before start
  // set the data rate for the SoftwareSerial port

}

void loop() {
  // put your main code here, to run repeatedly:
      
  if (digitalRead(PIN_LAUNCH) == LOW)  // button pressed
    go_counter = 1; // used as a RSFlipFlop
  if (digitalRead(PIN_LAUNCH) == HIGH) // button released
    go_counter = 0; // if stable switch
     
    if (go_counter == 0)
      Affiche(VAL_INIT, coul_green);
    else if (val_counter > 5)
      Affiche(val_counter, coul_on); // showing the number
    else if (val_counter > 0)
      Affiche(val_counter, coul_blu); // last 5 secondes in blue
#ifdef FUNNY_ACTION
    else if (val_counter > -5)
      Affiche(0, coul_red); // during funny action
#endif
    else
      Affiche(0, coul_on); // after funny action, everything is off
  if (go_counter)
  {
    val_counter--; // minus 1s
    delay(1000);// if no RTC, the delay must be calibrated to keep real timing
  }
  else
    val_counter = VAL_INIT;
}

void Affiche(int number, uint32_t color )
{
  uint32_t col; //color, on or off
  byte n_diz = (number / 10)%10;
  byte n_uni = number % 10;
  
  if (number > 199)
    return; // no lighting over 99
  else
  {
    // the first "1"
    if (number >99) // "1" has to be lightened
    {  
      for (int h = 0; h < 8; h++)
        pixels.setPixelColor(h, color);
    }
    else
    {  
      for (int h = 0; h < 8; h++)
        pixels.setPixelColor(h, coul_off);
    }
    
    for (int i = 0; i < 7; i++) // each digit
    {
      // first dozens
      if ((1 << i) & chiffres[n_diz])
        col = color;
      else
        col = coul_off;
      // if number is between 1 and 9, nothing is lightened for dozens
      if (number < 10 && number >0)
        col = coul_off;
      for (int j = 0; j < NUM_PIX_PER_BRANCH; j++)
      {
        pixels.setPixelColor(i * NUM_PIX_PER_BRANCH + j+8, col);
      }
      // then units
      if ((1 << i) & chiffres[n_uni])
        col = color;
      else
        col = coul_off;
        
      for (int j = 0; j < NUM_PIX_PER_BRANCH; j++)
      {
        pixels.setPixelColor(7 * NUM_PIX_PER_BRANCH + i * NUM_PIX_PER_BRANCH + j+8, col);
      }
    }
  }
  pixels.show();
}


Et après ça, ça devrait le faire 😃

samedi 29 avril 2017

Coupe de Belgique 2017 : Un Namur de compétition

Comme chaque année depuis Préhistobot, Brickstory est parti en terre Wallonne pour à la fois affronter les équipes belges, mais aussi pour se préparer à la coupe de France qui  se tient quelques semaines plus tard.

Après Mons et Louvain-La-Neuve, c'est cette fois à Namur que se tient la rencontre. Au menu, 21 équipes dont la moitié belges, l'autre moitié étant composée d'une équipe allemande (RCA) d'une équipe suisse (CVRA) et d'équipes françaises.

En arrivant le samedi matin sur les lieu, l'Amphi Pedro Arrupe de l'Unversité de Namur, les équipes s'installent dans ce qui ressemble à un couloir et tout le monde s'affaire à préparer, réparer, finir de concevoir les robots. Un coup d’œil sur les tables de jeu nous montre plusieurs choses :
  • Les fusées ne sont pas ouvertes sur toute la longueur
  • Les cratères sont délimités par des petits tasseaux non chanfreinés
  • La peinture des modules est granuleuse (pas faite au pistolet ou à la bombe) et surtout les bords des modules sont peints
  • Il y a un écart de 5mm entre la partie jaune et la partie bleu, du fait de l'impression du terrain sur le vinyle
  • La bascule n'est pas biseauté, il subsiste une marche de 2mm à franchir

Nous passons à l'étape d'homologation qui se déroule plutôt bien. En statique aucun souci, et pour l'étape dynamique nous avions prévu un  programme simple où les deux robots faisaient juste des séquence avance-recule permettant de vérifier l'évitement, et la funny action pour marquer des points. Comme d'habitude, on a quelques remarques sur la détection dans les coins, mais ça passe. De toute façon personne ne craint rien avec nos Lego 😉

17 équipes homologuées sur 21 présentes, une 18è passera cette étape pour les matches de dimanche.

Premier match contre Coffee Machine. Equipe que l'on connait bien, qui était même homologable quelques heures seulement après la parution du règlement en septembre dernier. Cette année, en plus de leur machine à café traditionnelle, ils sont venus avec un robot secondaire, statique, basé sur un grille pain. Ce grille pain a une unique fonction : envoyer un toast en forme de fusée en guise de funny action... Juste génial. Notre match le fût un peu moins, le petit robot n'a pas démarré, et le câble d'alimentation des actionneurs secondaires s'est sectionné lors de la phase de préparation. Le gros robot part quand même mais le câble repositionné bloque la funny action. 21 malheureux points.

Deuxième match contre les Space Monsters, équipe belge qui a deux robots assez costauds, mais qui ne semblent pas encore au point à ce stade de la compétition. Les nôtres non plus d'ailleurs puisque notre petit robot soulève étrangement ses deux codeurs sur la bascule et ne les redescend pas. Il va donc droit dans la zone de départ adverse, alors que notre adversaire usine tranquillement le vinyle, obligeant les arbitres à appuyer sur le bouton d'arrêt d'urgence. Notre gros robot fait quand même quelques points, 61 au total, et nous arrivons en tête du classement général.

Toute la première journée ici : https://youtu.be/wXq3mWg_XBY

Après une soirée de codage, mais aussi de repos avec une visite au casino de Namur, nous retournons le lendemain à l'université pour les 3 derniers matches de qualification.

Troisième match contre Oddity. le petit robot passe bien la bascule, mais il est décalé et n'arriva pas à prendre le moindre module de la fusée. Le gros robot ne peut pas manipuler correctement les modules sur la table, surement à cause de la couleur jaune, car en bleu ça passait bien. Par miracle on ramène 4 minerais et un module dans la zone de départ, ce qui donne 45 points avec la funny action. On reste en tête du classement.

Quatrième match, les réglages sont modifiés, mais on tombe encore sur du jaune contre le FSE Colbert. Le petit robot arrive cette fois à récolter deux modules qu'il dépose dans la zone de départ. Le gros cafouille lors de la dépose des modules polychromes, en donnant même un module à l'adversaire. En revanche les deux modules monochromes sont récupérés et déposés devant la basse latérale avant d'être poussés à l'intérieur de celle ci. Big Applause, ça fait plaisir :-)
Toutefois, petite négociation avec l'arbitre car à la fin, notre cerceau n'est pas relevé et les balles sont prisonnières du robot. On est d'accord là dessus, mais pour être sûrs on déplace le robot dans le sens de marche. Le robot touche alors un module qui était sur le côté du robot, et le chef arbitre nous dit que puisque le module a bougé, il était contrôlé par le robot et donc ne compte pas !!! En général on laisse les arbitres décider et on accepte tout, mais là, on a trouvé ça étrange. Après négociation, on a les deux points, mais c'est un point qu'il faudra remonter car c'est clairement une source d'embrouille.
61 points et on on garde la première place.

Cinquième et dernier match contre Moona Lisa. On est bleu, enfin, et tout se passe beaucoup mieux. Les modules sont déposés dans la base à 45° (malgré un cadeau à l'adversaire encore), un dans la base latérale, 3 dans la zone de départ et quelques balles. Résultat 77 points, et en route pour les finales.

A ce moment de la compétition, on sépare les belges et les étrangers, et on se retrouve dans les demi finales étrangères avec Coffee Machine, RCA et PM-Robotix. Contre Coffee Machine, le match se déroule à peu près comme prévu (en jaune encore) et on retrouve RCA en finale

Toujours en jaune (décidément, il va falloir faire un truc dans le logiciel de tirage au sort !!!), notre gros robot rate quelques modules et RCA fait un gros match, alors que notre petit robot s'arrête en pleine action. On découvrira plus tard que la batterie s'est déconnectée !!!

RCA sera battu par les Space Monsters dans la finale des finales, deux équipes qu'on reverra à coup sûr à Eurobot (enfin on y sera spectateurs, on est trop vieux !!!)

Toute la deuxième journée ici :https://youtu.be/vf1suGyozco

On revient comme à chaque fois avec une liste de choses à faire pour améliorer les robots en vue de la Coupe de France, et plein de bons souvenirs.

Un gros merci
- Au Pass, Robotix's et l'Universite de Namur pour l'organisation, l'accueil
 -A Étienne pour les commentaires pendant et entre les matches
- A l'ensemble des bénévoles avec qui on a pu échanger et rigoler
- A Coffee Machine pour leurs idées et leur coup de main pour la réparation de nos connecteurs
- A PM-Robotix pour les échanges, la bonne humeur
-A ESEO pour leur équipe travailleuse qui n'a pas eu la chance de marquer beaucoup de points malgré un robot très beau mécaniquement.
- A toutes les autres équipes belges, françaises et autres qui ont fait de cet événement un moment dont on se souviendra.

On sera là l'année prochaine à Namur, en espérant qu'il y ait du wifi stable dans la salle ;-)


mardi 21 février 2017

Finale régionale IDF des Trophées de robotique

Samedi 18 février, finale régionale des Trophées. Notre équipe historique, les Têtes Briquées est scindée en deux : le noyau restant forme les têtes Briquées, toujours avec des robots en Lego, et les autres (et des nouveaux) ont fondé l'équipe des Têtes Fabriquées à base de tout sauf Lego (enfin... presque).

Côté Têtes Briquées, on a gardé l'expérience de la mécanique Lego, mais tout a été refait de zéro. Pour augmenter le challenge, la télécommande a été refaite, cette fois à base d'Arduino, et plus de brique EV3.

Autant dire qu'avec une date de rencontre si tôt dans l'année, des effectifs réduits, la découverte de l'Arduino, c'était loin d'être gagné pour conserver le titre acquis l'an dernier.

La veille de la rencontre, les deux robots sont fonctionnels, la télécommande aussi, mais il n'ont pas réussi à trouver du temps pour s'entraîner.



Petit robot, statique, pour la funny action

Télécommande à base de 2 Arduino UNO

Robot principal, qui gère les modules et les balles


L'homologation est passée rapidement, mais on voit que la maîtrise du robot n'est pas encore là.



Le premier match contre E.T. se déroule dans les mêmes conditions, avec Lucas aux commandes. Victoire avec une score moyen de 49 points qui nous place malgré tout en 5ème position.


On se rend compte alors :
- Que le robot n'est pas si simple à piloter, et qu'il faut mieux gérer les différents actionneurs
- Les minerais sont très mobiles et qu'il est illusoire de vouloir les pousser simplement dans la zone de départ
- Qu'il y a un énorme écart entre les grosses équipes (Destroyer, etc..) et la grande partie des équipes qui placent un module à tout casser
- Qu'il va falloir s'entraîner pour espérer faire un bon résultat.

Second match contre Ice Robot, Antoine pilote, et résultat similaire. Viser la base centrale n'est pas aisé, les modules sont difficiles à extraire des fusées. Encore une victoire avec un score de


Troisième match contre GOMM avec Lucie aux commandes. Un score de 47 points nous assure une place en 1/4 de finale


La qualification en finale nationale étant acquise, les jeunes se rendent compte qu'il va falloir faire mieux en 1/4 de finale. Lucas prend les choses en main, se souvient de ses nombreuses parties de jeu sur console, s'approprie mieux la télécommande et se lance dans un entraînement  digne d'un sportif de haut niveau (toutes proportions gardées)

Et le travail paye. Il maîtrise mieux le robot, que ce soit la prise de modules, le retournement, et le largage dans les bases.  Le 1/4 de finale est remporté face aux Rob Hot Cugnot :



La 1/2 finale va être un peu plus difficile face à l'équipe qui domine largement la journée, les Destroyor.

Ils remporte facilement le match et nous accédons à la petite finale contre les Génies de Gif


Victoire dans cette petite finale qui nous permet de monter sur le podium.

Les Têtes Briquées repartent de là avec une petite coupe de bronze, un certificat de 3ème place, plein de souvenirs, d'enseignement, et une envie de tout déchirer à St Quentin les 1er et 2 avril prochain







Quelques petits retour positifs sur la journée :

  • Superbe organisation de la part de Planète Sciences, 
  • Le lieu de la ferme du Manet est toujours aussi grandiose
  • Les matches se déroulent très bien, avec des équipes très sympa, des encadrants géniaux et du Fair Play partout
  • Le règlement permet rapidement de savoir qui gagne un match, c'est plutôt cool
  • L'animation toujours au top 
  • Anges gardien, arbitres et autres bénévoles aussi.
Quelques légers bémols :
  • Manque de communication sur les classements à la fin de chaque série. Il faut être dans la salle au bon moment, et ça pas toujours simple avec une petite équipe
  • Les minerais ne sont pas stables du tout. C'est lié au règlement, mais du coup peu d'équipes ont cherché à les récolter
  • c'est un peu tôt dans l'année, et pendant les vacances. Pas la faute de Planète Sciences, mais c'est juste dommage.

vendredi 6 janvier 2017

Un minuteur à base LED multicolores

Nouveau projet annexe, réaliser un minuteur, ou un décompte assez gros pour être visible depuis les gradins lors des compétitions de robotique.

Bien sûr, il ne faut pas que ça coute trop cher, que ce soit ludique et pédagogique, donc DIY à fond.

J'ai commandé :
- un bandeau de LED WS2812 (sur AliExpress) en non-étanche (normalement c'est fini les bêtises avec les poissons à pêcher) avec une densité de 30 LED/m sur fond noir
- Un Arduino Uno (enfin l'équivalent  sinisé)
- une planche de bois format A3 (environ)
- une capa 100 uF- une alimentation stable 5V 4A

Et mes outils préférés :
- un fer à souder + étain
- crayon gomme équerre
- fil monobrin

Je suis parti d'un tuto en ligne assez bien fait, même s'il est dans la langue de Goethe : https://www.youtube.com/watch?v=UVISnxXh_VY

Et d'un autre qui m'a donné l'idée des gros chiffres : https://www.youtube.com/watch?v=LojGHyBFE8Q
 
Ouverture du colis

Premier test rapide du bandeau de LED, sans utiliser la protection de la capa. J'ai pour ça découpé mon bandeau pour ne garder que 4 LED.

Sur l'IDE Arduino, il suffit de télécharger la librairie NeoPixel d'Adafruit et de tester le programme de base "sample". Le bandeau de LED sera branché comme suit :
- le fil rouge sur le bouton rouge... euh.. sur le 5V
- le fil blanc sur la masse
- le fil vert sur D6


La prise en main est super rapide, il y a deux paramètres à régler dans le programme, la pin utilisée (j'ai gardé la D6) et le nombre de LED, que j'ai changé pour mettre 4


// Which pin on the Arduino is connected to the NeoPixels?
#define PIN            6
// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      4

Ensuite, l'allumage d'une LED se fait en utilisant la méthode setPixelColor(numéro de LED, couleur), puis la méthode show() de la classe AdaFruit_NeoPixel

pixels.setPixelColor(num, pixels.Color(0,150,0));
pixels.show();

La méthode Color() prend 3 paramètres, la valeur de rouge (0->255), de vert (0->255) et de bleu (0->255). Pour éteindre la LED, il faudra donc lui imposer Color(0,0,0) et faire un show()

Je me suis même amusé à faire un programme de couleur aléatoire sur les 4 LED avec un délai de 200ms entre chaque... Un peu psychédélique, mais ça le fait :-)



Revenons donc au minuteur.

Le principe électronique sera le suivant (excusez l'utilisation de powerpoint comme logiciel de conception électronique, mais chez nous on fait plutôt du Lego)
On part sur deux chiffres car le décompte sera de 90s.

Chaque chiffre en vert correspond à un digit (une bande de 4 LED) dans l'ordre vu par l'arduino, chaque chiffre en noir correspond au numéro de la LED à allumer.
Le GO sera le lanceur du minuteur, donc un simple bouton poussoir

On voit qu'on a 56 LED qui consomme chacune jusqu'à 60mA (allumage à fond), donc il faut une alimentation pouvant générer 56x60 = 3360 mA + conso de l'Arduino, donc 4A pour être large.

Ceci étant défini, il faut tracer le schéma sur la planche en bois. Chaque chiffre fera environ 15x30cm, ce qui devrait être suffisant pour être vu d'assez loin

Dessin sur la planche
 Ne regardez pas les traces de gras sur la planche, je devais revenir du Mc Do :-). De toute façon, la planche sera recouverte de noir pour mieux faire ressortir les couleurs des LED
 




Le même avec l'échelle des distances


Ensuite, il y a une opération de collage des bandeaux de 4 LED. Il faut juste être vigilent de bien respecter le sens les flèches sur les  LED. En effet, le protocole unifilaire est le suivant :

  • Une trame contenant toutes les infos est envoyée par l'Arduino sur le fil.
  • Chaque LED (enfin c'est pas la LED mais la pupuce WS2812) contient une entrée pour recevoir les data (DIN) et une sortie pour les envoyer (DOUT)
  • La première LED reçoit la trame, prend le premier bloc de couleur et renvoie le reste de la trame à la LED suivante.
  • On continue jusqu'au bout de la trame.

Chaque bandeau de 4 LED doit ensuite lié au suivant :
La masse sur la masse
Le +5V sur le +5V
Le DOUT de la dernière LED sur le DIN de la sauivante

Pour relier, j'ai opté pour du câble monobrin, ce qui permet d'éviter les petits brins qui causeraient avec le point de soudure à côté... et qui mettrait le brun. En plus c'est bien plus simple à dénuder et   découper

Voilà le résultat en vidéo du montage :


Ensuite le programme Arduino

J'ai défini 3 couleurs.
coul_on : du blanc pas trop puissant pour pouvoir garder juste l'Arduino pour alim
coul_red : un rouge pour la fin du compteur
coul_off : pour éteindre les LED

La pin 7 permet de lancer le compteur lorsqu'il est mis à la masse (le bouton du chrono quoi!)

Les chiffres sont allumés en blanc, le 0 en rouge pendant 5 secondes, puis tout est éteint.

La fonction Affiche(num, coul) porte bien son nom... elle allume les LED avec la couleur souhaitée pour former le nombre souhaité.

Chaque chiffre est décrit par sa correspondance binaire (dans l'ordre des digits) dans le tableau chiffres[], cela permet d'optimiser un peu le code. Les bits 1 sont allumés à la couleur voulue et les autres à coul_off (donc éteints)

#include <Adafruit_NeoPixel.h>

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN_PIXELS            6

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      56
// how many pixels per branch of the digits
#define NUM_PIX_PER_BRANCH  4

// the pin for launching counter
#define PIN_LAUNCH        7
// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN_PIXELS, NEO_GRB + NEO_KHZ800);
// colors defined for lignhtened (or not) pixels

uint32_t coul_on = pixels.Color(30,30,30);
uint32_t coul_red = pixels.Color(30,0,0);
uint32_t coul_off = pixels.Color(0,0,0);

int chiffres[10] = {0x77,0x44,0x3E,0x6E,0x4D,0x6B,0x7B,0x46,0x7F,0x6F};

int go_counter=0;
int val_counter = 90; // number of seconds
void setup() {
  // put your setup code here, to run once:
  pixels.begin(); // This initializes the NeoPixel library.
  pinMode(PIN_LAUNCH,INPUT_PULLUP); // input is set as pullup to avoid having three wires
  Affiche(0,coul_off); // turn off the leds
}

void loop() {
  // put your main code here, to run repeatedly:
  if (digitalRead(PIN_LAUNCH)== LOW) // button pressed
    go_counter = 1; // used as a RSFlipFlop
  if (go_counter)
  {
    if (val_counter > 0)
      Affiche(val_counter,coul_on); // showing the number
    else if (val_counter > -5)
      Affiche(0,coul_red); // during funny action
    else
      Affiche(0,coul_off); // after funny action, everything is off

    val_counter--; // minus 1s
    delay(1000);// if no RTC, the delay must be calibrated to keep real timing
  }
}

void Affiche(int number,uint32_t color )
{
  uint32_t col; //color, on or off
  if (number > 99)
    return; // no lighting over 99
  byte n_diz = number/10;
  byte n_uni = number % 10;
  for (int i=0;i<7;i++) // each digit
  {
    // first dozens
    if ((1<<i) & chiffres[n_diz])
      col = color;
    else
      col = coul_off;
    for (int j=0;j<NUM_PIX_PER_BRANCH;j++)
    {
      pixels.setPixelColor(i*NUM_PIX_PER_BRANCH+j,col);
    }
    // then units
    if ((1<<i) & chiffres[n_uni])
      col = color;
    else
      col = coul_off;
    for (int j=0;j<NUM_PIX_PER_BRANCH;j++)
    {
      pixels.setPixelColor(7*NUM_PIX_PER_BRANCH + i*NUM_PIX_PER_BRANCH+j,col);
    }
  }
  pixels.show();
  }

Le résultat en vidéo (j'ai débuté le compteur à 10s, ça suffit pour la démo)

 


C'est pris d'un peu près, donc le résultat n'est pas hyper génial sur la vidéo. En se mettant à plusieurs mètres, ça rend beaucoup mieux.

Les améliorations à apporter :
  • Rajouter le condo 100 uF pour pouvoir utiliser une alim externe et protéger les LED quand on allumera à fond
  • remplacer l'arduino Uno par un Arduino min pro, plus compact et largement suffisant.
  • Couvrir d'une plaque de plastique dépoli pour diffuser les lumières des LED
  • peindre le fond en noir pour mieux faire ressortir les lumières 
  • Calibrer la valeur du Delay pour avoir 90s exactement
  • Rajouter un câble long pour lancer le minuteur à distance (comme l'arbitre le fera).
N'hésitez pas à copier, modifier, améliorer...