Dernière mise à jour le 19/09/17

Présentation



Wikipedia : Le protocole RC5 ou RC-5 est un des nombreux protocole de communication binaire utilisé par les télécommandes infrarouges des appareils électroniques et particulièrement dans les appareils électroniques audiovisuels.

Principe d’une trame RC5


Une trame au format RC5 se compose de 14 bits avec :

  • 2 bits de départ (synchronisation de la réception infrarouge);
  • 1 bit de basculement (change à chaque nouvel appui sur la touche considérée);
  • 5 bits d’adressage du système (appareil concerné: tv, dvd…);
  • 6 bits de commande (changement de chaîne, volume, veille…)

Un bit est composé d’un état logique HAUT « 1 » et d’un état logique BAS « 0 » il correspond à ceci :


La période de ce bit est donc égale à :


Tbit=2*889µs = 1778µs soit une période de 1,778ms.
Sachant cela on peut donc calculer la longueur d’une trame envoyé qui est donc :


Ttrame = 2bits départ + 1 bit basculement + 5 bits adressage + 6 bits commande
Ttrame = (2 * 0.001778) + (1*0.001778) + (5*0.001778) + (6*0.001778) = 0.024892µs soit 24,892ms


Si on arrondi on obtient 25ms…

Aspects d’une trame


Ce codage de trame s’appelle le codage Manchester, un nouveau nom à comprendre et à analyser mais avant d’en parler regardons comment réaliser un bits avec une diode infrarouge.

Comment réaliser un bits et des créneaux avec une diode infra Rouge

Les créneaux réalisés par la diode Infrarouge ne sont pas des créneaux comme nous l’avant vu ci-dessus, mais une multitude de signaux qui sont eux aussi en créneaux, c’est ce qu’on appelle « une modulation bi-phase »

En effet, à l’intérieur d’un créneau, nous avons 32 cycles de créneaux qui ont une fréquence de 36Khz.


Le calcul est simple, si il y’a 32 cycles en 889µs, cela veut dire que pour 1 cycle nous avons (règle de 3) 27,7µs (889µs/32 = 27,7µs) arrondi donne 28µs.


Pour rappel :
Un cycle correspond à une période c’est-à-dire qu’un signal qui se répète plusieurs fois dans le temps est considéré comme une période.
Le créneau bleu ci-dessus correspond à une période c’est-à-dire 1 cycle)
Il en résulte qu’une période fait 28µs soit F=1/T = 1/0,000028= 35714Hz arrondi donne 36Khz.

(Entre nous une méthode plus rapide à calculer était de faire le nombre de cycle divisé par la durée soit 32/0.000889 = 35995Hz soit 36Khz).




Bon maintenant que nous avons vu comment était réalisé un crénau puis un bits regardons le fonctionnement du codage Manchester

Fonctionnement du Codage Manchester

Bon, nous y voilà !!! Nous avons parlé comment réaliser un bit, et une trame, mais comme je le disais précédemment une trame ce code en utilisant le codage Manchester. Le codage Manchester est un codage synchrone, ce qui signifie que les données à transmettre, intègrent également l’horloge de synchronisation nécessaire à leur décodage.
Revenons à cette trame


1er bit de départ
Le bit de départs est avant tout composé d’un état BAS qui dur 889µs et d’un état HAUT qui dur lui aussi 889µs (bit = 0.001778µs
Il en résulte qu’il s’agit d’un « 1 » logique.
2ème bit de départ
Pour ce 2ème bit de départs c’est la même chose, il s’agit aussi d’un « 1 » logique
3ème bit (bit de répétition)
Encore une fois il s’agit là aussi d’une « 1 » au niveau logique haut.
4ème bits
Dans ce cas de figure on passe à l’état logique HAUT qui dur 889µs et d’un état logique BAS qui 889µs il en résulte que ce bit est à l’état logique « 0 »
En conclusion on peut représenter les bits sous cette forme :

Proteus Easy HDL



(Clique pour mieux voir)

Comment réaliser une trame sous Proteus??? et bien Proteus propose dans ces générateurs, un générateur appelé Easy HDL, qui permet en mode script décrire des lignes de code (attention je ne vais pas rentrer dans les détails de ce langage puisque dans la rubrique Aide sous Proteus, vous avez toutes les explications possible pour réaliser un petit morceau de code).

Un aperçu de la liste des exemples (En Anglais)

Comment utiliser Easy HDL


Comment trouver Easy HDL sous Proteus nul besoin d’installer de logiciel ou autre!! Ce n’est pas compliqué je vous laisse suivre ci-dessous le processus (Cliquer sur l’image pour agrandir)

Réalisation Trame RC5 avec Easy HDL

J’avais envie de mettre en pratique la théorie sur le RC5 et de faire moi même ma propre trame RC5 en respectant à la lettre le protocole ainsi que le codage Manchester. A partir de la je me suis beaucopu documenter autour de du Easy HDL qui estun outil puissant car il peu réaliser beaucoup de fonction. Mais avant de me lancer dans un programmation à ce tirer les cheveux dans tout les sens et de faire une “usine à gaz”, j’ai tout d’abord écrit les bits à la suite des autres tout simplement.

Le programme du Script Easy HDL est ci-dessous


// Definie les variables
FLOAT PeriodeBit=1.778m
FLOAT Etat = PeriodeBit / 2
INT i=0
OUT=0 // On met la sortie à état logique “0”
SLEEP FOR 1000m // On attend 1sec

GOTO LOOP // On activre le “Label LOOP”
LOOP:

FOR i=0 TO 13

IF i=0 THEN // 1 er bit start
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ENDIF

IF i=1 THEN // 2ème bit start
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ENDIF

IF i=2 THEN // bit de réception
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ENDIF

IF i=3 THEN // Adresse 4
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=4 THEN // Adresse 3
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=5 THEN // Adresse 2
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=6 THEN // Adresse 1
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=7 THEN // Adresse 0
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=8 THEN // Commande 5
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=9 THEN // Commande 4
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=10 THEN // Commande 3
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=11 THEN // Commande 2
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=12 THEN // Commande 1
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF

IF i=13 THEN // Commande 0
OUT =0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ENDIF

NEXT i

OUT=0
SLEEP FOR 1000m
GOTO LOOP

Comme vous pouvez le constater il s’agit ici d’un script assez long puisque celui-ci permet de travailler sur chaque bits différents avec entre chaque espaces le “1er bit de Start”/”2ème bit de Start”/”bit de réception”/etc…
 
Ainsi, grâce à ce Script, nous obtenons une trame RC5 prête à être envoyée.

Amélioration du code


Nous avons vu précédemment qu’il est assez fastidieux de changer à tour de rôle chaque bits de la trame RC5. Le nouveau « code » plutôt un Script, a été amélioré par mes soins afin de pourvoir changer :

  • Bits de réception
  • Adressage
  • Commande

Dans ce nouveau Script, il est ainsi possible d’agir sur ces 3 données en modifiant les DATAs qui sont accessibles dans cette “portion” du Script:


INT Reception,Adresses,Commandes // Variables
DATA 0x01, 0x02, 0x01 // DATA à modifier {Bits de réception/Adressage/commande}
READ Reception,Adresses,Commandes // Lecture des données situées dans DATA les unes après les autres…

Attention!!!

  • bit de réception n’autorise que 2 valeurs (0x00 ou 0x01) !! (0x01 = Hexadécimal donne en binaire “01”)
  • Adressage valeur comprise entre 0x00 à 0x1F (5 bits max) (0x1F = Hexadécimal donne en binaire “11111”)
  • Commande valeur comprise entre 0x00 à 0x3F (6 bits max) (0x3F = Hexadécimal donne en binaire “111111”)

Il ne reste plus qu’à modifier les valeurs afin d’obtenir une trame RC5 beaucoup plus facile à interpréter et à modifier par le Script.


// Definie les variables
FLOAT PeriodeBit=1.778m
FLOAT Etat = PeriodeBit / 2
INT h,i,j,k,m,n
INT Reception,Adresses,Commandes // Variables
DATA 0x01, 0x02, 0x01 // DATA à modifier {Bits de réception/Adressage/commande}
READ Reception,Adresses,Commandes // Lecture des données situées dans DATA les unes après les autres…
i=0
OUT=0
//Read – Bit de réception / Adresse / Commande
SLEEP FOR 1000m
i = i+1
// 1er bit start
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
// 2ème bit start
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
// bit de réception (TOGGLE)
IF (Reception=1) THEN
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ELSE
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF
i=2
//===============================
// ADRESSES 0..4
//===============================
IF (i=2) THEN
FOR j=0 TO 4
// Adress 0..4

IF (Adresses & (1 << 4-j)) THEN
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ELSE
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF
NEXT j
i=3
ENDIF
//===============================
// Commandes 0..5
//===============================
IF (i=3) THEN
FOR k=0 TO 5
// Command 0..5

IF (Commandes & (1 << 5-k)) THEN
OUT = 0
SLEEP FOR Etat
OUT = 1
SLEEP FOR Etat
ELSE
OUT = 1
SLEEP FOR Etat
OUT = 0
SLEEP FOR Etat
ENDIF
NEXT k
i=0
ENDIF
OUT = 0