Récepteur de radiocommande de modélisme 2.4 Ghz avec Arduino

Utilisation de capteurs et composants électroniques avec Arduino.
Une fiche de tutoriel pour chaque.

Récepteur de radiocommande de modélisme 2.4 Ghz avec Arduino

Messagepar tiptop » Lun 26 Aoû 2013 22:43

Récepteur de radiocommande de modélisme 2.4 Ghz avec Arduino

Image.Image

Composants utilisés

Principe de fonctionnement
Une télécommande de radio-modélisme 2.4 GHz communique à longue distance avec un récepteur associé.
Cette technologie est bon marché, fiable, prêtes à l'emploi, à longue portée et sans brouillage.

Le récepteur peut être interfacé avec une carte Arduino pour récupérer et traiter la sortie de chaque canal.

Câblage
Le récepteur à 3 canaux comporte 4 prises. De haut en bas
  • Vcc
  • bind/ch3
  • ch2
  • ch1

Image
Image

Câblage (avec des fils mâle/femelle), sur le récepteur RC de gauche à droite --> Arduino
  • Plus, fil rouge V 5V
  • Moins, fil noir, GND --> GND
  • Signal, fil orange ou blanc, commandes de ch1, ch2, ch3 --> pin5 pin6 pin7...

Image

Signaux codés PPM en sortie du récepteur

Les sorties du récepteur permettent de piloter directement des servomoteurs de modélisme ou un contrôleur de vitesse de moteur (BEC) sur les sorties ch1, ch2...

La commande est un signal numérique de période constante 20 ms (50 Hz), codé en largeur d'impulsions (PPM).
  • 1 ms high correspond à 0% (full brake, reverse)
  • 1.5 ms correspond au point neutre (neutral throttle).
  • 2 ms high correspond à 100% de commande (full throttle).


Caractéristiques techniques
La télécommande de modélisme fonctionne en 2.4 GHz, modulation GFSK, alimentée en 12v.
Le récepteur est alimenté de 4.5 à 6V (pile 5V, Ubec, ou pin 5V de l'Arduino...)
Les différents canaux sont indépendants.

Apparier la télécommande avec son récepteur

Chaque récepteur comporte une adresse unique (numéro sur l'étiquette collée dessus). Chaque télécommande est normalement associée en usine à son récepteur.
On peut changer cette configuration, en associant une autre télécommande avec un autre récepteur.

Il faut disposer d'une "matching line" qui permet de relier les broches 1-3 (du canal Ch3/GND) sur le récepteur.

Pour changer l'association (binding) entre télécommande et récepteur (de même marque).
  • Eteindre la télécommande
  • Brancher la "matching line" dans la prise Ch3 du récepteur éteint.
  • Alimenter en 5v le récepteur par une batterie, sa led rouge clignote vite, pour indiquer le status "binding" en cours.
  • Appuyer et maintenir le bouton "bind" de la télécommande (avec une pointe de stylo) et la mettre sous tension.
    Au bout de 5 sec au maximum, la led du récepteur arrête de clignoter, le récepteur a trouvé la télécommande et s'est synchronisé avec elle.
  • Relâcher le bouton bind de la télécommande (dont la led verte clignote),
  • Retirer la matching line du récepteur.
  • Eteindre la télécommande et le récepteur, puis les rallumer.

On peut maintenant utiliser le récepteur, la télécommande étant synchronisée avec lui.
Ce réglage est conservé hors tension.

Mise en route
La led du récepteur clignote lentement : il est sous tension mais ne capte pas la télécommande qui lui correspond.

Allumer la télécommande, ses 2 voyants rouge (power) et vert (glow) s'allument en continu.

Le led du récepteur reste allumée en continu, la réception est maintenant ok.

Pilotage de servomoteur à distance
Image
Brancher directement un servomoteur sur le canal ch1.
Attention au sens de branchement (pas de détrompeur) : orange = signal, rouge = alimentation, marron=gnd.
Le servo doit suivre à distance les commandes de la télécommande.

Si on utilise plusieurs servos, monter une alimentation externe (l'intensité de la carte Arduino ne suffit pas à commander de la puissance).

Réglages sur la télécommande
Les canaux utilisés :
  • ch1 pour le volant agissant sur le servo de direction (ST = Steering), pilotage gauche/droite.
  • ch2 pour la gâchette agissant sur le contrôleur de vitesse du moteur (TH = throttle), manette de puissance moteur.
  • ch3 non utilisé

Les boutons de réglage de la télécommande
Canal CH1 (ST)
  • Le 1er interrupteur ST nor/rev permet d'inverser le sens de la réponse du volant (STeering).
  • Le 1er potentiomètre ST trim permet de caler le point milieu du volant (en ligne droite).
  • Le 3eme potentiomètre ST d/r permet de régler l'amplitude des mouvements commandés par le volant (jusqu'à une amplitude nulle).

Canal CH2 (TR)
  • Le second interrupteur TH nor/rev permet d'inverses le sens de la réponse de la gâchette (accélérer/freiner).
  • le second potentiomètre ajuste le point milieu.

Interfaçage simple du récepteur avec Arduino

Le signal utile (high) est codé en durée, sur 1 à 2 ms, pendant un cycle de 20 ms.
la fonction pulsin() permet de détecter le passage à l'état high ou low d'une broche et de chronométrer cette durée.

Toutefois cette méthode n'est pas optimale, avec 20ms de temps mort des milliers de cycles d'horloge du micro contrôleur sont perdus en temps d'attente.
Régler un timeout (en microsecondes) assez court pour éviter de gaspiller les ressources du calculateur.

Exemple en anglais https://www.sparkfun.com/tutorials/348

Notre code permet la lecture de 2 canaux (direction ST et vitesse TH)
Code: Tout sélectionner
//=== lecture de récepteur de radiomodélisme
//  tiptopboards.com C. ROLLAND 26 08 2013
// demo_rc_modelisme
//
// source Nick Poole cc. SparkFun Electronics
//https://www.sparkfun.com/tutorials/348 modifié
//=========================================================

//On utilise 2 voies sur le récepteur de radiomodélisme 2.4Ghz
// Ch1 = STeering (volant) pilotage gauche/droite avec un servomoteur
// Ch2 = THrottle (gachette de puissance) régler la vitesse de moteur
// Ch3 non utilisé par la télécommande à 2 cannaux
//========================================================
int ch1; // Nos deux cannaux de RC
int ch2;

void setup() {
  //Relier les masses du récepteur et de l'arduino, et
  pinMode(5, INPUT);  // ch1 sur Arduino pin5 STerring
  pinMode(6, INPUT);  // ch2 sur Arduino pin6 THrottle
  Serial.begin(9600);

}

void loop() {
  //Pulsin n'est pas très optimisé mais ça fonctionne
  //Signaux de largeur modulée (1ms à 2ms) sur cycle 20ms
  //Donc 1000 microsec = zéro, 2000 micsec = max et 1500 = neutre
  ch1 = pulseIn(5, HIGH, 25000); // Lire ch1 (25 ms)
  ch2 = pulseIn(6, HIGH, 25000); // Lire ch2


  Serial.print("Ch1 = "); // Afficher les lectures Arduino
  Serial.print(ch1);     

  Serial.print("  Ch2 = ");
  Serial.println(ch2);

  delay(100); //Petit delai
             
}


Image

Dans cet exemple,
Canal CH1 ST
  • Le volant renvoie une valeur comprise entre 1000 et 2000 micro sec, centrée sur 1500 au repos (mesuré 1007 - 2017).
  • Le 1er potentiomètre permet de caler la valeur retournée sur 1500 (sur la position neutre).
  • Le 3eme potentiomètre règle la sensibilité, de 0 (désactivé) à pleine échelle (position maxi, pour 1000 à 2000).
Canal CH2 TR
  • La gâchette avancée (accélération) retourne une valeur comprise entre 1372 et 688 (1627 et 947 si on décale son réglage).
  • La gâchette tirée (freinage) retourne 1518 à 2212 si on l'inverse (1342 - 2023 si décale son réglage).
  • Position neutre vers 1500, extrêmes 839 à 1980.

Interfaçage plus élaboré du récepteur avec Arduino
Pour optimiser le code Arduino, il est préférable d'utiliser les interruptions logicielles pour repérer les changements du signal.

Rappels sur la gestion d'interruptions.
  • 2 broches de l'Arduino Uno sont configurables comme interruptions : int_0 sur pin2 , ou int_1 sur pin 3.
  • L'utilisation des interruptions nécessite une entrée sans parasites.
  • On ne peut pas utiliser les fonctions temporelles delay() et millis() qui sont stoppées pendant une interruption.
  • Le traitement logiciel durant l'interruption doit être réduit au minimum.
  • Indiquer volatile au compilateur les variables utilisées par les interruptions (car susceptibles de changer à n'importe quel moment).
  • La fonction d'interruption est déclenchée ici sur fronts montant et descendant (rising et falling )
    Elle est configurée dans le setup avec
    attachInterrupt( pin_interrupt_xx, fonction_xxx, RISING );
    http://arduino.cc/fr/Main/AttachInterrupt

Pour les projets complexes, utiliser la librairie #include <RCArduinoFastLib.h>
Disponible ici https://github.com/scottjgibson/RCArduinoFastLib
Elle permet de lire plusieurs voies, gérer jusqu'à 18 servomoteurs avec une carte Uno, à 50 Hz, en même temps qu'un contrôleur de moteur ESC à haute fréquence.
Exemple de code (complexe) http://ceptimus.co.uk/?p=66

Principe de fonctionnement
Le gestionnaire d'interruptions scrute les entrées.
Si une broche passe sur high, on stocke en mémoire l'instant actuel.
Quand elle repasse à low, on en déduit la largeur d'impulsion en soustrayant l'instant actuel à la valeur stockée lors du front montant précédent (résolution 4 micro secondes).

Il faut utiliser des entiers long sans signe pour gérer les instants, sinon le reset de la fonction micro secondes au bout de 70 minutes provoquerait un bug.

Références
Sans librairie, avec simplement la fonction pulsin() donc non optimisé
Sur sparkfun (en anglais, Cf notre tutoriel)
https://www.sparkfun.com/tutorials/348

Autre exemple simple
http://rcarduino.blogspot.fr/2012/01/ho ... -with.html

http://rcarduino.blogspot.co.uk/2012/04 ... draft.html

Avec la librairie spécifique RCArduinoFastLib
A télécharger sur https://github.com/scottjgibson/RCArduinoFastLib
Source "Decoding 6 servo channel inputs with an Arduino UNO" http://ceptimus.co.uk/?p=66

http://rcarduino.blogspot.fr/2012/11/ho ... stlib.html
avec les fichiers RCArduinoFastLib.h et RCArduinoFastLib.cpp
et un exemple

http://rcarduino.blogspot.ae/2012/11/ho ... tream.html

Info générales sur les interruptions avec Arduino
http://arduino103.blogspot.fr/2012/02/l ... duino.html
tiptopboards - admin
Avatar de l’utilisateur
tiptop
Administrateur du site
 
Messages: 88
Inscription: Mar 13 Aoû 2013 20:38
Localisation: 38

Retourner vers Capteurs et composants

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 3 invités