Télémétrie, me voilà !!!

Salut à tous,
En ce jour, j'ai réussi à communiquer entre deux Arduino les données d'un capteur de température TMP36 avec deux modules nRF24L01+antenne (portée 1 km en terrain dégagé d'après des tests publiés sur youtube).
Je possède un module GPS Ublock NEO6-M, un capteur BMP180, je connais le code pour ces deux là et celui pour la transmission RF de données.
Maintenant y a plus qu'à !
Je mettrais des photos du montage, des modules nRF24L01 et le code arduino bientôt.
On va pouvoir recevoir les données de vol en direct !
Amicalement,
Romuald

Voici le code Arduino que j'ai employé :

*********************************Partie Transmetteur **************

/*

Radio    Arduino
CE    -> 7
CSN   -> 8 (Hardware SPI SS)
MOSI  -> 11 (Hardware SPI MOSI)
MISO  -> 12 (Hardware SPI MISO)
SCK   -> 13 (Hardware SPI SCK)
IRQ   -> Rien
VCC   -> En dessous de 3.6 volts
GND   -> GND



*/


#include
#include

const static uint8_t RADIO_ID = 1;             // Numéro d'indentification de notre module émetteur
const static uint8_t DESTINATION_RADIO_ID = 0; // Numéro d'identification du module récepteur (A qui notre émetteur transmet)
const static uint8_t PIN_RADIO_CE = 7;//déclaration du pin CE
const static uint8_t PIN_RADIO_CSN = 8;//déclaration du pin CSN

const int L1 = 3; // broche 3 se nomme maintenant L1, verification de la communication
const int L2 = 4; // broche 4 se nomme maintenant L2, état de l'initialisation
const int L3 = 5; // broche 5 se nomme maintenant L3, accusé de réception
const int L4 = 6; // broche 6 se nomme maintenant L4 accusé de réception


int sensorPin = 0; // valeur renvoyéee par le TMP36 à transmettre

struct RadioPacket // Packet de données envoyé,
//uint8_t=variable sur 8 bit, uint32_t=variable sur 32 bit
{
   uint32_t sensorPin;//variable sensorPin codée sur 32 bit
};

NRFLite _radio; //Déclaration du module NRF
RadioPacket _radioData;//Déclaration du packet de données

void setup()
{
 pinMode(L1, OUTPUT); // déclaration de la broche de sortie
 pinMode(L2, OUTPUT); // déclaration de la broche de sortie
 pinMode(L3, OUTPUT); // déclaration de la broche de sortie
 pinMode(L4, OUTPUT); // déclaration de la broche de sortie

     
   if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))//si l'initialisation du module n'est pas finie
   {
       digitalWrite(L1,HIGH);
       while (1); // Attend
   }
       digitalWrite(L2,HIGH);
   
}

void loop()
{
    _radioData.sensorPin=analogRead(A0);//lecture de la valeur du TMP36
 
   
 if (_radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData))) //Si le module récepteur confirme qu'il a bien recu le message
   {
       digitalWrite(L3,HIGH);
   }
   
   else
   {
       digitalWrite(L4,HIGH);
   }

   delay(1);//pause de 10 milli secondes
   
   /*
   Par défaut la commande _radio.send transmet les données puis attend pour un accusé de réception
   
   Il est possible de changer cette condition avec ces commandes :
   
   _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::NO_ACK)//pas d'accusé de réception
   _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::REQUIRE_ACK) // par défaut , accusé de réception
   */
}



*********************************Partie Récepteur **************


/*

Radio    Arduino
CE    -> 7
CSN   -> 8 (Hardware SPI SS)
MOSI  -> 11 (Hardware SPI MOSI)
MISO  -> 12 (Hardware SPI MISO)
SCK   -> 13 (Hardware SPI SCK)
IRQ   -> Rien
VCC   -> En dessous de 3.6 volts
GND   -> GND



*/
#include
#include

const static uint8_t RADIO_ID = 0;       // Numéro d'indentification de notre module récepteur
const static uint8_t PIN_RADIO_CE = 7; //déclaration du pin CE
const static uint8_t PIN_RADIO_CSN = 8;//déclaration du pin CSN


struct RadioPacket // Packet de données envoyé,
//uint8_t = variable sur 8 bit, uint16_t=variable sur 16 bit, uint32_t=variable sur 32 bit
{
   uint32_t sensorPin;//variable Valeur codée sur 32 bit
};

NRFLite _radio; //Déclaration du module NRF
RadioPacket _radioData;//Déclaration du packet de données

void setup()
{
   Serial.begin(115200);//On ouvre la laison série avec le PC à 115200 baud


   if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))//si l'initialisation du module n'est pas finie
   {
       Serial.println("L'arduino ne peut pas communiquer avec le module ");
       while (1); // Attend
   }
   Serial.println("Setup fini");
   
   /*
   Par défaut la vitesse est de 2mb/s sur la channel 100/125
   L'émetteur et le recepteur doivent etre sur la même channel et avoir la même vitesse pour bien communiquer
   
   Il est possible de changer ces paramtres avec les commandes:    
   
   _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE250KBPS, 0)//250kB/s channel 0
   _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE1MBPS, 75)//1 MB/s channel 75
   _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE2MBPS, 100) // par défaut
   */
}

void loop()
{
   while (_radio.hasData())//Tant que le module NRF a des données
   {
       _radio.readData(&_radioData); // lecture des nouvelles données


// converting that reading to voltage, for 3.3v arduino use 3.3
    float voltage = (_radioData.sensorPin * 5.0)/1024;
    float mvoltage = (voltage*1000);
    float temperatureC = (mvoltage - 500)/14 ;  //converting from 10 mv per degree wit 500 mV offset
                                                  //to degrees ((voltage - 500mV) times 100)

       Serial.println(temperatureC);//afficher sur le pc la valeur recue
       
   }
}


Les photos (et peut-être une vidéo) vont suivre !

cool, merci pour le partage romu.

Le matériel nécessaire :
- 2 modules nRF24l01+PA+LA comme celui là https://www.amazon.fr/Lidahaotin-Module-nRF24L01-antenne-interurbaine/dp/B07LGQDWGF/ref=sr_1_3?ie=UTF8&qid=1550494064&sr=8-3&keywords=nRF24L01+%2B+pa+%2B+module+sans+fil+lna+%28avec+antenne%29

- 2 modules adaptateurs pour nRF24l01 5V vers 3.3V comme ceux-là https://www.banggood.com/fr/2Pcs-Socket-Adapter-Plate-For-8Pin-NRF24L01-Wireless-Module-p-943160.html?p=AF09072066279201508W&cur_warehouse=CN

- 2 arduino Uno qui peuvent être remplacés par nano ou mini, plus facile à mettre dans nos fusées
- 4 LEDs (2 rouges de vertes)  qui servent de contrôle de bon ou mauvais fonctionnement
- 4 résistances 200 Ohms
- 1 capteur de température TMP36 comme celui-ci https://www.amazon.fr/Adafruit-TMP36-Analog-Temperature-sensor/dp/B011NEQ7J4/ref=sr_1_4?ie=UTF8&qid=1550494493&sr=8-4&keywords=TMP36
Il pourra être remplacé à l'avenir par un module GPS ou un capteur BMP180 ou gyroscope (code à adapter en fonction de ce qu'on utilise)
- des fils de connexion Arduino

Les schémas de cablage :

************************* Partie Transmetteur **************************


************************* Partie Récepteur **************************

je ne connaissais pas ces modules
perso j'utilise les modules 3DR pour la telemetrie. Ils utilisent le port serie ou USB ce qui fait que j'ai besoin d'un seul arduino et je peux brancher l'autre sur la tablette/telphone ou PC

en revanche tes modules sont sympa car je me verrai bien les utiliser vu leur prix pour faire des communications entre les parties de la fusée sans avoir à faire courrir des fils

si tu veux faire de la telemetrie et afficher tes resultats sur PC je te conseille d'apprendre processing

Félicitations Romuald !
Tu nous feras une démo à notre prochaine rencontre.

ça me parait très intéressant !!

bdureau a écrit:si tu veux faire de la telemetrie et afficher tes résultats sur PC je te conseille d'apprendre processing

Pour le moment j'utilise le moniteur sériel de l'interface Arduino.
Je vais regarder Processing.

BENJAMIN59 a écrit:Tu nous feras une démo à notre prochaine rencontre.

Je pense tester sur une fusée lors de nos prochains lancements et je serai ravi de pouvoir vous faire une démo.

Amicalement,
Romuald

PS : si vous avez des tutos pour processing, simple à comprendre avec des exemples pour débuter, je suis preneur.

Je vais aussi voir à utiliser les cartes ESP32 comme celles utilisées par François.

Utiliser des ESP32 est certainement une bonne idée car cela permet d'avoir tout d'intégré et c'est certainement des cartes très rapides.

Pour processing tu trouveras des exemples avec la version que tu téléchargeras.
L'idée c'est de lire les données sur le port serie et de les afficher, tu pourrai faire comme moi, afficher la courbe de l'altitude en fonction du temps. Processing a plein de bibliotheques qui simplifient les choses. C'est du langage Java et ça fonctionne comme Arduino sur le principe de construction des programmes

Bonjour, oui voilà ce que j'ai lu sur amazon :

Lidahaotin 1set / lot Module sans Fil nRF24L01 + PA + LNA avec antenne 1000 mètres interurbaine
de Lidahaotin
Soyez la première personne à écrire un commentaire sur cet article
Prix : EUR 2,91 LIVRAISON GRATUITE.
Tous les prix incluent la TVA.
1 neuf à partir de EUR 2,91

Le nRF24L01 + est un émetteur-récepteur dans la bande ISM de 2,4 GHz
Portée: 800+ mètres ligne de mire
Un microcontrôleur hôte peut communiquer et configurer le nRF24L01 + sur une interface périphérique série 4 broches (SPI).
Les registres de configuration sont accessibles via la connexion SPI.
Les paramètres configurables comprennent le canal de fréquences (125 canaux sélectionnables), puissance de sortie,
et le débit binaire (taux de données: 250 kbps, 1 Mbps, et 2Mbps)
Le régulateur de tension sur puce accepte des tensions d'alimentation de 1,9 à 3,6 V
Le module possède des entrées 5V tolérantes ce qui permet un raccordement direct de broches SPI à l'Arduino