Chargement en cours


logo fantastic modelers
loader

Maquettes et figurines S.F. et Fantastique

bouton orangebouton bleucontour bouton

Actualités

Destroyer stellaire impérial (2) :
carte Arduino sur une maquette

Carte Arduino UNO SMD utilisée pour l'éclairage d'un destroyer stellaire impérial Star Wars.

j’ai commencé il y a quelques semaines la réalisation d’un destroyer stellaire impérial Star Wars. J’ai décidé pour ce modèle de me former à l’utilisation des cartes Arduino. Les cartes Arduino permettent de charger un programme qui s’exécute automatiquement à chaque mise sous tension de la carte. Je ne vais pas détailler ici le fonctionnement complet de la carte, si ça vous intéresse, vous trouverez tout ce qu’il vous faut sur leur site. Je veux ici simplement montrer ce qu’on peut faire avec une carte Arduino sur une maquette.

Allumage des réacteurs

L’aspect le plus intéressant de l’utilisation d’une carte Arduino sur une maquette concerne l’allumage des réacteurs. La seule limite est l’imagination. On peut programmer un allumage progressif, décalé, à n’importe quelle vitesse. Là, j’ai rajouté en plus un bruit aléatoire, comme si les moteurs avaient quelques ratés au démarrage.

Allumage des thrusters de manoeuvre sur demande

Les réacteurs de manoeuvre, c’est à dire les quatre petits thrusters qui encadrent les trois réacteurs de poussés principaux peuvent s’allumer à la demande en actionnant un bouton poussoir fixé sur le socle.

Vous pouvez voir leur allumage dans la vidéo juste au dessus.

Allumage séquencé

Un effet vraiment sympa quand on éclaire une maquette consiste à allumer les différentes sections par séquence, c’est à dire pas toutes en même temps. Quand j’aurai terminé la maquette, je mettrai en ligne une vidéo de toute la séquence.

Allumage aléatoire des hublots

Sur un vaisseau de cette taille, il n’y a pas de raisons que tous les hublots soient allumés simultanément. Comme j’ai mis une carte Arduino, j’en ai profité pour coder un allumage aléatoire des hublots. A chaque fois qu’on allume la maquette, le programme sélectionne un schéma d’allumage au hasard. Ainsi, d’une fois sur l’autre ce ne sont pas les mêmes hublots qui sont allumés.

Arduino sur une maquette : allumage des hublots du destroyer stellaire impérial-deuxième schéma
Arduino sur une maquette : allumage des hublots du destroyer stellaire impérial-premier schéma

Ces deux photos montrent deux schéma d’allumage différents. Amusez-vous au jeu des différences…

Le code

Comme Arduino est open source, je reste dans l’esprit en vous donnant le code que j’ai conçu pour faire cette maquette. N’hésitez pas à me poser des questions si vous voulez l’utiliser.



void setup() {
  
Serial.begin(9600);

// réacteurs principaux
  pinMode(9,OUTPUT);
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);

// réacteurs de manoeuvre
  pinMode(5,OUTPUT);

// bouton poussoir
  pinMode(2,INPUT_PULLUP);//le poussoir est connecté entre la terre et l'entrée via une résistance pull_up de 20 kOhm interne, attention le pin est par défaut à l'état HIGH, LOW si poussoir enfoncé

//hublots
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(12,OUTPUT);

  randomSeed(analogRead(0));
  int tirage = random(0,10);//tirage d'un nombre aléatoire pour allumer les hublots suivants des schémas différents
  
  randomSeed(analogRead(0));
  int delai_1=random(100,600);

  randomSeed(analogRead(0));
  int delai_2=random(100,600);


  switch(tirage){
    case 0:
        digitalWrite(7,HIGH);
        delay(delai_1);
        digitalWrite(8,HIGH);
        delay(delai_2);
        digitalWrite(12,HIGH);
    break;

    case 1:
        digitalWrite(7,LOW);
        delay(delai_1);
        digitalWrite(8,LOW);
        delay(delai_2);
        digitalWrite(12,HIGH);
    break;

    case 2:
        digitalWrite(7,LOW);
        delay(delai_1);
        digitalWrite(8,HIGH);
        delay(delai_2);
        digitalWrite(12,LOW);
    break;

    case 3:
        digitalWrite(7,HIGH);
        delay(delai_1);
        digitalWrite(8,LOW);
        delay(delai_2);
        digitalWrite(12,LOW);
    break;

    case 4:
    case 5:
        digitalWrite(7,HIGH);
        delay(delai_1);
        digitalWrite(8,HIGH);
        delay(delai_2);
        digitalWrite(12,LOW);
    break;

    case 6:
    case 7:
        digitalWrite(7,HIGH);
        delay(delai_1);
        digitalWrite(8,LOW);
        delay(delai_2);
        digitalWrite(12,HIGH);
    break;
    
    case 8:
    case 9:
        digitalWrite(7,LOW);
        delay(delai_1);
        digitalWrite(8,HIGH);
        delay(delai_2);
        digitalWrite(12,HIGH);
    break;
  }

//éclairage hangar
  pinMode(3,OUTPUT);

  delay(2000);
  digitalWrite(3,HIGH);

//éclairage LED CMS latérales  
  
  pinMode(4,OUTPUT);

  delay(4000);
  digitalWrite(4,HIGH);
  
}

int i[14];//initialisation des compteurs utiliés dans chaque fonction réacteur
bool etatAllumage = 0;
int j=1;//intialisation du compteur pour les réacteurs de maneouvre

  void loop() {
        reacteur(9,9000,15200,true);
        reacteur(10,5000,15000,true);
        reacteur(11,7000,15600,true);

   if(etatAllumage==1){

      while(j<=255){//allumage des réacteurs
        if(j<0){//après le premier passage, j vaut -1 et allume la LED, on le ramène à zéro pour éviter le flash initial
          j=0;
        }
        analogWrite(5,j);
        delay(10);
        j++;
      }
    }
    
    else{//extinction des réacteurs
        while(j>=0){
        analogWrite(5,j);
        delay(1);
        j--;
      }
    }
           
    bool etatPinPoussoir = digitalRead(2);
    delay(5);
    if(!etatPinPoussoir){
      if(etatAllumage){
        etatAllumage = 0;
        
      }
      else{
        etatAllumage = 1;
      }
    }

}

void reacteur(int pin,unsigned long dureeAllumage, unsigned long delai,bool bruitOn){

    float pas = dureeAllumage/255;//calcul du pas temporel
    unsigned long currentMillis = millis();

    static unsigned long previousMillis[14];//un tableau de valeurs est initialisé (les variables en static ne doivent pas interférer entre les différents appels de la fonction)

      if(currentMillis<(dureeAllumage+delai)){

        if((currentMillis-previousMillis[pin])>=pas && (currentMillis>delai)){//si la date est inférieure à la durée d'allumage paramétrée
          previousMillis[pin] = currentMillis;//la date actuelle est sauvegardée pour servir de référence pour la prochaine boucle
          analogWrite(pin,i[pin]);//la LED est alluméeà i[pin]/255 du maximum
          i[pin] = i[pin]+1;//le compteur est incrémentée pour la prochaine boucle

          if(bruitOn){
          
          randomSeed(analogRead(0));//initialisation de la fonction random en lisant l'entrée 0 qui du coup doit rester non connectée
          int bruit = random(0,100);

             if(bruit<8){
              digitalWrite(pin,LOW);
              delay(10);
              analogWrite(pin,i[pin]);
             }
          }

        if(i[pin]>=255){
          digitalWrite(pin,HIGH);//si le maximum est atteint, la LED reste allumée
        }
      }
   }      
}

C’est un peu long pour faire relativement peu mais c’est la loi du genre quand on code…

Insertion de la carte dans le socle

Une erreur de débutant (que j’ai souvent commise) consiste à insérer la carte dans la maquette. C’est séduisant : il n’y a que 2 ou 3 fils à faire monter par la tige de soutien et ça permet de faire un socle plus petit.

Malheureusement, ça ne permet plus la maintenance de la carte. De nombreux problèmes peuvent survenir : altération du code si la carte est placée dans un champ magnétique, vieillissement de la carte, des contacts électriques etc. Il est plus sage de prévoir le pire et d’anticiper un remplacement futur de la carte.

Arduino sur une maquette : insertion de la carte dans le socle

C’est pourquoi je l’ai insérée dans le socle. Evidemment, l’inconvénient est que j’ai dû faire monter 12 fils par la tige de soutien… mais ça a fini par passer.

Conclusion : avantages d’une carte Arduino sur une maquette

Il m’a fallu très longtemps pour m’y mettre, des années. C’est toujours pareil avec la nouveauté. On se dit « bof, ça marche très bien comme ça, pourquoi changer ? ». C’est la maquette de l’USS Enterprise NCC-1701-A que j’ai réalisé l’an dernier qui m’a décidé.

Mon client m’avait demandé d’utiliser un kit d’éclairage commercialisé qui permettait le clignotement des feux de position, l’allumage progressif des réacteurs etc. Je me suis dit à l’époque que ça ne devait pas être bien sorcier et j’ai décidé que ma prochaine maquette y aurait droit.

Sur ce modèle de destroyer stellaire impérial, il n’y a que la lumière à gérer mais on peut envisager beaucoup d’autres possibilités : moteurs pour animer certaines parties, effets sonores, schéma d’éclairage complètement différents au choix de l’utilisateur etc. Je garde toujours en tête l’idée de réaliser le hangar de la base de Hoth animé, éclairé et sonorisé… dans une autre vie je le crains !

Posté le 25 août 2019 par petersteven dans Work in progress

bouton orangebouton bleucontour bouton

COMMENTAIRES

Laisser un commentaire ?




Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.