Dual-Sandbox

30/01/2026

1. Choix du matériel

Nous avons choisi les dimensions de la boîte du bac à sable à partir des plaques de plexiglas disponibles. Les moteurs que nous allons utiliser nous ont également été déjà fournis par notre responsable.

06/02/2026

1. Étude des chantiers à venir

Nous avons identifié les différents chantiers sur lesquels travailler :

• Contrôle du moteur DC (par PWM, via Arduino ; des transformateurs seront nécessaires car la carte Arduino ne peut pas travailler avec les tensions de 24 V assignées au moteur DC)
• Fixation du moteur : il faut décider du mode de fixation du moteur (probablement une sorte de cadre qui le maintiendrait)
• Étanchéité (éviter que des grains de sable restent bloqués contre le verre, derrière les plaques de bois) : peut-être une pièce flexible en caoutchouc comme ce qu'on trouve sur les pelles de balayettes

2. Travail sur la PWM avec Arduino

Essai de PWM avec un moteur DC 5V en utilisant un potentiomètre 50k. Le montage ne marchait pas, cela peut être dû à un mauvais branchement ou à un potentiomètre défaillant.

13/02/2026

Le but de cette séance est de comprendre pourquoi le montage de la dernière fois n'a pas fonctionné. Révision via un tutoriel Arduino.

• Le potentiomètre fonctionne bien (vérifié par un programme Arduino qui permet de lire les variations de tension induites par le potentiomètre)
• 
  • Branchement qui fonctionne théoriquement (via tinkercad.com) : les variations de voltages induisent bien des variations de rotations par minutes (sans surcharge pour la carte UNO)
  • Le branchement ne fonctionne pas dans la réalité (peut-être à cause de la résistance, qui ne laisse pas assez de courant passer)

Une piste pour contrôler le moteur en utilisant un Motor Shield 

20/02/2026

• Utilisation du Motor Shield Rev3 pour contrôler le moteur DC 5V : montage beaucoup plus simple que sans shield. (la piste mentionnée précédemment a été fructueuse)
  • Montage avec contrôle de la vitesse via potentiomètre
• Prochaine étape : adapter le montage pour le moteur DC 24V, 3A (6A au démarrage)
  • Nous avons un transistor IRF520, mais qui ne tiendrait pas le courant du moteur.
  • À la place, nous pensons utiliser un transistor IRLZ44NPBF 55V 47A (s'il fonctionne avec PWM)
  • Les transformateurs NDR-120-24 (guide usager) à disposition vont nous servir à réduire la tension du secteur à un niveau utilisable pour le moteur. Nous allons étudier leurs branchements la prochaine fois.

27/02/2026

• Pour le transistor IRLZ44NPBF 55V 47A, le délai entre deux activation est de minimum 136 ns (addition des temps d'activation, de lancement, de désactivation et de fall time). La fréquence PWM de base d'Arduino est de 490 Hz, ce qui correspond à une période d'environ 2 ms : on devrait pouvoir utiliser ce transistor pour faire de la PWM avec Arduino.
• Guide sur l'utilisation de la PWM avec un transistor MOSFET IRF540N (qui a des paramètres assez proches de l'IRLZ44NPBF que nous pensons utiliser)
  • Nous allons avoir besoin d'une diiode pour rediriger le courant du moteur quel que soit le transistor utilisé
  • Dans les autres parties du guide, il est détaillé comment augmenter la fréquence de PWM d'Arduino, et comment adapter le circuit pour ces changement on/off beaucoup plus rapides. Ces ajustements pourraient nous intéresser pour réduire la chauffe du moteur (et le bruit émis)
• Nous avons revisité la PWM avec un moteur DC et une alimentation extérieure sans Motor Shield.

13/03/2026

• Pour notre projet et des futures Sandbox, il serait utile de pouvoir directement indiquer une vitesse plutôt que d'utiliser un potentiomètre : nous faisons donc des recherches pour contrôler un input de l'utilisateur. Pistes possibles :
  • LCD display et des bouton pression pour contrôler la vitesse et le sens de rotation du moteur.
    • Mais il resterait la question de la synchronisation entre moteurs, pour qu'ils soient lancés en même temps.
  • LCD display et Keypad ?

20/03/2026

• Nous avons revisité les montages des Sandbox précédent. Nous avons décidé d'utiliser ARDUINO pour contrôler les variations de vitesse du moteur : nous n'utiliserons donc pas les servoamplificateurs des montages précédents.
  • On va séparer l’alimentation de l’Arduino de celle des moteurs pour éviter que l’Arduino reçoive trop de tension ou de courant, et aussi pour réduire le nombre d’outils nécessaires. On peut abaisser la tension avec un Buck Converter, mais on ne peut pas réduire le courant fourni par l’alimentation du moteur. L’Arduino supporte seulement quelques centaines de mA, tandis que le moteur peut consommer jusqu’à 6A, ce qui ne sera pas fourni par l’Arduino, mais directement par l’alimentation 24V. On va utiliser un adaptateur simple branché sur le secteur, qui fournira 5V et le courant nécessaire pour alimenter l’Arduino.
• Pour le contrôle final du montage, nous avons pensé au système suivant :
  • chaque moteur est associé à un keypad/potentiomètre (qui détermine la vitesse de déplacement) et à un interrupteur à 3 positions (marche avant - arrêt - marche arrière). Une fois chacun des deux moteurs "configurés", on utilise un interrupteur à 2 positions pour lancer ou arrêter la manipe. Il devrait aussi être possible de changer la "configuration" de chaque moteur en cours de manipe.
• Prochaine séance : construire un montage Arduino avec le MOSFET et lire la tension aux bornes. (tester de la PWM avec Keypad et potentiomètre)

27/03/2026

• Le plan pour le découpage des blocs de plexiglas a été réalisé. Nous avons utilisé le logiciel Inkscape. Les dimensions des blocs ainsi que l’emplacement des trous pour le passage des vis sont indiqués sur ce même plan afin de l’envoyer au découpage.

  
  
  
  
  (PHOTO DE PLAN ICI)
  
  
  
  (LÉGENDE ET EXPLICATIONS POUR LE PLAN)
• Nous avons réalisé un montage comprenant un transistor (mais pas encore le transistor MOSFET final) pour tester de la PWM dans un circuit avec ce genre d'élément, même avec seulement un seul circuit à une seul tension.

  int pwmPin = 3;
  int rapportCyclique = 255;
  
  void setup() {
  }
  
  void loop() {
  
    while (rapportCyclique > 5) {
      analogWrite(pwmPin, rapportCyclique);
      delay(1000);
      rapportCyclique = rapportCyclique - 10;
    }
  }

  Le code commence avec une intensité de la LED maximale, et diminue le rapport cyclique (le temps relatif où la broche passe à une tension non nulle) progressivement : l'intensité de la LED diminue progressivement aussi.

03/04/2026

• Nous avons tous les composants nécessaires ; nous avons construit un circuit qui incorpore ces composants, mais sans différence de tension, et où une LED remplace le moteur DC.

  #include <Keypad.h>
  
  const int ROW_NUM = 4; //four rows
  const int COLUMN_NUM = 4; //three columns
  
  char keys[ROW_NUM][COLUMN_NUM] = {
    {'1','2','3','A'},
    {'4','5','6','B'},
    {'7','8','9','C'},
    {'*','0','#','D'}
  };
  
  byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
  byte pin_column[COLUMN_NUM] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad
  int pwmPin = 11;
  
  Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
  String input_vitesse; // la vitesse est représentée par le rapport cyclique (entre 0 et 255)
  int vitesse = -1;
  bool clavier = true; // régit si l'on peut ou non modifier le rapport cyclique
  
  void setup(){
    Serial.begin(9600);
    input_vitesse.reserve(2); // au maximum, 3 caractères peuvent être stockés par cette variable
  }
  
  void loop(){
    char key = keypad.getKey();
  
    if (key){
      Serial.println(key);
  
      if (clavier){
        if(key == '*') {
          input_vitesse = ""; // reinitialise le paramètre vitesse
        } 
        else if(key == '#') {
          Serial.println(input_vitesse);
          if(input_vitesse.toInt() < 256) {
            Serial.println("Rapport cyclique compatible !");
            vitesse = input_vitesse.toInt();
            clavier = false; // on sort de la boucle -> la pwm peut être appliquée à la vitesse indiquée
          
          } 
          else {
            Serial.println("Rapport cyclique non compatible.");
            input_vitesse = "";
          }
  
          input_vitesse = ""; // input_vitesse est réinitialisé
        } 
        else {
          input_vitesse += key; // ajoute un chiffre à la vitesse
        }
      }
      if (key == 'D'){
        clavier = true; // Si la touche D est pressée, l'utilisateur peut indiquer un nouveau rapport cyclique
      }
    }
    
    analogWrite(pwmPin, vitesse);
  }

  L'utilisateur peut sélectionner un rapport cyclique entre 0 et 255 via le Keypad. Cette sélection est confirmée via la touche #, et réinitialisée via la touche *. La touche D permet de sélectionner un nouveau rapport cyclique. Selon le rapport cyclique choisi, l'intensité de la LED varie.

• Il serait intéressant de pouvoir contrôler 2 vitesse avec un seul Keypad (réflexion en cours).

10/04/2026

• Nous avons construit un circuit avec un code qui permet de contrôler l'intensité de 2 LEDs en même temps grâce au même Keypad. L'utilisateur appuie sur la touche C pour choisir l'intensité de la LED rouge, et sur la touche D pour choisir l'intensité de la LED verte. Le fonctionnement interne du choix de la vitesse se fait sur le même principe que lors de la séance précédente.

  

  #include <Keypad.h>
  
  const int ROW_NUM = 4; //four rows
  const int COLUMN_NUM = 4; //three columns
  
  char keys[ROW_NUM][COLUMN_NUM] = {
    {'1','2','3','A'},
    {'4','5','6','B'},
    {'7','8','9','C'},
    {'*','0','#','D'}
  };
  
  byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
  byte pin_column[COLUMN_NUM] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad
  
  int ledC = 11;
  int ledD = 10;
  
  Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
  String input_vitesse; // la vitesse est représentée par le rapport cyclique (entre 0 et 255)
  int vitesseC = 0;
  int vitesseD = 0;
  bool clavier = true; // régit si l'on peut ou non modifier le rapport cyclique
  
  // faire une fonction qui permette de sélectionner un moteur (ex : A ou B) puis de choisir sa vitesse.
  
  void setup(){
    Serial.begin(9600);
    input_vitesse.reserve(2); // au maximum, 3 caractères peuvent être stockés par cette variable
  }
  
  int vitesse_setup(){ // fonction qui permet de sélectionner une vitesse / intensité
    int vitesse;
  
    while (clavier){
      char key = keypad.getKey();
  
      if (key){
        Serial.println(key);
  
        if(key == '*') {
          input_vitesse = ""; // réinitialise le paramètre vitesse
        } 
        else if(key == '#') {
          Serial.println(input_vitesse);
          if(input_vitesse.toInt() < 256) {
            Serial.println("Rapport cyclique compatible !");
            clavier = false; // on sort de la boucle -> la pwm peut être appliquée à la vitesse indiquée
            vitesse = input_vitesse.toInt();
            input_vitesse = ""; // input_vitesse est réinitialisé
            return vitesse;
          
          } 
          else {
            Serial.println("Rapport cyclique non compatible.");
            input_vitesse = "";
          }
          
        } 
        else {
          input_vitesse += key; // ajoute un chiffre à la vitesse
        }
      }
    }
  }
  
  void loop(){
    char key = keypad.getKey();
  
    if (key){
      if (key == 'C'){
        clavier = true;
        vitesseC = vitesse_setup(); 
        Serial.println(vitesseC);
  
      } else if (key == 'D'){
        clavier = true;
        vitesseD = vitesse_setup();
        Serial.println(vitesseD);
      }
      analogWrite(ledC, vitesseC); // change l'intensité de la ledC
      analogWrite(ledD, vitesseD); // change l'intensité de la ledD
    }
  }

17/04/2026

• Nous avons pu utiliser la découpe laser pour ajuster les plaques de plexiglas aux dimensions choisies.
• Le circuit électronique ARDUINO / Moteur DC est finalisé ; nous avons juste besoin d'une pièce pour relier les fils au moteur.

24/04/2026

• Nous avons pu construire le circuit avec un moteur, et nous avons pu entraîner des changements de vitesse via la PWM induite par le Keypad. Sous un rapport cyclique de 80, le moteur ne tournait pas (pas assez de courant ?)
• Nous allons explorer l'idée d'utiliser un écran LCD pour pouvoir suivre les changements de vitesse demandées plus facilement.