De quoi parle t on aujourd’hui?

Ce qui est difficile avec un blog, c’est de prendre le temps de le maintenir à jour au détriment des avancées en mode plus « autiste ».

Mais cela permet aussi de s’arrêter un moment, pour prendre le temps de figer le passé récent.

Ceci dit, j’aimerais évoquer comment faire parler nos infatigables exécutants du terrain (que l’on pourra renommer Arduino, histoire de ne pas perdre le lecteur nouveau) avec leur grand frère beaucoup mieux doté, l’imprésentable Raspberry Pi.

Mon intérêt étant d’exposer le monde sensible accessible aux besogneux Arduinos à l’idéiste Raspberry Pi.

A ce stade, il apparaît essentiel de préciser les termes:

Idéiste:

1. [Chez Platon et ses héritiers] Ce qui appartient au domaine de l’intelligible et qui seul possède la perfection éternelle et la réalité absolue.

Plus concrètement, relier les Arduinos au Raspberry Pi (que je surnommerai Râ le temps de cet article) rend possible:

• leur exposition (que l’on va rendre contrôlée, pour faire face aux vilains hackers de tout poil) au réseau des réseaux, possiblement mais pas forcément par l’entremise d’un serveur web hostée sur Râ
• une plus grande puissance de traitement de l’information issue des Arduinos (nous verrons plus tard ce qu’on peut en faire)
• un stockage potentiellement bien fait des infos issues des Arduinos (base NoSQL possiblement, mais pas forcément, hostée sur Râ)
• l’accès à notre installation domotique par l’IA qui prend présentement, et discrètement, possession du monde

Bien, mais par quoi commence t on?

Alors j’aimerais un peu accélérer le rythme des articles, quitte à passer vite sur certains détails. Le cas échéant, toi lecteur qui reste toujours au centre des préoccupations de l’auteur de ce blog (si,si) ne doit pas hésiter à manifester des arrêts sur ceux ci si tu en ressens le besoin.

Donc, après un peu de reflexion, je me suis arrêté sur des modules RF à pas cher.

Les archi-utilisés NRF24L01 sont:

• pas chers (entre 1.4€ et 3.6€ selon les modèles)
• très bien documentés, il y a pas mal de librairies à la fois bas niveau et haut niveau qui les abstraient
• consomment peu
• fonctionnent bien sur Arduino et les Râ

Les modèles que j’ai moi même expérimentés:

• le modèle avec antenne (3.6€)

• le modèle avec PCB noir (1.5€)

• le modèle avec PCB vert (1.6€)

 

Comparaison

Alors, pour avoir un peu expérimenté ces modules, voici mes conclusions malheureusement non étayées par des tableaux, chiffres, et autre argument solide (je n’ai pas pris le temps de faire tout ça).

D’un Arduino à un Râ, les meilleurs résultats furent de loin ceux entre 2 modules RF avec PCB vert. Oui, cette configuration était sensiblement plus efficace qu’entre 2 modules avec antenne, ou un module avec antenne et un module avec PCB vert.

Dans l’hypothèse ou les modules avec antenne seraient plus directionnels, j’ai également testé en orientant les antennes dans tous les sens sans mieux.

Oui mais

Ces modules étant sensés être mieux (donnés théoriquement pour une portée de 1 Km (!!)), étant plus chers, il semble que quelque chose pouvait toutefois clocher.

• Alimentation

Tous ces modules s’alimentent en 3.3V. Les essais de votre serviteur se sont tous fait sur des clones d’Arduino nano à 3€ pièce, alimenté par USB (donc, rappelons le, en 5V).

Il y a deux régulateurs de tension dans ces Arduinos nano, un vers 5V et un vers 3.3V. Il semblerait que le régulateur 3.3V des clones utiisés soient dans le même chip gérant la conversion USB/série (CH340/341 dans notre cas), information non confirmée toutefois.

Quoi qu’il en soit, il semble crédible de mettre en cause l’efficacité du régulateur de tension vers 3.3V intégré.

Une piste à explorer est donc d’en utiliser un, et vérifier une possible amélioration.

• Condensateur de découplage

Ce sujet est vaste, il pourrait être l’objet d’un futur article du blog.

Simplement, en électronique, il arrive qu’une partie d’un circuit ait un besoin non constant d’énergie, et « tire » ainsi plus ou moins d’électrons des lignes d’alimentation à une fréquence plus ou moins importante.

Nos modules RF fonctionnent à 2.4GHZ, et peuvent à la fois engendrer des interférences en amont du circuit, mais aussi peuvent être affectés par l’incapacité du régulateur qui fournit le 3.3V à fournir une belle tension constante, quelque soit la charge exigée par nos modules.

Un grand pouvoir (peut être le plus grand à vrai dire) d’un condensateur, c’est sa capacité à absorber, à lisser. Ou dit autrement, à « découpler » les parties du circuit en amont et en aval de celui ci. En effet, comme il stocke des électrons et les relâche avec la patience d’un sage à la blanche barbe, il s’oppose aux vives variations de charge.

Ainsi, placer un condensateur de 4.7 uF (ou plus) entre la borne d’alimentation VCC du module RF et la masse pourrait améliorer les choses.

Ceci sera fait, dans un prochain article cependant, histoire de ne pas alourdir celui ci.

On fait quoi avec nos modules RF

Différentes librairies utilisent pour manipuler nos NRF24L01.

J’espère que tu pardonneras l’absence d’étude comparative critique, nous partons directement sur la lib RF24, version stanleyseow : https://github.com/stanleyseow/RF24, un fork de la lib de maniacbug qui apporte notamment un support sur Râ.

On branche le module RF sur l’arduino

On branche le module RF sur Râ

 

Si vous avez un modèle non +, le branchement est exactement le même (simplement, les lignes à partir de 27 ne sont pas présentes).

On code

Le code Arduino

[sourcecode language= »cpp »]
#include <SPI.h>
#include <RF24.h>

#define CE_PIN 9
#define CSN_PIN 10
const uint64_t pipe = 0xE8E8F0F0E1LL;
RF24 radio(CE_PIN,CSN_PIN);

const int PIRPin = 3;

void setup()
{

Serial.begin(9600);
Serial.println("RF module about to send..");

radio.begin();

radio.setRetries(15, 15);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_MAX);
radio.setCRCLength(RF24_CRC_8);
radio.setRetries(15,15);

radio.openWritingPipe(pipe);
}

void loop()
{
uint8_t toTransmit;

int PIRread = digitalRead(PIRPin);
if(PIRread == HIGH)
{
toTransmit = 1;
}
else
{
toTransmit = 0;
}

radio.write(&toTransmit,sizeof(toTransmit));
Serial.print("transmitting ");
Serial.println(toTransmit);
}
[/sourcecode]

Ce code n’amène pas moult discussions.
Il envoie simplement un entier qui est à 1 si le capteur branché sur la pin 3 (qui se trouve être un capteur de présence en l’occurrence) est à l’état haut, et 0 autrement.

Le reste est de la configuration. On peut cependant évoquer le PA max, pour un maximum de puissance en émission, la vitesse de transmission à 250 kbit/s, vitesse max qui permet une portée légérement plus importante.

Et chose importante, l’entier 64 bits donné à pipe peut être vu comme une référence du canal utilisé pour la transmission, il doit donc bien entendu être identique entre un émetteur et son récepteur.

Plutôt simple, donc.
Il se trouve que la taille de la payload envoyée a été empiriquement mesurée à 32 octets. Je n’ai pas encore cherché à comprendre le pourquoi, i.e. de quoi elle est composée.

nb: je ne décris pas comment installer la lib Arduino, chose relativement classique (copier les .h/.cpp dans le répertoire librairies de votre root de sketches arduino, propre à votre installation de l’IDE arduino).

Le code Râ

Il y a pas mal de façon d’aborder la chose sur notre mini ordinateur.

Activer le driver spi

Nous allons utiliser une lib qui utilise le driver SPI, pour cela il faut commencer par activer le driver SPI déactivé par défaut sur Raspbian.

Pour cela, on peut soit utiliser raspi-config qui permet de le faire via un menu, ou le faire « à la main ».

Faisons le à la main. En tant que root, modifier ce fichier /etc/modprobe.d/raspi-blacklist.conf pour commenter la ligne qui contient spi (et tant qu’à faire, celle qui contient i2c, qui pourra être utile par une suite..).

Ensuite, loader en tant que root ce module/driver : sudo modprobe spi-bcm2708.

Installer la lib RF24

Récuperer la lib RF24 depuis le github dont j’ai donné le lien plus haut (https://github.com/stanleyseow/RF24), aller dans RPi/RF24 puis un make/make install en tant que root installera la lib RF24 et les headers qui vont bien.

Implémenter l’utilisation de RF24 sur Râ

Alors la fainéantise c’est plutôt mal, même si c’est clairement discutable.

Cependant, les choses étant ce qu’elles sont, toi lecteur n’aura qu’une archive d’un work-in-progress pour faire tes tests.

test_RPI_RF24.tar

Un make à la racine de l’archivé detarré, decompressé produire le main, exécutable en tant que root.

[sourcecode]

pi@ffrp ~/gotoarduinoc/test $ sudo ./main
DBHandler initializing..
PING: PONG
DBHandler init OK
RFHandler initializing..
RFHandler init OK
read: 0 from pipe: 0
redis cmd: ZADD sensors:sensor_0_0 1420036719 1420036719:0
read: 0 from pipe: 0
redis cmd: ZADD sensors:sensor_0_0 1420036720 1420036720:0
read: 0 from pipe: 0
redis cmd: ZADD sensors:sensor_0_0 1420036721 1420036721:0

[/sourcecode]

Ce qui suit read:, à savoir 0 ou 1, est la valeur envoyée de l’Arduino.
Le lecteur attentif que tu es aura remarqué la présence de 3 adresses de pipe dans le code RFHandler.cpp, pour lire la valeur de 3 arduinos différents.
Aussi, tu auras remarqué que ce code en chantier met les valeurs lues dans une base NoSQL key/value Redis.

Mais pourquoi avoir arrêté en si bon chemin ce code?
Pour un avenir meilleur. La suite, dans un prochain article!