Controllo del servomotore wireless tramite collegamento di comunicazione a 2,4 GHz

In questo post costruiremo un circuito servomotore wireless che può controllare 6 servomotori in modalità wireless su un collegamento di comunicazione a 2,4 GHz.

introduzione

Il progetto è diviso in due parti: un trasmettitore con 6 potenziometri e un circuito ricevitore con 6 servomotori .

Il telecomando ha 6 potenziometri per controllare 6 singoli servomotori indipendentemente dal ricevitore. Ruotando il potenziometro, l'angolo del il servomotore può essere controllato .

Il circuito proposto può essere utilizzato dove è necessario un movimento controllato, ad esempio il braccio di un robot o il controllo della direzione della ruota anteriore di un'auto RC.

Il cuore del circuito è il modulo NRF24L01 che è un ricetrasmettitore funziona su banda ISM (banda industriale, scientifica e medica) è la stessa banda di frequenza su cui lavora il tuo WI-FI.

Illustrazione dei moduli NRF24L01:

Dispone di 125 canali, ha una velocità dati massima di 2 Mbps e ha una portata massima teorica di 100 metri. Avrai bisogno di due di questi moduli per stabilire un collegamento di comunicazione.

Configurazione dei pin:

Funziona su protocollo di comunicazione SPI. È necessario collegare 7 degli 8 pin ad Arduino per far funzionare questo modulo.

Funziona a 3,3 V e 5V uccide il modulo, quindi è necessario prestare attenzione durante l'alimentazione. Fortunatamente abbiamo a bordo un regolatore di tensione 3.3V su Arduino e deve essere alimentato solo dalla presa 3.3V di Arduino.

Ora passiamo al circuito del trasmettitore.

Circuito del trasmettitore:

Il circuito è composto da 6 potenziometri da 10K ohm. Il terminale centrale di 6 potenziometri è collegato ai pin di ingresso analogico da A0 a A5.

La tabella è fornita accanto allo schema per la connessione NRF24L01 ad Arduino a cui puoi fare riferimento, se hai qualche confusione nello schema del circuito.

Questo circuito può essere alimentato da USB o da una batteria da 9 V tramite jack CC.

Scarica il file della libreria qui: github.com/nRF24/

Programma per trasmettitore:

//----------------------Program Developed by R.Girish------------------------//
#include
#include
#include
RF24 radio(9,10)
const byte address[6] = '00001'
#define pot1 A0
#define pot2 A1
#define pot3 A2
#define pot4 A3
#define pot5 A4
#define pot6 A5
const int threshold = 20
int potValue1 = 0
int potValue2 = 0
int potValue3 = 0
int potValue4 = 0
int potValue5 = 0
int potValue6 = 0
int angleValue1 = 0
int angleValue2 = 0
int angleValue3 = 0
int angleValue4 = 0
int angleValue5 = 0
int angleValue6 = 0
int check1 = 0
int check2 = 0
int check3 = 0
int check4 = 0
int check5 = 0
int check6 = 0
const char var1[32] = 'Servo1'
const char var2[32] = 'Servo2'
const char var3[32] = 'Servo3'
const char var4[32] = 'Servo4'
const char var5[32] = 'Servo5'
const char var6[32] = 'Servo6'
void setup()
{
Serial.begin(9600)
radio.begin()
radio.openWritingPipe(address)
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.stopListening()
}
void loop()
{
potValue1 = analogRead(pot1)
if(potValue1 > check1 + threshold || potValue1 {
radio.write(&var1, sizeof(var1))
angleValue1 = map(potValue1, 0, 1023, 0, 180)
radio.write(&angleValue1, sizeof(angleValue1))
check1 = potValue1
Serial.println('INPUT:1')
Serial.print('Angle:')
Serial.println(angleValue1)
Serial.print('Voltage Level:')
Serial.println(potValue1)
Serial.println('----------------------------------')
}
potValue2 = analogRead(pot2)
if(potValue2 > check2 + threshold || potValue2 {
radio.write(&var2, sizeof(var2))
angleValue2 = map(potValue2, 0, 1023, 0, 180)
radio.write(&angleValue2, sizeof(angleValue2))
check2 = potValue2
Serial.println('INPUT:2')
Serial.print('Angle:')
Serial.println(angleValue2)
Serial.print('Voltage Level:')
Serial.println(potValue2)
Serial.println('----------------------------------')
}
potValue3 = analogRead(pot3)
if(potValue3 > check3 + threshold || potValue3 {
radio.write(&var3, sizeof(var3))
angleValue3 = map(potValue3, 0, 1023, 0, 180)
radio.write(&angleValue3, sizeof(angleValue3))
check3 = potValue3
Serial.println('INPUT:3')
Serial.print('Angle:')
Serial.println(angleValue3)
Serial.print('Voltage Level:')
Serial.println(potValue3)
Serial.println('----------------------------------')
}
potValue4 = analogRead(pot4)
if(potValue4 > check4 + threshold || potValue4 {
radio.write(&var4, sizeof(var4))
angleValue4 = map(potValue4, 0, 1023, 0, 180)
radio.write(&angleValue4, sizeof(angleValue4))
check4 = potValue4
Serial.println('INPUT:4')
Serial.print('Angle:')
Serial.println(angleValue4)
Serial.print('Voltage Level:')
Serial.println(potValue4)
Serial.println('----------------------------------')
}
potValue5 = analogRead(pot5)
if(potValue5 > check5 + threshold || potValue5 {
radio.write(&var5, sizeof(var5))
angleValue5 = map(potValue5, 0, 1023, 0, 180)
radio.write(&angleValue5, sizeof(angleValue5))
check5 = potValue5
Serial.println('INPUT:5')
Serial.print('Angle:')
Serial.println(angleValue5)
Serial.print('Voltage Level:')
Serial.println(potValue5)
Serial.println('----------------------------------')
}
potValue6 = analogRead(pot6)
if(potValue6 > check6 + threshold || potValue6 {
radio.write(&var6, sizeof(var6))
angleValue6 = map(potValue6, 0, 1023, 0, 180)
radio.write(&angleValue6, sizeof(angleValue6))
check6 = potValue6
Serial.println('INPUT:6')
Serial.print('Angle:')
Serial.println(angleValue6)
Serial.print('Voltage Level:')
Serial.println(potValue6)
Serial.println('----------------------------------')
}
}
//----------------------Program Developed by R.Girish------------------------//

Questo conclude il trasmettitore.

Il ricevente:

Il circuito del ricevitore è composto da 6 servomotori, un Arduino e due alimentatori separati.

Il i servomotori necessitano di una corrente maggiore per funzionare, quindi non devono essere alimentati da arduino . Ecco perché abbiamo bisogno di due fonti di alimentazione separate.

Si prega di applicare la tensione al servo in modo appropriato per i micro servomotori 4.8V è sufficiente, se si desidera alimentare servomotori più voluminosi, applicare la corrispondenza della tensione al valore del servo.

Ricorda che il servomotore consuma un po 'di potenza anche quando non c'è momento, questo perché il braccio del servomotore combatte sempre contro qualsiasi cambiamento dalla sua posizione commentata.

Programma per ricevitore:

//----------------------Program Developed by R.Girish------------------------//
#include
#include
#include
#include
RF24 radio(9,10)
const byte address[6] = '00001'
Servo servo1
Servo servo2
Servo servo3
Servo servo4
Servo servo5
Servo servo6
int angle1 = 0
int angle2 = 0
int angle3 = 0
int angle4 = 0
int angle5 = 0
int angle6 = 0
char input[32] = ''
const char var1[32] = 'Servo1'
const char var2[32] = 'Servo2'
const char var3[32] = 'Servo3'
const char var4[32] = 'Servo4'
const char var5[32] = 'Servo5'
const char var6[32] = 'Servo6'
void setup()
{
Serial.begin(9600)
servo1.attach(2)
servo2.attach(3)
servo3.attach(4)
servo4.attach(5)
servo5.attach(6)
servo6.attach(7)
radio.begin()
radio.openReadingPipe(0, address)
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.startListening()
}
void loop()
{
delay(5)
while(!radio.available())
radio.read(&input, sizeof(input))
if((strcmp(input,var1) == 0))
{
while(!radio.available())
radio.read(&angle1, sizeof(angle1))
servo1.write(angle1)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle1)
Serial.println('--------------------------------')
}
else if((strcmp(input,var2) == 0))
{
while(!radio.available())
radio.read(&angle2, sizeof(angle2))
servo2.write(angle2)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle2)
Serial.println('--------------------------------')
}
else if((strcmp(input,var3) == 0))
{
while(!radio.available())
radio.read(&angle3, sizeof(angle3))
servo3.write(angle3)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle3)
Serial.println('--------------------------------')
}
else if((strcmp(input,var4) == 0))
{
while(!radio.available())
radio.read(&angle4, sizeof(angle4))
servo4.write(angle4)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle4)
Serial.println('--------------------------------')
}
else if((strcmp(input,var5) == 0))
{
while(!radio.available())
radio.read(&angle5, sizeof(angle5))
servo5.write(angle5)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle5)
Serial.println('--------------------------------')
}
else if((strcmp(input,var6) == 0))
{
while(!radio.available())
radio.read(&angle6, sizeof(angle6))
servo6.write(angle6)
Serial.println(input)
Serial.print('Angle:')
Serial.println(angle6)
Serial.println('--------------------------------')
}
}
//----------------------Program Developed by R.Girish------------------------//

Questo conclude il ricevitore.

Come gestire questo progetto:

• Alimentare entrambi i circuiti.
• Ora ruota una qualsiasi delle manopole del potenziometro.
• Ad esempio 3 ° potenziometro, il servo corrispondente sul ricevitore ruota.
• Questo vale per tutti i servomotori e potenziometri.

Nota: è possibile collegare il trasmettitore al computer e aprire il monitor seriale per vedere dati come l'angolo del servomotore, il livello di tensione sul pin analogico e il potenziometro attualmente in uso.

Se hai qualche domanda specifica riguardo a questo progetto di servomotore wireless basato su Arduino, esprimi nella sezione commenti potresti ricevere una risposta rapida.