Simulador de Carreras 2D DIY con Arduino Nano y Servos SG90

Componentes y materiales

Herramientas necesarias

• Soldador (genérico)

Aplicaciones y servicios online

• Arduino IDE

Descripción del proyecto

SimTools es un software genérico de simulador de movimiento capaz de controlar múltiples interfaces hardware, incluido Arduino. Esta combinación se usa en el proyecto del video. El hardware consiste solo en un microcontrolador Arduino Nano y dos servomotores micro SG90 baratos. Solo hay que subir el código que se proporciona a continuación.

Los datos del juego requeridos, con ayuda del software SimTools, se transmiten por el puerto serie al Arduino. Este activa los servomotores que mueven la plataforma de simulación según corresponda. Es una versión a pequeña escala de un simulador de dos ejes. Para hacer un simulador real, necesitas añadir drivers de motor y servomotores grandes.

Hay muchos ejemplos de simuladores DIY, planos de construcción y consejos en https://www.xsimulator.net/. El procedimiento de configuración de SimTools se describe en el video, pero también puedes descargar el manual PDF en: https://simtools.us/wp-content/uploads/2019/06/SimToolsUserManual-v2.4.pdf

SimTools funciona en modo "Demo" hasta que se registre una licencia válida. El plugin para Live for Speed es totalmente operativo para pruebas mientras SimTools está en modo demo. (La demo de Live for Speed también sirve para probar SimTools.) Más info y descarga de Live for Speed en https://www.lfs.net/downloads

Descarga de SimTools: https://www.xsimulator.net/community/marketplace/motion-simulation-software-simtools.63/

Código

Código principal (C/C++)

//********************************************************************************************
// RC Model Servo
// Código original por EAOROBBIE (Robert Lindsay)
// Modificado completamente por aarondc
// Para uso libre con SimTools Motion Software
//********************************************************************************************
#include <Servo.h>
//#define DEBUG 1  // descomenta para debug Serial.print

const int kActuatorCount = 2;  // número de actuadores
// "nombres" (letras) que SimTools envía para identificar cada actuador
// El orden aquí determina el orden de kPins y kActuatorScale
const char kActuatorName[kActuatorCount] = { 'R', 'L' };
const int kPins[kActuatorCount] = {4, 5};  // pines de los actuadores
const int kActuatorScale[kActuatorCount][2] = {
  { 0, 179 },   // Escalado actuador derecho
  { 179, 0 }    // Escalado actuador izquierdo
};
const char kEOL = '~';  // Fin de línea - delimitador para valores de actuador
const int kMaxCharCount = 3;  // seguro...

Servo actuatorSet[kActuatorCount];
int actuatorPosition[kActuatorCount] = {90, 90};  // posiciones actuales, inicializadas a 90
int currentActuator;
int valueCharCount = 0;

// Estados para máquina de estados
// psReadActuator = siguiente carácter del puerto serie indica el actuador
// psReadValue = siguientes 3 caracteres indican el valor
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() {
  // todo se maneja en serialEvent()
}

void serialEvent() {
  char tmpChar;
  int tmpValue;
  while (Serial.available()) {
    if (currentState == psReadActuator) {
      tmpChar = Serial.read();
#ifdef DEBUG
      Serial.print("leído "); Serial.println(tmpChar);
#endif
      for (int i = 0; i < kActuatorCount; i++) {
        if (tmpChar == kActuatorName[i]) {
#ifdef DEBUG
          Serial.print("que es actuador "); 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;
          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("leído "); Serial.println(actuatorPosition[currentActuator]);
#endif
        // Escalar posición nueva entre 0 y 179
        actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator], 0, 255,
          kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
#ifdef DEBUG
        Serial.print("escalado a "); Serial.println(actuatorPosition[currentActuator]);
#endif
        updateActuator(currentActuator);
        currentState = psReadActuator;
      }
    }
  }
}

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

Esquemáticos