Simulateur de Course 2 Axes DIY : Arduino Nano & Servos SG90

Composants et Fournitures

Composant	Quantité
Arduino Nano R3	1
Servomoteur micro SG90	2

Outils et Machines Nécessaires

• Fer à souder (générique)

Applications et Services

• Arduino IDE

À propos du projet

SimTools est un logiciel générique de simulateur de mouvement capable de piloter plusieurs interfaces matérielles, dont Arduino. Cette combinaison est utilisée dans le projet présenté en vidéo. La partie hardware se compose uniquement d'un microcontrôleur Arduino Nano et de deux servomoteurs micro SG90 bon marché. Il suffit de téléverser le code ci-dessous.

Les données de jeu requises, transmises par SimTools via le port série, activent les servomoteurs qui déplacent la plateforme de simulation en conséquence. Il s'agit d'un simulateur deux axes à petite échelle. Pour un vrai simulateur, il faut ajouter des drivers de puissance et de gros servomoteurs.

De nombreux exemples de simulateurs DIY, plans de construction et conseils sur xsimulator.net. La procédure de configuration SimTools est décrite dans la vidéo, manuel PDF téléchargeable : SimTools User Manual v2.4

SimTools fonctionne en mode "Demo" jusqu'à enregistrement d'une licence valide. Le plugin pour Live for Speed est pleinement opérationnel en mode demo. (La démo de Live for Speed permet aussi de tester SimTools.) Plus d'infos et téléchargement : lfs.net/downloads

Téléchargement SimTools : Marketplace xsimulator.net

Code

Code principal (C/C++)

//********************************************************************************************
// RC Model Servo
// Code original par EAOROBBIE (Robert Lindsay)
// Remanié par aarondc
// Utilisation libre pour SimTools Motion Software
//********************************************************************************************
#include <Servo.h>
//#define DEBUG 1  // décommenter pour activer les Serial.print de debug
const int kActuatorCount = 2;  // nombre d'actionneurs gérés

// Lettres ("noms") envoyées par SimTools pour identifier chaque actionneur
// L'ordre détermine l'ordre des constantes kPins et kActuatorScale
const char kActuatorName[kActuatorCount] = { 'R', 'L' };
const int kPins[kActuatorCount] = { 4, 5 };  // broches des actionneurs
const int kActuatorScale[kActuatorCount][2] = {
  { 0, 179 },   // Mise à l'échelle actionneur Right
  { 179, 0 }    // Mise à l'échelle actionneur Left (inversé)
};
const char kEOL = '~';  // Délimiteur fin de ligne pour valeurs actionneur
const int kMaxCharCount = 3;  // sécurité

Servo actuatorSet[kActuatorCount];
int actuatorPosition[kActuatorCount] = { 90, 90 };  // positions initiales
int currentActuator;
int valueCharCount = 0;

// Machine à états
enum TPortState { psReadActuator, psReadValue };
TPortState currentState = psReadActuator;

void setup() {
  for (int i = 0; i < kActuatorCount; i++)
    actuatorSet[i].attach(kPins[i]);
  for (int i = 0; i < kActuatorCount; i++)
    updateActuator(i);
  Serial.begin(9600);
}

void loop() { }  // tout se passe dans serialEvent()

void serialEvent() {
  char tmpChar;
  int tmpValue;
  while (Serial.available()) {
    if (currentState == psReadActuator) {
      tmpChar = Serial.read();
#ifdef DEBUG
      Serial.print("lu : "); Serial.println(tmpChar);
#endif
      for (int i = 0; i < kActuatorCount; i++) {
        if (tmpChar == kActuatorName[i]) {
#ifdef DEBUG
          Serial.print("actionneur "); Serial.println(i);
#endif
          currentActuator = i;
          currentState = psReadValue;
          actuatorPosition[currentActuator] = 0;
          valueCharCount = 0;
          break;
        }
      }
    }
    if (currentState == psReadValue) {
      while ((valueCharCount < kMaxCharCount) && Serial.available()) {
        tmpValue = Serial.read();
        if (tmpValue != kEOL) {
          tmpValue = tmpValue - 48;  // ASCII vers chiffre
          if ((tmpValue < 0) || (tmpValue > 9)) tmpValue = 0;
          actuatorPosition[currentActuator] = actuatorPosition[currentActuator] * 10 + tmpValue;
          valueCharCount++;
        } else break;
      }
      if (tmpValue == kEOL || valueCharCount == kMaxCharCount) {
#ifdef DEBUG
        Serial.print("valeur lue : "); Serial.println(actuatorPosition[currentActuator]);
#endif
        // Mise à l'échelle 0-255 → 0-179
        actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator], 0, 255,
          kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
#ifdef DEBUG
        Serial.print("mis à l'échelle : "); Serial.println(actuatorPosition[currentActuator]);
#endif
        updateActuator(currentActuator);
        currentState = psReadActuator;
      }
    }
  }
}

void updateActuator(int thisActuator) {
  actuatorSet[thisActuator].write(actuatorPosition[thisActuator]);
}

Schémas