Bonjour,
J'aimerais savoir comment faire fonctionner une transmission radio via le module NRF24l01 (avec son adaptateur) d'un arduino uno à méga en réception. Je sais exactement où brancher les connections (pour le Uno et pour le mega), et j'utilise des codes qui on fonctionnés pour d'autres personnes (moi même n'étant pas très doué en programmation).
En realité j'avais construit il y a quelques années un robot fonctionnant avec ce système (donc avec cette transmission, des joystick, relais l298 etc..) et tout fonctionnait bien. Maintenant que je voudrais pouvoir en faire un autre, avec du matériel neuf, plus rien ne fonctionne. J'ai essayé d'ajouter des alims externes malgré l'adaptateur du NRF, j'ai essayé des versions simplifié du code mais rien ne fonctionne. Ma question est, y a t il d'autres raisons pour lesquelles cette transmission fonctionnerait pas ? En dehors de l'alimentation, de la fiabilité des modules et cartes ? J'ai bien sûr aussi mis à jours toutes librairies ou même le logiciel mais rien ne semble fonctionner.
Post mis dans la mauvaise section, on parle anglais dans les forums généraux. ➜ je l'ai déplacé vers le forum francophone pour vous pour cette fois...
Merci de prendre en compte les recommandations listées dans "Les bonnes pratiques du Forum Francophone”
dans les tutos j'ai 2 (vieux) codes
vous avez regardé s'ils fonctionnent ?
Merci beaucoup de votre réponse
J'ai essayé sur votre premier lien, les codes et voici ce qu'il y a dans le moniteur série "erreur d'envoi" lorsque j'essaye d'envoyer un caractère, toutes les connections sont là où elles doivent être alors je ne comprend pas trop d'où vient le probleme
Comment alimentez vous les modules ?
Photo ?
Bonjour raphael_thghtedzshh
Est tu sûre que l'Arduino "voit" ton module?
Charges le programme ci-dessous, renseignes les broches CE et CE:
RF24 radio(9, 10); //CE CS
Si ton module est vu ça donne à peu près:
SPI Speedz = 10 Mhz
STATUS = 0x0e RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=7 TX_FULL=0
RX_ADDR_P0-1 = 0x544d52687c 0xabcdabcd71
RX_ADDR_P2-5 = 0xc3 0xc4 0xc5 0xc6
TX_ADDR = 0x544d52687c
RX_PW_P0-6 = 0x01 0x01 0x01 0x01 0x01 0x01
EN_AA = 0x3f
EN_RXADDR = 0x02
RF_CH = 0x4c
RF_SETUP = 0x07
CONFIG = 0x0f
DYNPD/FEATURE = 0x03 0x06
Data Rate = 1 MBPS
Model = nRF24L01+
CRC Length = 16 bits
PA Power = PA_MAX
ARC = 0
Si pas vu:
SPI Speedz = 10 Mhz
STATUS = 0x00 RX_DR=0 TX_DS=0 TX_DF=0 RX_PIPE=0 TX_FULL=0
RX_ADDR_P0-1 = 0x0000000000 0x0000000000
RX_ADDR_P2-5 = 0x00 0x00 0x00 0x00
TX_ADDR = 0x0000000000
RX_PW_P0-6 = 0x00 0x00 0x00 0x00 0x00 0x00
EN_AA = 0x00
EN_RXADDR = 0x00
RF_CH = 0x00
RF_SETUP = 0x00
CONFIG = 0x00
DYNPD/FEATURE = 0x00 0x00
Data Rate = 1 MBPS
Model = nRF24L01+
CRC Length = Disabled
PA Power = PA_MIN
ARC = 0
Le programme de test:
#include <SPI.h>
#include "RF24.h"
#include "printf.h"
//------------------------------------- Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8
RF24 radio(9, 10); //CE CS
//------------------------------------- Topology
const uint64_t pipes[2] = { 0xABCDABCD71LL, 0x544d52687CLL }; // Radio pipe addresses for the 2 nodes to communicate.
void setup()
{
Serial.begin(115200);
printf_begin();
//----------------------------------- Setup and configure rf radio
radio.begin();
radio.setAutoAck(1); // Ensure autoACK is enabled
radio.enableAckPayload(); // Allow optional ack payloads
radio.setRetries(0,15); // Smallest time between retries, max no. of retries
radio.setPayloadSize(1); // Here we are sending 1-byte payloads to test the call-response speed
radio.openWritingPipe(pipes[1]); // Both radios listen on the same pipes by default, and switch when writing
radio.openReadingPipe(1,pipes[0]);
radio.startListening(); // Start listening
}
void loop(void)
{
Serial.println();
radio.printDetails(); // Dump the configuration of the rf unit for debugging
delay(2000);
}
A+
Cordialement
jpbbricole
Voici une photo du système
J'alimente les cartes arduino par le port USB du PC, pour le Uno :
Gnd Gnd
Vcc +5v
Ce 7
Csn 8
Sck 13
Mosi 11
Miso 12
Et pour le mega
Gnd Gnd
Vcc +5v
Ce, csn 7,8
Sck 52
Mosi 51
Miso 50
Quand je fais les tests je connecte une carte au pc par le port USB pour lire le moniteur serie pendant que j'alimente l'autre carte avec une alim externe 9v sur le vin
bonjour, merci de m'aider
J'ai donc testé en mettant CE et CSN sur 9 et 10 et voici ce qu'il y a dans le moniteur série pour le uno
en ce qui concerne le mega;
Ainsi pour le uno cela me semble bon mais j'ai quelques doutes pour le mega, surtout qu'en essayant de débrancher le mosi par exemple, le code affiche ce genre de choses
merci
Bonsoir raphael_thghtedzshh
Pour moi (je ne suis pas spécialiste), les 2 moniteurs me sembles plausibles et indiquent que les modules sont bien vus par leur Arduino respectifs.
Il te faudrait mettre les 2 programmes en ligne.
A+
jpbbricole
Je decouvre ce sujet.
Je vois des indications de fréquence SPI de 10 MHz.
Avec des micros avr (carte uno et méga), donc sans PLL, de fréquence d’horloge 16 MHz il me semblait que la fréquence max du SPI était 16/2 = 8 MHz.
oui, enfin même comme ça cela ne semble pas fonctionner
À vrai dire, cela commence à ressembler à une impasse, les modules NRF sont neufs, j'ai désinstallé et réinstallé toutes les librairies nécessaires... Ce pourrait-il que le problème vienne directement des cartes Arduino ?
Bonsoir raphael_thghtedzshh
D'après les monitorings ci-dessus, il me semble que non.
Mets tes 2 programmes en ligne.
Cordialement
jpbbricole
En ligne ? c'est à dire, je vous donne mes codes ?
Oui, en utilisant les balises idoines:
voici l'emeteur
//emeteur
#include <SPI.h>
#include "RF24.h"
int led1 = 4;
int led2 = 10;
const int bp2 = 3;
int bp1 = 0;
const int bp4 = 2;
const int bp15 = 5;
const int bpp1 = 9;
const int bpp2 = 6;
bool Nbpp1 = LOW;
bool lastButtonState = LOW;
bool Nbpp2 = LOW;
bool lastButtonState2 = LOW;
int UwU = 0;
int GT;
int GTb;
RF24 myRadio(7, 8);
byte addresses[][6] = {"0"};
struct package {
int X;
int Y;
int Xb;
int pot;
int Yb;
int potb;
int bp2;
int bp1;
int bpp1;
int bpp2;
int bp4;
};
typedef struct package Package;
Package data;
void setup() {
Serial.begin(115200);
delay(200);
myRadio.begin();
myRadio.setChannel(100);
myRadio.setPALevel(RF24_PA_LOW);
myRadio.setDataRate(RF24_250KBPS);
myRadio.setAutoAck(false);
myRadio.disableDynamicPayloads();
myRadio.setPayloadSize(sizeof(Package));
myRadio.openWritingPipe(addresses[0]);
myRadio.stopListening();
pinMode(bp2, INPUT_PULLUP);
pinMode(bp4, INPUT_PULLUP);
pinMode(bp15, INPUT_PULLUP);
pinMode(bpp2, INPUT_PULLUP);
pinMode(bpp1, INPUT_PULLUP);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop() {
int b2 = digitalRead(bp2);
int b4 = digitalRead(bp4);
int b15 = digitalRead(bp15);
int pot = analogRead(A5);
int buttonState = digitalRead(bpp1);
int buttonState2 = digitalRead(bpp2);
GTb = analogRead(A4);
data.Yb = analogRead(A3);
data.Y = analogRead(A2);
data.pot = pot;
data.bp2 = b2;
data.bp4 = b4;
if (buttonState == HIGH && lastButtonState == LOW) Nbpp1 = !Nbpp1;
lastButtonState = buttonState;
if (buttonState2 == HIGH && lastButtonState2 == LOW) Nbpp2 = !Nbpp2;
lastButtonState2 = buttonState2;
data.bpp1 = Nbpp1;
data.bpp2 = Nbpp2;
digitalWrite(led1, Nbpp1 == LOW);
digitalWrite(led2, Nbpp2 == LOW);
if ((data.Xb < 470 && data.X > 540 && b4 == HIGH && GTb > 512) ||
(data.Xb > 540 && data.X < 470 && b4 == HIGH && GTb > 512)) {
data.potb = 512;
} else {
data.potb = map(GTb, 1024, 0, 0, 1024);
}
UwU = (b15 == HIGH);
data.bp1 = UwU;
GT = analogRead(A1);
data.X = map(GT, 1024, 0, 0, 1024);
data.Xb = analogRead(A0);
myRadio.write(&data, sizeof(data));
Serial.println(data.Xb);
delay(20); // 50 Hz stable
}
et le recepteur
//recepteur
#include <SPI.h>
#include "RF24.h"
#include <Servo.h>
RF24 myRadio(7, 8);
byte addresses[][6] = {"0"};
struct package {
int X;
int Y;
int Xb;
int pot;
int Yb;
int potb;
int bp2;
int bp1;
int bpp1;
int bpp2;
int bp4;
};
typedef struct package Package;
Package data;
Servo monServo;
Servo monServo1;
Servo monServo2;
Servo monServo3;
Servo monServo4;
Servo monServo5;
Servo monServo6;
Servo monServo7;
Servo monServo8;
Servo monServo9;
int pinmonServo; // = 20;
int pinmonServo1;// = 21;
int pinmonServo2; //= 48;
int pinmonServo3; //= 19;
int pinmonServo4 ;//= 12;
int pinmonServo5 ;//= 13;
int pinmonServo6;// = 9;
int pinmonServo7; //= 10;
int pinmonServo8; //= 46;
int pinmonServo9;// = 44;
unsigned long lastReceiveTime = 0;
const unsigned long inactiveTimeout = 500;
void setup() {
pinMode(10, OUTPUT);
digitalWrite(10, HIGH);
Serial.begin(115200);
delay(300);
myRadio.begin();
myRadio.setChannel(100);
myRadio.setPALevel(RF24_PA_LOW);
myRadio.setDataRate(RF24_250KBPS);
myRadio.setAutoAck(false);
myRadio.disableDynamicPayloads();
myRadio.setPayloadSize(sizeof(Package));
myRadio.openReadingPipe(1, addresses[0]);
myRadio.startListening();
monServo.attach(pinmonServo);
monServo1.attach(pinmonServo1);
monServo2.attach(pinmonServo2);
monServo3.attach(pinmonServo3);
monServo4.attach(pinmonServo4);
monServo5.attach(pinmonServo5);
monServo6.attach(pinmonServo6);
monServo7.attach(pinmonServo7);
monServo8.attach(pinmonServo8);
monServo9.attach(pinmonServo9);
Serial.println("RECEPTEUR PRET");
}
void loop() {
if (myRadio.available()) {
myRadio.read(&data, sizeof(data));
lastReceiveTime = millis();
Serial.print("RX pot=");
Serial.print(data.pot);
Serial.print(" X=");
Serial.print(data.X);
Serial.print(" Xb=");
Serial.println(data.Xb);}
if (millis() - lastReceiveTime > inactiveTimeout) {
monServo9.write(55);
monServo8.write(100);
monServo7.write(114);
monServo6.write(104);
monServo5.write(120);
monServo4.write(112);
monServo2.write(115);
monServo1.write(103);
monServo.write(106);
return;
}
int X = data.X;
int Y = data.Y;
int Xb = data.Xb;
int Yb = data.Yb;
int pot = data.pot;
int potb = data.potb;
int bp2 = data.bp2;
int bp1 = data.bp1;
int bpp1 = data.bpp1;
int bpp2 = data.bpp2;
// ---------- MOTEUR GAUCHE ----------
if (X < 460) monServo.write(121);
else if (X > 560) monServo.write(89);
else monServo.write(106);
// ---------- MOTEUR DROIT ----------
if (Xb < 460) monServo1.write(118);
else if (Xb > 560) monServo1.write(87);
else monServo1.write(103);
// ---------- COUPE MOTEUR ----------
if (bp2 == HIGH) monServo2.write(105);
else monServo2.write(115);
// ---------- ACCÉLÉRATEUR ----------
int angle = map(pot, 1020, 0, 0, 180);
monServo3.write(angle);
// ---------- LEVAGE RAIL ----------
if (Yb < 460) monServo4.write(124);
else if (Yb > 560) monServo4.write(97);
else monServo4.write(112);
// ---------- LEVAGE PATTES ----------
if (Y < 460) monServo5.write(135);
else if (Y > 560) monServo5.write(105);
else monServo5.write(120);
// ---------- DIFFÉRENTIEL ----------
monServo6.write(bpp1 ? 112 : 104);
monServo7.write(bpp2 ? 104 : 114);
// ---------- BIELLE ----------
monServo8.write(bp1 ? 100 : 125);
// ---------- ACCÉLÉRATEUR DÉBROU ----------
int angleb = map(potb, 1020, 0, 0, 55);
monServo9.write(angleb);
}
dans l'émetteur, charges ce programme:
#include <SPI.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
int compteur = 0;
void setup() {
Serial.begin(115200);
radio.begin();
radio.setChannel(100);
radio.setPALevel(RF24_PA_LOW);
radio.setDataRate(RF24_250KBPS);
radio.openWritingPipe(address);
radio.stopListening();
}
void loop() {
bool ok = radio.write(&compteur, sizeof(compteur));
Serial.print("Envoi : ");
Serial.print(compteur);
Serial.print(" | ");
Serial.println(ok ? "OK" : "ECHEC");
compteur++;
delay(1000);
}
et dans le récepteur, celui-ci:
#include <SPI.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
int compteurRecu;
void setup() {
Serial.begin(115200);
radio.begin();
radio.setChannel(100);
radio.setPALevel(RF24_PA_LOW);
radio.setDataRate(RF24_250KBPS);
radio.openReadingPipe(1, address);
radio.startListening();
}
void loop() {
if (radio.available()) {
radio.read(&compteurRecu, sizeof(compteurRecu));
Serial.print("Reçu : ");
Serial.println(compteurRecu);
}
}
et dis moi ce qui se passe. (je n'ai pas pû essayer)
et avec les test du post #8, tu as les mêmes résultats?
Je ne suis pas sûr de comprendre, au post 8 il s'agissait de vérifier la communication entre le module et la carte dans lequel rien ne semblait dysfonctionnel