Construire une tourelle Nerf pilotée par Bluetooth : guide pièces et assemblage

Composants et fournitures

Composant	Quantité
Arduino Nano R3	1
Module Bluetooth HC-05	1
Convertisseur abaisseur LM2596	1
Servomoteurs MG-90s	3
Moteurs DC type 130	2
Diode redresseur FR207	1
MOSFET RFP30N06LE	1
Prise jack 2,1×5,5 mm	1
Résistances 10 kΩ	1
Résistances 330 Ω	1
Résistances 680 Ω	1
Vis auto-taraudeuses M2×10	30
Vis à tête fraisée M5×20	4
Connecteurs Dupont	15
Tige métallique 1,5 mm	1
Fils électriques	1
Gaine thermorétractable	1
Élastique 20 mm	1
Alimentation 9 V (2,5 A minimum)	1

Outils et machines nécessaires

• Tournevis
• Dénudeur de fils
• Pinces
• Fer à souder
• Multimètre
• Outil à sertir
• Imprimante 3D

Applications et services en ligne

• Microsoft Windows 10

À propos de ce projet

Merci de consulter mon projet de tourelle Nerf pilotée par Bluetooth. Il n'y a pas grand-chose à expliquer : c'est une tourelle Nerf contrôlée via Bluetooth depuis un appareil Android ou un PC.

Plus de détails sur : littlefrenchkev.com/bluetooth-nerf-turret

Comment ça fonctionne ?

Rien de très complexe. Les mouvements de rotation (pan) et d'inclinaison (tilt) sont gérés par 2 servomoteurs pilotés par un Arduino Nano.

Les fléchettes sont propulsées par 2 rouleaux entraînés par 2 petits moteurs DC. Un servomoteur pousse les fléchettes dans les rouleaux lorsque l'ordre de tir est envoyé. Le chargeur peut contenir 7 fléchettes.

Comme mentionné, le contrôle se fait via Bluetooth depuis un appareil Android ou un PC.

Comment la construire ?

ASSEMBLAGE

Le trépied et le chargeur existent en deux versions : l'une pour servos MG-90s, l'autre pour MG996r. Les MG996r sont plus gourmands en énergie ; assurez-vous que votre alimentation suffit si vous les choisissez.

Trépied :

Chargeur :

CÂBLAGE :

LOGICIEL ET TESTS !!!

Photos supplémentaires

Code

Code Arduino

Code à téléverser sur l'Arduino. Le code reste identique que vous choisissiez de contrôler la tourelle via l'application Android ou un PC.

#include <Servo.h> //-----Déclaration des servos et variables
Servo recoil_servo;
Servo pan_servo;
Servo tilt_servo;
const byte pan_limit_1 = 0;
const byte pan_limit_2 = 180;
const byte tilt_limit_1 = 65;
const byte tilt_limit_2 = 180;
const byte recoil_rest = 180; // Angle du servo au repos
const byte recoil_pushed = 125; // Angle pour pousser la fléchette

//-----Variables pour la gestion des données série
byte byte_from_app;
const byte buffSize = 30;
byte inputBuffer[buffSize];
const byte startMarker = 255;
const byte endMarker = 254;
byte bytesRecvd = 0;
boolean data_received = false;

//-----Variables pour le timing moteur et le tir
bool is_firing = false;
bool can_fire = false;
bool recoiling = false;
unsigned long firing_start_time = 0;
unsigned long firing_current_time = 0;
const long firing_time = 150;
unsigned long recoil_start_time = 0;
unsigned long recoil_current_time = 0;
const long recoil_time = 2 * firing_time;
const byte motor_pin = 12;
boolean motors_ON = false;

void setup() {
  pinMode(motor_pin, OUTPUT);
  digitalWrite(motor_pin, LOW);

  recoil_servo.attach(9);
  pan_servo.attach(10);
  tilt_servo.attach(11);

  //-----Séquence de démarrage
  recoil_servo.write(recoil_rest);
  pan_servo.write(90);
  delay(1000);
  tilt_servo.write(105);
  Serial.begin(9600);
}

void loop() {
  getDataFromPC();
  set_motor();
  if (data_received) {
    move_servo();
    set_recoil();
    set_motor();
  }
  fire();
}

void getDataFromPC() {
  // Structure attendue : [octet_début, pan, tilt, moteur_on, tir, octet_fin]
  // octet_début = 255
  // pan = octet 0-253
  // tilt = octet 0-253
  // moteur_on = 0 éteint - 1 allumé
  // tir = 0 non pressé - 1 pressé
  // octet_fin = 254

  if (Serial.available()) {
    byte_from_app = Serial.read();
    if (byte_from_app == 255) {
      bytesRecvd = 0;
      data_received = false;
    } else if (byte_from_app == 254) {
      data_received = true;
    } else {
      inputBuffer[bytesRecvd] = byte_from_app;
      bytesRecvd++;
      if (bytesRecvd == buffSize) {
        bytesRecvd = buffSize - 1;
      }
    }
  }
}

void move_servo() {
  byte pan_servo_position = map(inputBuffer[0], 0, 253, pan_limit_2, pan_limit_1);
  pan_servo.write(pan_servo_position);

  byte tilt_servo_position = map(inputBuffer[1], 0, 253, tilt_limit_2, tilt_limit_1);
  tilt_servo.write(tilt_servo_position);
}

void set_recoil() {
  if (inputBuffer[3] == 1) {
    if (!is_firing && !recoiling) {
      can_fire = true;
    }
  } else {
    can_fire = false;
  }
}

void set_motor() {
  if (inputBuffer[2] == 1) {
    digitalWrite(motor_pin, HIGH);
    motors_ON = true;
  } else {
    digitalWrite(motor_pin, LOW);
    motors_ON = false;
  }
}

void fire() {
  if (can_fire && !is_firing && motors_ON) {
    firing_start_time = millis();
    recoil_start_time = millis();
    is_firing = true;
  }
  firing_current_time = millis();
  recoil_current_time = millis();

  if (is_firing && firing_current_time - firing_start_time < firing_time) {
    recoil_servo.write(recoil_pushed);
  } else if (is_firing && recoil_current_time - recoil_start_time < recoil_time) {
    recoil_servo.write(recoil_rest);
  } else if (is_firing && recoil_current_time - recoil_start_time > recoil_time) {
    is_firing = false;
  }
}

Fichiers Python

L'exécutable et l'application Android sont disponibles ici : littlefrenchkev.com et GitHub

Schémas

Voici le schéma de câblage principal. Le câblage est divisé en petites sections reliées par connecteurs Dupont pour faciliter l'assemblage.

Câblage du module Bluetooth HC-05. Ce schéma inclut un diviseur de tension pour abaisser le 5V de l'Arduino à ~3,3V pour la broche RX du HC-05.