Module émetteur-récepteur Transparent

Bonjour,

Je viens de recevoir ca :

Il semblerait que ce soit super facile à utiliser par rapport à d'autres modules Récepteur / Transmetteur.
Le problème est que je ne trouve aucun datasheet ni aucun site ou forum qui en parle et je suis complètement paumé :frowning:

J'ai bien trouvé un post dans ce forum qui parle d'un autre module qui y ressemble fortement et qui fait référence a cette page :
https://forum.hobbycomponents.com/viewtopic.php?f=74&t=1869

Mais encore une fois je comprends rien :frowning: ils parlent de mettre le même ID pour communiquer et donc changer avec les commandes AT. Mais je comprends même pas comment rentrer dans le mode AT :confused:
ils parlent de mettre à 0 ou en LOW la pin CMD mais ils disent pas comment faire ca.

Bref, je suis un peu désorienté pour démarrer.
Pourriez-vous me donner un coup de pouce juste pour comprendre comment le module fonctionne ?
Merci par avance pour votre aide.

Bonsoir
Comment mettre a 0 l'entrée CMD ?
Avec un fil relié entre CMD et GND
C'est...... fastoche....

C'est mieux quand on le sait :wink:
Grand merci !

Je continue ma galère de "découverte" ! Merci beaucoup.

Il semblerait que ce soit super facile à utiliser par rapport à d'autres modules Récepteur / Transmetteur.
Le problème est que je ne trouve aucun datasheet ni aucun site ou forum qui en parle

si personne n'en parle qui peut dire que c'est super facile à utilser ......à part le vendeur ?

Bref, je suis un peu désorienté pour démarrer.

Mieux vaut commander des modules bien documentés si on veut s'éviter de découvrir soi même comment les utilser

Ceci dit avant de modifier les configurations par des commandes AT , tester la communication avec les configurations d'usine. Il se pourrait que les transceivers soint livrés avec la même configuration par défaut (canal, id...) permettant ainsi une liaison sans préparartion. Cela se fait souvent pour d'autres transceivers.
tester les codes emetteur et récepteur du second site

Merci pour tes conseils !

Ceci dit c'est parce que malgré les différents tests réalisés avec mes petites connaissances, je n'ai pas réussi a les faire communiquer. Et je suis tombé sur ces commandes AT, donc pour cela que je voulais essayer cela.
Mais bon c'est pas gagner, j'arrive quand même pas a mettre une commande AT qui me sorte une réponse :confused:

  1. Tu n'as aucune garantie que les modules des deux sites disposent du même jeu de commandes AT
  2. comment testes-tu une commande AT ? avec quel montage ? quelle procédure ?

Je fais comme ça :
Les branchements :
Module -> Arduino Uno
Vdd -> 5v
Gnd -> gnd
Txd -> rx
Rxd -> tx
Cmd -> gnd (donc pour activer les commandes)

J’ai suivi ce doc que j’ai reçu cet après midi par le vendeur à qui j’ai demandé des infos il y a quelques jours :
https://drive.google.com/folderview?id=0B6uNNXJ2z4CxLUlEMTQzRTNMU0U&usp=sharing

Ensuite je teste la commande suivante dans le moniteur : AT+BAUD?

Mais j’obtiens pas de réponse.
Merci pour ton aide.

Une carte Uno n'est pas ce qu'il ya de mieux comme intermédaire entre PC et module radio !!
Un adaptateur FTDI ou équivalent serait bien mieux

Si tu n'as rien d'autre qu'une carte UNO pour cette fonction relies les RX ensemble et les Tx ensemble, ne croises pas comme d'habitude. Pour ces tests de commandes AT à partir de la console , le module prend la place du microcontrolleur, il ne dialogue pas avec lui donc pas de croisement.

Règles la console sur 9600bauds, choisis l'option 'pas de fin de ligne", fais en sorte que CMD soit à la masse avant la mise sous tension du module radio et testes AT+BAUD? pour connaître le débit en mode 'transparent'
(le débit en mode AT est , lui, imposé à 9600 bauds)

super ! ca fonctionne :slight_smile: j’ai bien un retour.
Je suis bien en BAUD 9600 sur les 2 modules et un RID et TID = 0x5555555555 sur les 2 modules.
Donc je comprends que mes modules doivent être ne mesure de communiquer.

Je refais des tests …
Je ne voudrais pas abuser mais si tu sais me donner un script simple pour envoyer un message, je suis preneur.
Avec un NRF24, il y a des bibliothèques spécifiques et des fonctions a utiliser mais apparemment pour celui ci y’a rien de spécial, du coup je suis pas très sur de ce que je dois utiliser … j’ai compris que c’etait directement au travers des fonctions du moniteur serie (!?) mais je pensais que le moniteur ne faisait que du local.
Bref … merci beaucoup en tout les cas ! :slight_smile:

re,

J'ai pris soin de retirer le CMD du ground et de mettre le Rx du module vers le Tx du Arduino Uno pour tester.
(Le destinataire est un arduino Nano qui est branché egalement avec les Tx -> Rx et Rx -> Tx)

En m'inspirant du lien dans mon premier post, j'ai tenté ce code pour le Transmetteur (Tx) :

void setup() 
{
  Serial.begin(9600);
}

void loop() 
{
  Serial.println("test");
  delay(1000);
}

et celui la pour le receveur (Rx):

void setup() 
{
  Serial.begin(9600);
}

void loop() 
{
  char Data;

  /* Has a byte of data been recived? */
  if (Serial.available() > 0) 
  {
    /* If so then get the data */
    Data = Serial.read();

    Serial.println(Data);
  }
}

Je ne recois pas les message à l'arrivée :frowning:
J'ai merdouillé quelquepart dans le code ?

Merci par avance.

l’unique port série matériel des ATMega328 étant (sur la carte Uno) utilisé pour la connection au PC par l’USB ,
créer un second port série (logiciel) pour la liaison au module.
Chacun son port série , un pour le PC , un pour le module !!
Pour cela chercher des exemples avec SoftwareSerial(),
A 9600 bauds cela fonctionne sans problème.

(sources d 'inspiration : liaison série à travers des HC12 ou des modules Bluetooth)

Compris !!
Vais tester tout ca !

Merci.

Hello,

Je reviens sur ce post, je suis encore bloqué et je comprends pas pourquoi :frowning:
Un problème de communication entre mes modules de communications :confused:

J’essaye de réaliser le projet de Joop Brokking qu’on peut trouver ici : Brokking.net - Your Arduino Balancing Robot (YABR) - Home.
Alors j’ai tout pareil que lui sauf que mon robot est monté avec un arduino nano et des controleur de moteur différents (A4988).
J’ai réussi (non sans mal) a faire tenir debout le robot :slight_smile: il reste bien stabilisé.
J’ai créé le même joystick que lui avec un nunchuck et le meme composant de communication.
Je pense que ca communique parce que lorsque j’actionne le nunchuck, je vois bien une petite lumiere bleue sur le module de comm qui s’active de chaque coté.
Par conte le robot ne bouge pas d’un poil :frowning: comme s’il envoyait pas de données ou pas les bonnes données …

Voici le code du nunchuck que je n’ai pas besoin de modifier normalement :

#include <Wire.h>                                                   //Include the Wire.h library so we can communicate with the Nunchuck

int nunchuk_address = 0x52;                                         //Nunchuk I2C address (0x52)
byte received_data[6], send_byte;                                   //Declare some global byte variables

void setup(){
  Serial.begin(9600);                                               //Start the serial port at 9600 kbps
  Wire.begin();                                                     //Start the I2C as master
  TWBR = 12;                                                        //Set the I2C clock speed to 400kHz
  Wire.begin();                                                     //Start the I2C bus as master
  delay(20);                                                        //Short delay
  Wire.beginTransmission(nunchuk_address);                          //Start communication with the Nunchuck
  Wire.write(0xF0);                                                 //We want to write to register (F0 hex)
  Wire.write(0x55);                                                 //Set the register bits as 01010101
  Wire.endTransmission();                                           //End the transmission
  delay(20);                                                        //Short delay
  Wire.beginTransmission(nunchuk_address);                          //Start communication with the Nunchuck
  Wire.write(0xFB);                                                 //We want to write to register (FB hex)
  Wire.write(0x00);                                                 //Set the register bits as 00000000
  Wire.endTransmission();                                           //End the transmission
  delay(20);                                                        //Short delay
}

void loop(){
  Wire.beginTransmission(nunchuk_address);                          //Start communication with the Nunchuck.
  Wire.write(0x00);                                                 //We want to start reading at register (00 hex)
  Wire.endTransmission();                                           //End the transmission
  Wire.requestFrom(nunchuk_address,6);                              //Request 6 bytes from the Nunchuck
  for(byte i = 0; i < 6; i++) received_data[i] = Wire.read();       //Copy the bytes to the received_data array
  send_byte = B00000000;                                            //Set the send_byte variable to 0
  if(received_data[0] < 80)send_byte |= B00000001;                  //If the variable received_data[0] is smaller then 80 set bit 0 of the send byte variable
  if(received_data[0] > 170)send_byte |= B00000010;                 //If the variable received_data[0] is larger then 170 set bit 1 of the send byte variable
  if(received_data[1] < 80)send_byte |= B00001000;                  //If the variable received_data[1] is smaller then 80 set bit 3 of the send byte variable
  if(received_data[1] > 170)send_byte |= B00000100;                 //If the variable received_data[1] is larger then 170 set bit 2 of the send byte variable
  if(send_byte)Serial.print((char)send_byte);                       //Send the send_byte variable if it's value is larger then 0
  delay(40);                                                        //Create a 40 millisecond loop delay

}

pour voir ce qu’il envoie, j’ai ajoutté à la fin ca :

      Serial.println(send_byte);
      delay(100);

et il affiche des infos du type :

0
0
0
4
4
4
4
0
8
8
8
1
1
1
1
1
0
0
2
2
2

Et normalement il doit renvoyer juste des :
0
0
2
2
8
8
4
4

Est-ce a cause de mon affichage qui n’est pas bon :

      Serial.println(send_byte);
      delay(100);

Ou y a t-il une coquille dans le script de Joop Brokking ? ou avez-vous une autre piste à me proposer ?

Merci pour votre aide.

re,

Bon j'ai reussi a virer les caractères bizarre ... en retirant le (char) ici :

if(send_byte)Serial.print((char)send_byte);

en mettant comme ca :

if(send_byte)Serial.print(send_byte);

par contre j'ai l'impression que les données sont pas recu de l'autre coté :confused:

Hello,

Vraiment je m’en sort pas :’( Help please …

Voila ou j’en suis : Pour rappel mon objectif est de commander le robot avec le nunchuk comme dans la vidéo de Joop Brokking. Le robot tiens debout et est stable.

Le joystick nécessite aucune modif normalement mais ca marche pas :frowning: alors j’ai cherché a vérifié si les infos étaient bien envoyé du Nunchuk vers le robot …
A force de recherche j’ai pu vérifier que mes modules fonctionnait bien avec les codes suivants :

Transmetteur :

#include <SoftwareSerial.h>

SoftwareSerial HC12(10,11); // HC-12 TX Pin, HC-12 RX Pin

void setup() {
  Serial.begin(9600);             // Serial port to computer
  HC12.begin(9600);               // Serial port to HC12
}
void loop() {

  while (Serial.available()) {      // If Serial monitor has data
    HC12.write(Serial.read());      // Send that data to HC-12
  }
}

Récepteur :

/*    
Module Radio : Arduino
TxD : 10
RxD : 11 (utilisé pour le Transmetteur)
VDD : 5V
GND : GND
*/
#include <SoftwareSerial.h>

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin

void setup() {
  Serial.begin(9600);             // Serial port to computer
  HC12.begin(9600);               // Serial port to HC12
}
void loop() {
  while (HC12.available()) {        // If HC-12 has data
    Serial.write(HC12.read());      // Send the data to Serial monitor
  }
}

La ca marche, quand je tape un message dans le premier moniteur, il apparait dans le second.

Je cherche donc maintenant a adapter le code de mon Joystick Nunchuk pour vérifier qu’en face il reçoit bien les infos.

Voici le code de ma télécommande (qui m’affiche bien les infos de mon nunchuk sur le moniteur) :

#include <Wire.h>                                                   //Include the Wire.h library so we can communicate with the Nunchuck
#include <ArduinoNunchuk.h>

byte send_byte;                                   //Declare some global byte variables

//Instancier la manette Wii Nunchuck
ArduinoNunchuk nunchuk = ArduinoNunchuk();

void setup(){
  Serial.begin(9600);                                               //Start the serial port at 9600 kbps
  nunchuk.init();   //Initialiser la Nunchuck
}

void loop(){

  nunchuk.update();  //lecture des donnees --> nunchuk.analogX, nunchuk.analogY
 
  send_byte = B00000000;                                            //Set the send_byte variable to 0
  if(nunchuk.analogX < 80)send_byte |= B00000001;                  //If the variable received_data[0] is smaller then 80 set bit 0 of the send byte variable
  if(nunchuk.analogX > 170)send_byte |= B00000010;                 //If the variable received_data[0] is larger then 170 set bit 1 of the send byte variable
  if(nunchuk.analogY < 80)send_byte |= B00001000;                  //If the variable received_data[1] is smaller then 80 set bit 3 of the send byte variable
  if(nunchuk.analogY > 170)send_byte |= B00000100;                 //If the variable received_data[1] is larger then 170 set bit 2 of the send byte variable
  if(send_byte)Serial.print(send_byte);                       //Send the send_byte variable if it's value is larger than 0
  delay(40);
}

Maintenant j’essaye de l’adapter avec le SoftwareSerial pour vérifier qu’en face (je ne change pas le code du Récepteur plus haut) il reçoit bien les infos :

#include <Wire.h>                            //Include the Wire.h library so we can communicate with the Nunchuck
#include <ArduinoNunchuk.h>
#include <SoftwareSerial.h>

SoftwareSerial HC12(10,11);                 // HC-12 TX Pin, HC-12 RX Pin

byte send_byte;                             //Declare some global byte variables

//Instancier la manette Wii Nunchuck
ArduinoNunchuk nunchuk = ArduinoNunchuk();

void setup(){
  Serial.begin(9600);                      //Start the serial port at 9600 kbps
  nunchuk.init();                          //Initialiser la Nunchuck
  HC12.begin(9600);                        // Serial port to HC12
}

void loop(){

  nunchuk.update();                         //lecture des donnees --> nunchuk.analogX, nunchuk.analogY
 
  send_byte = B00000000;                               //Set the send_byte variable to 0
  if(nunchuk.analogX < 80)send_byte |= B00000001;      //If the variable received_data[0] is smaller then 80 set bit 0 of the send byte variable
  if(nunchuk.analogX > 170)send_byte |= B00000010;     //If the variable received_data[0] is larger then 170 set bit 1 of the send byte variable
  if(nunchuk.analogY < 80)send_byte |= B00001000;      //If the variable received_data[1] is smaller then 80 set bit 3 of the send byte variable
  if(nunchuk.analogY > 170)send_byte |= B00000100;     //If the variable received_data[1] is larger then 170 set bit 2 of the send byte variable
  //if(send_byte)Serial.print(send_byte);              //Send the send_byte variable if it's value is larger than 0
    if (send_byte) {
      Serial.print(send_byte);
      HC12.write(Serial.read());
    }
  delay(40);                                                        //Create a 40 millisecond loop delay
}

Mais en face, il reçoit pas les bons caractères :frowning: il affiche des “⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮” à la place :frowning:

Auriez-vous une idée sur le problème ?
Merci d’avance.

côté récepteur le moniteur série est-il configuré (en bas à droite) sur le bon débit ?

Hello,
Oui j’ai vérifié justement. C’est bien le bon débit.

Si ton byte de base vaut B00000000 et que tu lui ajoutes B00000001 (0x01) ou B00000010 (0x02) ou B00000100 (0x04) ou B00001000 (0x08) il est assez normal qu'un println() côté récepteur affiche des ?. C'est du binaire pur.
Il faut afficher la valeur en HEXA (sprintf() par exemple), avec "%x".

J'ai probablement tort. SoftwareSerial::read() renvoie un int.
Je n'avais pas vu que tu utilises Serial.write(HC12.read()).
Donc utilise plutôt : Serial.print(HC12.read()), qui fera la conversion tout seul.

J'avais testé avec le print a la place du write mais ca ne fonctionnait pas, par contre je sais plus ce qu'il me faisait comme résultat :confused:
Tout de suite je peux pas mais je refait le test asap pour vérifier.
Merci.