Pilotare servo motori a distanza con Arduino

Pilotare servo motori a distanza con Arduino
Pilotare servo motori a distanza con Arduino

In questo articolo ti mostro come è possibile pilotare a distanza dei servo motori con Arduino.

DigitSpace

Prima di passare al contenuto è doveroso ringraziare il sito DigitSpace per avermi fornito parte del materiale di questo progetto.

Qualche settimana fa avevo scritto un articolo su come è possibile pilotare a distanza dei motori passo passo con Arduino e i moduli radio nRF24L01.
L’esigenza era di Marco, che vorrebbe realizzare una torretta da soft-air gestita appunto da remoto.

In fase di realizzazione si è voluto cambiare tipo di motori, passando dagli stepper motor a dei servo a rotazione continua.

Da qui la necessità di modificare il codice ed i collegamenti e visto che la cosa potrebbe tornare utile a qualcuno mi è sembrato giusto condividerla.

Codice Trasmittente

/*
   Pilotare servo motori a distanza con Arduino

   Autore  : Andrea Lombardo
   Web     : http://www.lombardoandrea.com
   Post    : https://wp.me/p27dYH-Q5
*/

//Inclusione delle librerie
#include <Bounce2.h>
#include <nRF24L01.h>
#include <RF24_config.h>
#include <RF24.h>

//Costanti e PIN

//Pin pulsante incorporato nel modulo joystick che abilita o disabilita il controllo dei motori
const unsigned int pinSwEnable = 2;

//Pin pulsante esterno che controllerà il servo del grilletto
const unsigned int pinSwTrigger = 3;

//Chip Select e Chip Enable della Radio
const unsigned int radioCE = 4;
const unsigned int radioCS = 5;

//Pin per il LED di stato
const unsigned int ledEnable = 7;


//Pin analogici per il joystick
const unsigned int jX = A0;
const unsigned int jY = A1;

//Definizione indirizzo sul quale stabilire la comunicazione radio
const byte indirizzo[5] = {0, 0, 0, 0, 0};

/*
  Variabili utilizzate per definire min e max speed ed eseguire il mapping sui valori del joystick.
*/

const unsigned int maxSpeedForward = 180;
const unsigned int stopSpeed = 90;
const unsigned int maxSpeedBackward = 0;

/*
  La lettura dei potenziometri non è mai affidabile al 100%.
  Questo valore aiuta a determinare il punto da considerare come "Sta al centro" nei movimenti.
*/
const unsigned int treshold = 8;

//Millisecondi per il debonuce del bottone
const unsigned long debounceDelay = 10;

//Definisco struttura pacchetto da inviare
struct Packet {
  unsigned int speedX;
  unsigned int speedY;
  boolean enable;
  boolean trigger;
};

//Variabili di appoggio
long  valX, mapX, valY, mapY, tresholdUp, tresholdDown;

//Creo istanze dei bottoni
Bounce btnEnable = Bounce();  //istanzia un bottone dalla libreria Bounce
Bounce btnTrigger = Bounce();  //istanzia un bottone dalla libreria Bounce

//Creo istanza della "radio" passandogli il numero dei pin collegati a CE e CSN del modulo
RF24 radio(radioCE, radioCS);

//Creo ed inizializzo istanza pacchetto da inviare
Packet pkt = {
  stopSpeed,//speedX
  stopSpeed,//speedY
  false,//enable
  false //trigger
};

void setup() {

  Serial.begin(115200);
  //Definizione delle modalità dei pin

  //LED Enable
  pinMode(ledEnable, OUTPUT);

  //Tasto enable
  pinMode(pinSwEnable, INPUT_PULLUP);

  //Tasto grilletto
  pinMode(pinSwTrigger, INPUT_PULLUP);

  //Inizializzo la radio
  radio.begin();

  /*
     Setto la potenza della radio, nel mio caso a LOW
     La radio può lavorare a diverse potenze: RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH e RF24_PA_MAX
     Che corrispondono a: -18dBm, -12dBm,-6dBM, e 0dBm
  */
  radio.setPALevel(RF24_PA_LOW);

  //Apro un canale di comunicazione sull'indirizzo specificato (sarà lo stesso per il ricevitore)
  radio.openWritingPipe(indirizzo);

  //Richiamando questo metodo sto impostando la radio come trasmettitore
  radio.stopListening();

  //Configuro istanze dei pulsanti
  btnEnable.attach(pinSwEnable);
  btnEnable.interval(debounceDelay);

  btnTrigger.attach(pinSwTrigger);
  btnTrigger.interval(debounceDelay);

  //Calcolo range valori entro i quali considerare la posizione del joystick come "Sta al centro"
  tresholdDown = (maxSpeedForward / 2) - treshold;
  tresholdUp = (maxSpeedForward / 2) + treshold;

  //Invio stato di enable al LED
  digitalWrite(ledEnable, pkt.enable);
}

void loop() {

  //gestisci stato dei pulsanti
  handlePulsanti();

  //gestisci valori dei potenziometri
  handleJoystick();

  //Invia dati tramite la radio
  if (pkt.enable) {
    radio.write(&pkt, sizeof(pkt));
  }
}

/*
  Si occupa di leggere i valori del joystick, mapparli ed aggiornare le variabili nel Packet
*/
void handleJoystick() {

  //esegui lettura analogica dei valori provenienti dai potenziometri del joystick
  valX = analogRead(jX);
  valY = analogRead(jY);

  //mappa i valori letti in funzione della velocità minima e massima
  mapX = map(valX, 0, 1023, 0, maxSpeedForward);
  mapY = map(valY, 0, 1023, 0, maxSpeedForward);

  if (mapX <= tresholdDown) {
    //x va indietro
    pkt.speedX = map(mapX, maxSpeedBackward, tresholdDown, maxSpeedBackward, tresholdDown);
  } else if (mapX >= tresholdUp) {
    //x va avanti
    pkt.speedX = map(mapX, tresholdUp, maxSpeedForward, tresholdUp, maxSpeedForward);
  } else {
    //x sta fermo
    pkt.speedX = stopSpeed;
  }

  if (mapY <= tresholdDown) {
    //y va indietro
    pkt.speedY = map(mapY, maxSpeedBackward, tresholdDown, maxSpeedBackward, tresholdDown);
  } else if (mapY >= tresholdUp) {
    //y va avanti
    pkt.speedY = map(mapY, tresholdUp, maxSpeedForward, tresholdUp, maxSpeedForward);
  } else {
    //y sta fermo
    pkt.speedY = stopSpeed;
  }

}


/*
  Si occupa di leggere lo stato dei pulsanti ed aggiornare le variabili nel Packet
*/
void handlePulsanti() {

  btnEnable.update();
  if (btnEnable.fell()) {
    pkt.enable = !pkt.enable;
  }

  //Mostra lo stato di enable con il LED
  digitalWrite(ledEnable, pkt.enable);

  //Aggiorna stato di pressione del "grilletto"
  btnTrigger.update();
  pkt.trigger = !btnTrigger.read();

}

Codice Ricevente

/*
   Pilotare servo motori a distanza con Arduino

   Autore  : Andrea Lombardo
   Web     : http://www.lombardoandrea.com
   Post    : https://wp.me/p27dYH-Q5
*/

//Inclusione delle librerie
#include <Servo.h>
#include <nRF24L01.h>
#include <RF24_config.h>
#include <RF24.h>

//Costanti e PIN

//Chip Select e Chip Enable della Radio
const unsigned int radioCS = 2;
const unsigned int radioCE = 3;

//Pin servo X
const unsigned int pinServoX = 5;

//Pin servo Y
const unsigned int pinServoY = 6;

//Pin servo Trigger
const unsigned int pinServoTg = 9;

//definizione indirizzo sul quale stabilire la comunicazione radio
const byte indirizzo[5] = {0, 0, 0, 0, 0};


//definisco struttura pacchetto che riceverò
struct Packet {
  unsigned int speedX;
  unsigned int speedY;
  boolean enable;
  boolean trigger;
};


const unsigned int stopSpeed = 90;

//Creo istanza della "radio" passandogli il numero dei pin collegati a CE e CSN del modulo
RF24 radio(radioCE, radioCS);

//Creo istanze servo
Servo servoX;
Servo servoY;
Servo servoTg;

//Creo ed inizializzo istanza pacchetto che userò per i dati ricevuti
Packet pkt = {
  stopSpeed,
  stopSpeed,
  false,
  false
};

void setup() {
  //Definizione delle modalità dei pin

  Serial.begin(115200);

  //Associa pin ai servo
  servoX.attach(pinServoX);
  servoY.attach(pinServoY);
  servoTg.attach(pinServoTg);

  //Inizializzo la radio
  radio.begin();

  /*
     Setto la potenza della radio, nel mio caso a LOW
     La radio può lavorare a diverse potenze: RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH e RF24_PA_MAX
     Che corrispondono a: -18dBm, -12dBm,-6dBM, e 0dBm
  */
  radio.setPALevel(RF24_PA_LOW);

  //Apro un canale in lettura sull'indirizzo specificato
  radio.openReadingPipe(1, indirizzo);

  //Metto la radio in ascolto
  radio.startListening();

  servoX.write(stopSpeed);
  servoY.write(stopSpeed);
  servoTg.write(0);

}

void loop() {

  //Se ci sono dati in ricezione sulla radio
  if (radio.available()) {

    //Leggo i dati sul buffer e li scrivo nell'istanza Packet precedentemente creata
    radio.read(&pkt, sizeof(pkt));

  } else {

    //Se non ricevo dati per un qualsiasi motivo, azzero tutto nell'istanza Packet.
    pkt = {
      stopSpeed,
      stopSpeed,
      false,
      false
    };

  }

  //Se nel pkt il valore del trigger è 1 ruoto di 90° il servo motor
  if (pkt.trigger) {
    servoTg.write(90);
  } else {
    //Altrimenti lo rimetto a 0
    servoTg.write(0);
  }

  //Interpreta i valori ricevuti ed aziona i motori di conseguenza
  pilotaServiMovimento(pkt);

  Serial.print("enable: ");
  Serial.print(pkt.enable);
  Serial.print(" speedX: ");
  Serial.print(pkt.speedX);
  Serial.print(" speedY: ");
  Serial.print(pkt.speedY);
  Serial.print(" trigger: ");
  Serial.println(pkt.trigger);

  delay(15);
}

/*
  Interpreta i valori contenuti nella struttura Packet
  ed aziona i servo di conseguenza
*/
void pilotaServiMovimento(Packet pkt) {

  if (pkt.enable) {
    servoX.write(pkt.speedX);
    servoY.write(pkt.speedY);
  } else {
    servoX.write(stopSpeed);
    servoY.write(stopSpeed);
  }

}

Schemi

Anche in questa occasione ho utilizzato dei moduli radio nRF24L01 per la comunicazione a distanza. La parte trasmittente è rimasta più o meno uguale a quella della precedente versione, mentre la ricevente adesso gestisce in totale tre servo motori. Due per rotazione ed elevazione (quelli a rotazione continua) ed uno per azionare il grilletto della replica (0° – 180°).

Per comodità ti riporto il pinout del modulo nRF24L01:

GNDGround
Vcc1.9V – 3.3V
CEChip Enable
CSNChip Select
SCKSerial Clock
MOSIMaster Output Slave Input
MISOMaster Input Slave Output
IRQInterrupt (generalmente non ci serve)
nRF24L01 Pinout
nRF24L01 Pinout

Circuito Trasmittente

Come ti ho già anticipato lo schema del trasmettitore è pressoché identico a quello della precedente versione, cambiano solo i pin CS e CE della radio che prima erano disposti diversamente visto che utilizzavo un Arduino Nano.

Schema trasmettitore
Schema trasmettitore

Circuito Ricevente

Dato che i servo a disposizione esprimono le migliori prestazioni ad un voltaggio diverso da quello che potrebbe fornire Arduino, ho inserito nel circuito un trasformatore DC DC (detto anche Buck Converter) per portare l’alimentazione da 12V (che sarebbero troppi per i servo) a 7V cosi da alimentare sia loro sia l’Arduino.

Nello specifico i servo che ho utilizzato sono due MG996R e un SG90 offerti dal sito DigitSpace che ringrazio.

Schema ricevitore
Schema ricevitore

Sono fiducioso nella riuscita del progetto e non vedo l’ora di vedere foto e video del lavoro ultimato da Marco.
Per adesso accontentiamoci di una demo da banco:

A fine pagina trovi il link per scaricare il pacchetto con codici e schemi di collegamento. Come sempre ti ricordo che acquistando prodotti Amazon passando attraverso i link del mio sito, io percepisco una piccola commissione (parliamo di centesimi) in buoni regalo. Questi buoni sommati alle eventuali donazioni PayPal, servono a mantenere attivo il sito web e ad acquistare nuovi componenti.






Ricerche che hanno riportato a questa pagina:

Potrebbero interessarti anche...