Control servomotor wireless folosind o legătură de comunicație de 2,4 GHz

În acest post vom construi un circuit servomotor fără fir care poate controla fără fir 6 servomotoare pe o legătură de comunicație de 2,4 GHz.

Introducere

Proiectul este împărțit în două părți: un transmițător cu 6 potențiometre și un circuit receptor cu 6 servomotoare .

Telecomanda are 6 potențiometre pentru a controla 6 servo-motoare individuale independent la receptor. Prin rotirea potențiometrului, unghiul servomotorul poate fi controlat .

Circuitul propus poate fi utilizat acolo unde aveți nevoie de mișcare controlată, de exemplu brațul unui robot sau controlul direcției roții din față a mașinii RC.

Inima circuitului este modulul NRF24L01, care este un transceiver care funcționează pe banda ISM (bandă industrială, științifică și medicală), este aceeași bandă de frecvență pe care o funcționează WI-FI.

Ilustrarea modulelor NRF24L01:

Are 125 de canale, are o rată de date maximă de 2 Mbps și are o rază teoretică maximă de 100 de metri. Veți avea nevoie de două astfel de module pentru a stabili o legătură de comunicare.

Configurarea pinului:

Funcționează pe protocolul de comunicare SPI. Trebuie să conectați 7 din cei 8 pini la Arduino pentru ca acest modul să funcționeze.

Funcționează pe 3,3 V și 5V, ucide modulul, deci trebuie să aveți grijă în timpul alimentării. Din fericire avem la bord regulatorul de tensiune de 3,3 V pe Arduino și trebuie alimentat numai de la o priză de 3,3 V a Arduino.

Acum să trecem la circuitul emițătorului.

Circuitul emițătorului:

Circuitul este format din 6 potențiometri cu o valoare de 10K ohm. Terminalul mijlociu a 6 potențiometre este conectat la pinii de intrare analogici A0 la A5.

Tabelarea este dată lângă schema pentru conexiunea NRF24L01 la Arduino la care vă puteți referi, dacă aveți vreo confuzie în diagrama circuitului.

Acest circuit poate fi alimentat de la baterie USB sau 9V prin mufa DC.

Vă rugăm să descărcați fișierul bibliotecii aici: github.com/nRF24/

Program pentru emițător:

//----------------------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------------------------//

Asta încheie emițătorul.

Destinatarul:

Circuitul receptorului este format din 6 servo-motoare, unul Arduino și două surse de alimentare separate.

servomotorele au nevoie de curent mai mare pentru a funcționa, deci nu trebuie alimentate de la arduino . De aceea avem nevoie de două surse de alimentare separate.

Vă rugăm să aplicați tensiunea la servo în mod corespunzător pentru micro servo motoare 4.8V este suficient, dacă doriți să alimentați servo motoare mai voluminoase, aplicați tensiunea potrivită la ratingul servo.

Vă rugăm să rețineți că servomotorul consumă puțină energie chiar și atunci când nu există niciun moment, deoarece brațul servomotorului luptă întotdeauna împotriva oricărei schimbări din poziția sa comentată.

Program pentru receptor:

//----------------------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------------------------//

Asta încheie receptorul.

Cum se operează acest proiect:

• Alimentați circuitul.
• Acum rotiți oricare dintre butonul potențiometrului.
• De exemplu, al treilea potențiometru, servo-ul corespunzător la receptor se rotește.
• Acest lucru se aplică tuturor servomotorelor și potențiometrelor.

Notă: Puteți conecta emițătorul la computer și puteți deschide monitorul serial pentru a vedea date, cum ar fi unghiul servomotorului, nivelul de tensiune la pinul analogic și care potențiometru funcționează în prezent.

Dacă aveți vreo întrebare specifică cu privire la acest servomotor wireless bazat pe Arduino, vă rugăm să exprimați în secțiunea de comentarii că veți primi un răspuns rapid.