Nous allons ici reprendre ce que j’ai initié dans un précédent article, à savoir le contrôle de prises télécommandées via Internet.

Après avoir étudié le fonctionnement de la télécommande fournie avec les prises, je peux maintenant chercher à reproduire les ordres RF via un micro-contrôleur.

Je vais pour cela utiliser le module radio émetteur présenté dans le premier article couplé avec un MSP430 de Texas Instruments. Facile à se procurer, peu onéreux et avec une documentation et un support bien fournis, ce micro-contrôleur offre un certain nombre d’avantages. De plus c’est un composant que je n’ai jamais utilisé ce qui présente un intérêt ludique supplémentaire 😀

Je laisse à chacun le soin de se renseigner sur les différentes manière de programmer ce composant, je ne vais présenter ici que le code de manière simpliste permettant à ceux qui le souhaite de le reprendre pour un MSP430 ou tout autre micro-contrôleur.

Envoi d’une trame par le MSP430

Première étape, inclure les éléments propres au composant via la première ligne ci-dessous, puis déclarer sur quelle broche du micro-contrôleur on a choisi de brancher le module RF. J’ai pour ma part choisi (arbitrairement) de brancher mon module sur la broche P1.3, je la nome « RF_pin » dans mon code.

1
2

#include "msp430.h"
#define RF_pin    0x08     //RF module on P1.3 pin

J’ai ensuite choisi d’écrire un fonction hardware_setup chargée d’initialiser le composant. La première ligne est chargée d’arrêter ce qu’on appelle le watchdog. Il s’agit un timer qui effectue un reset du composant au bout d’un certain temps d’inactivité pour éviter les plantages complet. L’application étant ici destinée à tourner pendant longtemps sans activité particulière cela pourrait poser quelques soucis que de le laisser activé.

On indique ensuite au composant que la broche choisie pour le module RF est une sortie du micro-contrôleur. Il sait ainsi que c’est lui qui pilote la broche et non un composant externe.

1
2
3
4
5
6
7
8
9

/*
 * Procedure : hardware_setup
 * Description : Setup MSP 430 internal register respecting hardware constraints.
 */
void hardware_setup(void)
{
  WDTCTL = WDTPW + WDTHOLD;             // Stop watchdog timer to prevent time out reset
  P1DIR |= RF_pin;                          // Set RF Pin to output direction
}

L’étape suivant consiste à écrire une fonction d’attente. En effet une trame consiste en une successions de niveaux haut et de niveaux bas, mais les délais entre les changement d’états ont un rôle important puisqu’ils déterminent la valeur des bits transmis.

Comme vu dans le précédent article, le délai minimal à maintenir est de 125 µs pour mon application, j’ai donc commencer par écrire une fonction qui comptait jusqu’à 125. Lorsque j’ai fait un test avec cette fonction un petite vérification à l’oscilloscope m’a permis de me rendre compte que le délais ainsi créé n’était pas de 125 µs mais de 1.25 ms soit 1250 µs. Une petite division par 10 permet donc d’avoir approximativement les délais souhaités.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/*
 * Procedure : delay
 * Description : Waits for aproxmatively us micro-seconds.
 */
void delay(unsigned long us)
{
  unsigned long x;
  unsigned int i;
 
  x=us/10;         // us divided by 10 to have real micro-seconds
 
  for (i = 0; i<= x; i++)
  ;
}

J’ai ensuite choisi d’écrire différentes fonctions pour générer chaque type de bit que l’on souhaite insérer dans un trame, pour mémoire voici l’allure de chaque bit :
le bit 1 :

1
2
3
4
5
6
7
8
9
10
11

void one(void)
{
  P1OUT = RF_pin;
  delay(500);
  P1OUT ^= RF_pin;
  delay(125);
  P1OUT = RF_pin;
  delay(500);
  P1OUT ^= RF_pin;
  delay(125);
}

le bit 0 :

1
2
3
4
5
6
7
8
9
10
11

void zero(void)
{
  P1OUT = RF_pin;
  delay(125);
  P1OUT ^= RF_pin;
  delay(500);
  P1OUT = RF_pin;
  delay(125);
  P1OUT ^= RF_pin;
  delay(500);
}

le bit f :

1
2
3
4
5
6
7
8
9
10
11

void floating(void)
{
  P1OUT = RF_pin;
  delay(125);
  P1OUT ^= RF_pin;
  delay(500);
  P1OUT = RF_pin;
  delay(500);
  P1OUT ^= RF_pin;
  delay(125);
}

le bit de synchronisation :

1
2
3
4
5
6
7

void sync(void)
{
  P1OUT = RF_pin;
  delay(125);
  P1OUT ^= RF_pin;
  delay(5625);
}

Dans chaque cas on change l’état du port P1 en forçant le bit de P1OUT correspondant à la broche RF_pin à 1 ou à 0 et on applique le délai souhaité pour maintenir l’état de la broche.

Maintenant que toutes ces fonctions sont écrites elles vont grandement faciliter la rédaction de la fonction principale. Il s’agit en fait dans cet exemple d’une boucle infinie qui va envoyer la trame pour allumer la prise A1. Cette trame va donc se composer des bits suivants : 0-0-f-f-0-0-f-f-0-f-f-f-sync comme vu dans le premier article.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/*
 * Procedure : main
 * Description : Main function.
 */
int main( void )
{
  hardware_setup();
 
  for (;;)
  {
    //Addr
    zero();
    zero();
    floating();
    floating();
    zero();
    zero();
    floating();
    floating();
    // Cmd
    zero();
    floating();
    floating();
    floating();
    // Sync
    sync();
  }
}

Comme vous pouvez le constater avec mes commentaire, j’ai choisi (arbitrairement encore une fois) de considérer qu’une trame était constituée de 8 bits d’adresse, 4 bits de commande et un bit de synchronisation.

Voilà, une fois ce code compilé est implanté dans le MSP430 connecté au module RF, il me permet de commander l’allumage de la prise réglée en A1. La prochaine étape va donc être de permettre la communication entre le MSP430 et un PC via UART, puis de commander ce que va émettre le micro-contrôleur par une page web et un petit script sur un PC.