Simulador de Corrida 2D DIY com Arduino Nano e Servos SG90

Componentes e Materiais

Ferramentas e Máquinas Necessárias

• Ferro de solda (genérico)

Aplicações e Serviços Online

• Arduino IDE

Sobre o Projeto

O SimTools é um software genérico de simulador de movimento capaz de controlar múltiplas interfaces de hardware, incluindo Arduino. Esta combinação é usada no projeto apresentado no vídeo. A parte de hardware consiste apenas no microcontrolador Arduino Nano e dois servos micro SG90 baratos. Basta fazer upload do código abaixo.

Os dados do jogo necessários, com ajuda do software SimTools, são transmitidos pela porta serial para o Arduino. Em seguida, o Arduino ativa os servos que movem a plataforma de simulação de acordo. Esta é uma versão em pequena escala de um simulador de dois eixos. Para fazer um simulador real, você precisa adicionar drivers de motor e servos grandes.

Existem muitos exemplos de simuladores DIY, bem como desenhos de construção e dicas na página https://www.xsimulator.net/. O procedimento de configuração do SimTools é descrito no vídeo, mas você também pode baixar o manual do usuário em PDF: SimTools User Manual v2.4

O SimTools roda em modo "Demo" até que uma licença válida seja registrada. O plugin para Live for Speed é totalmente operacional para testes enquanto o SimTools está em modo demo. (A demo do Live for Speed também serve para testar o SimTools.) Mais informações e download do Live for Speed em https://www.lfs.net/downloads

Link para download do 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)
// Completamente modificado por aarondc
// Para uso livre com Sim Tool Motion Software
//********************************************************************************************
#include <Servo.h>
//#define DEBUG 1 // comente esta linha para remover linhas Serial.print de debug
const int kActuatorCount = 2; // quantos atuadores estamos manipulando
// As letras ("nomes") enviadas do Sim Tools para identificar cada atuador
// NB: a ordem das letras aqui determina a ordem das constantes restantes kPins e kActuatorScale
const char kActuatorName[kActuatorCount] = { 'R', 'L' };
const int kPins[kActuatorCount] = { 4, 5 }; // pinos aos quais os atuadores estão conectados
const int kActuatorScale[kActuatorCount][2] = {
  { 0, 179 },  // Escalonamento do Atuador Direito
  { 179, 0 }   // Escalonamento do Atuador Esquerdo
};
const char kEOL = '~'; // Fim de Linha - delimitador para valores do atuador
const int kMaxCharCount = 3; // seguro...
Servo actuatorSet[kActuatorCount]; // nosso array de atuadores
int actuatorPosition[kActuatorCount] = { 90, 90 }; // posições atuais dos atuadores, inicializadas em 90
int currentActuator; // acompanha qual atuador está sendo lido da porta serial
int valueCharCount = 0; // quantos caracteres de valor foram lidos (deve ser < kMaxCharCount)

// Estados para nossa máquina de estados
// psReadActuator = próximo caractere da serial nos diz o Atuador
// psReadValue = próximos 3 caracteres da serial nos dizem o valor
enum TPortState { psReadActuator, psReadValue };
TPortState currentState = psReadActuator;

void setup() {
  // Anexa os atuadores aos pinos
  for (int i = 0; i < kActuatorCount; i++)
    actuatorSet[i].attach(kPins[i]);
  // Inicializa posição dos atuadores
  for (int i = 0; i < kActuatorCount; i++)
    updateActuator(i);
  Serial.begin(9600); // abre porta serial a 9600 baud
}

void loop() {
  // Este código só roda quando temos dados seriais disponíveis
}

void serialEvent() {
  char tmpChar;
  int tmpValue;
  while (Serial.available()) {
    // Se esperando nome do atuador, pega aqui
    if (currentState == psReadActuator) {
      tmpChar = Serial.read();
      #ifdef DEBUG
      Serial.print("recebido ");
      Serial.println(tmpChar);
      #endif
      for (int i = 0; i < kActuatorCount; i++) {
        if (tmpChar == kActuatorName[i]) {
          #ifdef DEBUG
          Serial.print("que é atuador ");
          Serial.println(i);
          #endif
          currentActuator = i;
          currentState = psReadValue;
          actuatorPosition[currentActuator] = 0;
          valueCharCount = 0;
          break;
        }
      }
    }
    // Se pronto para ler posição do atuador atual
    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;
      }
      // Se leu delimitador de valor, atualiza atuador e procura próximo nome
      if (tmpValue == kEOL || valueCharCount == kMaxCharCount) {
        #ifdef DEBUG
        Serial.print("recebido ");
        Serial.println(actuatorPosition[currentActuator]);
        #endif
        // Escala nova posição para valor entre 0 e 179
        actuatorPosition[currentActuator] = map(actuatorPosition[currentActuator], 0, 255,
          kActuatorScale[currentActuator][0], kActuatorScale[currentActuator][1]);
        #ifdef DEBUG
        Serial.print("escalado para ");
        Serial.println(actuatorPosition[currentActuator]);
        #endif
        updateActuator(currentActuator);
        currentState = psReadActuator;
      }
    }
  }
}

// Escreve posição atual do atuador no atuador passado
void updateActuator(int thisActuator) {
  actuatorSet[thisActuator].write(actuatorPosition[thisActuator]);
}

Esquemáticos