Drahtlose Servomotorsteuerung über eine 2,4-GHz-Kommunikationsverbindung

Drahtlose Servomotorsteuerung über eine 2,4-GHz-Kommunikationsverbindung

In diesem Beitrag werden wir eine drahtlose Servomotorschaltung aufbauen, die 6 Servomotoren drahtlos über eine 2,4-GHz-Kommunikationsverbindung steuern kann.



Einführung

Das Projekt gliedert sich in zwei Teile: einen Sender mit 6 Potentiometern und eine Empfängerschaltung mit 6 Servomotor .



Die Fernbedienung verfügt über 6 Potentiometer zur unabhängigen Steuerung von 6 einzelnen Servomotoren am Empfänger. Durch Drehen des Potentiometers wird der Winkel des Servomotor kann gesteuert werden .

Die vorgeschlagene Schaltung kann verwendet werden, wenn Sie eine kontrollierte Bewegung benötigen, z. B. den Arm eines Roboters oder die Steuerung der Vorderradrichtung eines RC-Autos.



Das Herzstück der Schaltung ist das NRF24L01-Modul, ein Transceiver, der im ISM-Band (Industrial, Scientific and Medical Band) arbeitet. Es ist das gleiche Frequenzband, in dem Ihr WI-FI arbeitet.

Abbildung der NRF24L01-Module:

Es hat 125 Kanäle, eine maximale Datenrate von 2 MBit / s und eine theoretische maximale Reichweite von 100 Metern. Sie benötigen zwei solche Module, um eine Kommunikationsverbindung herzustellen.

Pin-Konfiguration:

Es funktioniert mit dem SPI-Kommunikationsprotokoll. Sie müssen 7 der 8 Pins mit Arduino verbinden, damit dieses Modul funktioniert.



Es funktioniert mit 3,3 V und 5 V, wodurch das Modul abgeschaltet wird. Daher muss beim Einschalten vorsichtig vorgegangen werden. Glücklicherweise haben wir einen 3,3-V-Spannungsregler an Bord von Arduino, der nur über die 3,3-V-Buchse von Arduino mit Strom versorgt werden darf.

Fahren wir nun mit der Senderschaltung fort.

Senderschaltung:

Die Schaltung besteht aus 6 Potentiometern mit einem Wert von 10 kOhm. Der mittlere Anschluss von 6 Potentiometern ist mit den analogen Eingangspins A0 bis A5 verbunden.

Die Tabelle ist neben dem Schaltplan für die Verbindung von NRF24L01 zu Arduino angegeben, auf den Sie sich beziehen können, wenn Sie im Schaltplan Unklarheiten haben.

Dieser Stromkreis kann über eine DC-Buchse von einer USB- oder 9-V-Batterie gespeist werden.

Bitte laden Sie die Bibliotheksdatei hier herunter: github.com/nRF24/

Programm für Sender:

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

Damit ist der Sender abgeschlossen.

Der Empfänger:

Die Empfängerschaltung besteht aus 6 Servomotoren, einem Arduino und zwei separaten Stromversorgungen.

Das Servomotoren benötigen zum Betrieb einen höheren Strom, sodass sie nicht über Arduino mit Strom versorgt werden dürfen . Deshalb benötigen wir zwei separate Stromquellen.

Bitte legen Sie eine Spannung an das Servo an, die für Mikroservomotoren geeignet ist. 4,8 V reichen aus. Wenn Sie sperrigere Servomotoren mit Strom versorgen möchten, legen Sie eine Spannung an, die der Nennleistung des Servos entspricht.

Bitte denken Sie daran, dass der Servomotor auch dann Strom verbraucht, wenn es keinen Moment gibt. Dies liegt daran, dass der Arm des Servomotors immer gegen Änderungen aus seiner kommentierten Position kämpft.

Programm für Empfänger:

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

Damit ist der Empfänger fertig.

So betreiben Sie dieses Projekt:

• Schalten Sie beide Stromkreise ein.
• Drehen Sie nun einen beliebigen Knopf des Potentiometers.
• Zum Beispiel 3. Potentiometer, das entsprechende Servo am Empfänger dreht sich.
• Dies gilt für alle Servomotoren und Potentiometer.

Hinweis: Sie können den Sender an einen Computer anschließen und den seriellen Monitor öffnen, um Daten wie den Winkel des Servomotors, den Spannungspegel am analogen Pin und das aktuell betriebene Potentiometer anzuzeigen.

Wenn Sie spezielle Fragen zu diesem Arduino-basierten Projekt für drahtlose Servomotoren haben, geben Sie im Kommentarbereich an, dass Sie möglicherweise eine schnelle Antwort erhalten.




Zurück: 200, 600 LED-String-Schaltung am Netz 220V Weiter: Sensorloser BLDC-Motorcontroller ohne Hochstrom mit Gegen-EMK