Commande de servomoteur sans fil à l'aide d'une liaison de communication 2,4 GHz

Dans cet article, nous allons construire un circuit de servomoteur sans fil pouvant contrôler 6 servomoteurs sans fil sur une liaison de communication 2,4 GHz.

introduction

Le projet est divisé en deux parties: un émetteur avec 6 potentiomètres et un circuit récepteur avec 6 servomoteurs .

La télécommande dispose de 6 potentiomètres pour contrôler 6 servomoteurs individuels indépendamment au niveau du récepteur. En tournant le potentiomètre, l'angle du le servomoteur peut être contrôlé .

Le circuit proposé peut être utilisé lorsque vous avez besoin d'un mouvement contrôlé, par exemple le bras d'un robot ou le contrôle de la direction de la roue avant d'une voiture RC.

Le cœur du circuit est le module NRF24L01 qui est un émetteur-récepteur il fonctionne sur la bande ISM (bande industrielle, scientifique et médicale) c'est la même bande de fréquence que votre WI-FI fonctionne.

Illustration des modules NRF24L01:

Il dispose de 125 canaux, d'un débit de données maximal de 2 Mbps et d'une portée maximale théorique de 100 mètres. Vous aurez besoin de deux de ces modules pour établir une liaison de communication.

Configuration des broches:

Il fonctionne sur le protocole de communication SPI. Vous devez connecter 7 des 8 broches à Arduino pour que ce module fonctionne.

Il fonctionne sur 3,3 V et 5 V tue le module, il faut donc faire attention lors de la mise sous tension. Heureusement, nous avons à bord un régulateur de tension 3.3V sur Arduino et il doit être alimenté uniquement à partir de la prise 3.3V d'Arduino.

Passons maintenant au circuit émetteur.

Circuit émetteur:

Le circuit se compose de 6 potentiomètres d'une valeur de 10K ohm. La borne centrale de 6 potentiomètres est connectée aux broches d'entrée analogiques A0 à A5.

Le tableau est donné à côté du schéma de la connexion NRF24L01 à Arduino que vous pouvez vous référer, si vous avez une confusion dans le schéma de circuit.

Ce circuit peut être alimenté par une batterie USB ou 9V via une prise CC.

Veuillez télécharger le fichier de bibliothèque ici: github.com/nRF24/

Programme pour l'émetteur:

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

Cela conclut l'émetteur.

Le récepteur:

Le circuit récepteur se compose de 6 servomoteurs, d'un Arduino et de deux blocs d'alimentation séparés.

Le Les servomoteurs ont besoin d'un courant plus élevé pour fonctionner, ils ne doivent donc pas être alimentés par arduino . C’est pourquoi nous avons besoin de deux sources d’alimentation distinctes.

Veuillez appliquer la tension au servo de manière appropriée pour les micro servomoteurs 4.8V suffit, si vous voulez alimenter des servomoteurs plus volumineux, appliquez une tension correspondant à la valeur nominale du servo.

N'oubliez pas que le servomoteur consomme de l'énergie même en l'absence de moment, c'est parce que le bras du servomoteur lutte toujours contre tout changement par rapport à sa position commentée.

Programme pour le récepteur:

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

Cela conclut le récepteur.

Comment faire fonctionner ce projet:

• Alimentez les deux circuits.
• Tournez à présent l’un des boutons du potentiomètre.
• Par exemple 3ème potentiomètre, le servo correspondant sur le récepteur tourne.
• Ceci s'applique à tous les servomoteurs et potentiomètres.

Remarque: vous pouvez connecter l'émetteur à l'ordinateur et ouvrir le moniteur série pour voir les données telles que l'angle du servomoteur, le niveau de tension sur la broche analogique et le potentiomètre actuellement utilisé.

Si vous avez des questions spécifiques concernant ce projet de servomoteur sans fil basé sur Arduino, veuillez exprimer dans la section des commentaires vous pouvez recevoir une réponse rapide.