All posts by Michael

About Michael

Développeur PHP freelance Symfony2 & Magento, passioné de programmation et d'électronique.

Capteurs de température autonomes MSP430 + Xbee

Il y a bientôt 3 ans de ça, alors que l’ESP8266 n’existait pas encore, je cherchais un moyen de collecter des données de température de plusieurs points d’un appartement, sans avoir la possibilité de brancher ces capteurs électriquement ou de les connecter au réseau filaire.

Après quelques recherches, j’ai réalisé que les micro contrôleurs Atmel utilisés dans les Arduino ne sont pas forcément adaptés à un fonctionnement sur batterie sur une longue durée.

On m’a alors conseillé d’étudier la famille des MSP430 de Texas Instruments, et en particulier la gamme MSP430G2xx Ultra-Low Power. Aussitôt mes samples du MSP430G2553 reçus (cette version intégre une interface série UART), les premiers tests étaient concluants : moins de 1μA de consommation en mode LPM3 (l’horloge auxiliaire reste active, avec un oscillateur crystal externe de 32 kHz).

Vue intérieure du module

Schéma module

Couplé à un XBee Série 1 pour sa simplicité d’utilisation (mais malheureusement assez onéreux, compter 25 €) et une thermistance 10kΩ pour relever la température (je n’ai pas besoin d’une grande précision), le tout fonctionne désormais sur 2 piles AAA 1.5V depuis plusieurs années, en transmettant 1 fois par minute la température et tension de la batterie.

Vue du module fermé

Quelques infos techniques :

  • Le MSP430 a été programmé en C grâce à la carte TI MSP430 Launchpad et l’IDE Code Composer Studio de TI
  • Les interruptions des timers ont été utilisées afin réveiller le MSP430 à intervalles réguliers
  • Le module XBee est maintenu en veille (Sleep Mode 1) grâce à un signal sur son pin 9 (cf. datasheet), et consomme ainsi moins de 10 μA, pour un temps de réveil inférieur à 15 ms
  • Le protocole utilisé pour la transmission est « maison », la valeur analogique brute est envoyée avec l’identifiant du module
  • Les données transmises par les différents modules sont reçues par un module « maître » puis stockées dans une base Elasticsearch, avec visualisation dans Kibana

Les interruptions sous Arduino / ATMega

Comme vous le savez certainement, il est possible sur les cartes Arduino (Uno, Mega, Due, etc.) de gérer des interruptions.

Le Arduino Uno (ATMega328) peut gérer 2 interruptions externes sur ses pins INT0 et INT1, mappés sur D2 et D3 (respectivement pins 4 et 5 du ATMega328 format PDIP).

Pins d’interruptions externes sur un Arduino Uno

A noter que les ATMega328 peuvent également gérer des interruptions de changement d’état sur 20 de ses pins ; cependant, la gestion de ces interruptions n’est pas aussi simple que les externes : il faut déterminer quel pin a généré l’interruption, pour quelle raison, etc. Une librairie Arduino a été développée afin de permettre l’utilisation de ces interruptions : arduino-pinchangeint.

Les interruptions peuvent être déclenchées selon 4 modes :

  • LOW : le pin est à un état bas
  • RISING : le pin passe d’un état bas à haut
  • FALLING : le pin passe d’un état haut à bas
  • CHANGE : le pin change d’état

Une ligne suffit à « écouter » une interruption sur un Arduino ; par exemple sur le pin INT0 (soit D2) nous attachons une interruption, qui appellera la fonction « myInterrupt » lors d’un passage du pin à l’état haut :

attachInterrupt(0, myInterrupt(), RISING);

Bien que le pin Arduino soit « D2 », nous indiquons ici « 0 » qui est le n° de pin d’interruption (0 pour INT0 / D2, 1 pour INT1 / D3).

Il faut ensuite définir la fonction qui sera appelée lors de l’interruption ; à noter que celle-ci ne reçoit aucun argument et ne doit rien retourner :

void myInterrupt() {
  // do something ...
}

Quelques limitations

Dans la fonction attachée à une interruption, celles-ci étant basées sur les timers de votre microcontrôleur, la fonction delay() ne marchera pas, millis() ne s’incrémentera pas.

Plus généralement, il est déconseillé de réaliser des opérations basées sur le temps, qui bloqueront votre µC ; par exemple la transmission de données en série (UART), I2C, etc.

Bonnes pratiques

L’usage des interruptions est idéal lors d’actions utilisateur, comme l’utilisation d’un bouton, d’un keypad, ou pour détecter un changement d’état rapide (signal infrarouge coupé), sans avoir à constamment « écouter » l’état d’un pin.

Idéalement, une fonction attachée à une interruption doit être la plus courte et rapide possible : une bonne pratique consiste à s’en servir pour stocker une valeur dans une variable (déclarée « volatile »). L’exécution de l’action à proprement parler se fera dans votre routine principale (loop()).

Par exemple :

volatile int change = 0;

void main() {
  attachInterrupt(0, myInterrupt(), RISING);
}

void loop() {
  if(change == 1) {
    // do something ...
change = 0;
  }
}

Liens utiles

Modules Ethernet Arduino et Microchip ENC28J60

Module Ethernet Microchip ENC28J60

Si vous souhaitez connecter votre Arduino à un réseau local filaire, plusieurs possibilités s’offrent à vous :

L’avantage de la dernière option est qu’elle permet de se passer d’une board Arduino, si l’on souhaite réaliser son propre circuit à base d’ATMega328 par exemple, ce qui est mon cas.

Tout comme le chip WIZnet W5100, qui équipe également les shields Ethernet, le chip Microchip ENC28J60 utilise SPI pour communiquer avec un microcontrôleur.

Le branchement à un Arduino Uno ou ATMega328 se fait comme suit :

Microchip ENC28J60 Arduino Uno ATMega328
CLKOUT Non connecté Non connecté
INT D2 Pin 4
WOL Non connecté Non connecté
SO D12 Pin 18
SI D11 Pin 17
SCK D13 Pin 19
CS D8* Pin 14*
RESET RESET Pin 1
VCC +3.3V +3.3V
(via régulateur de tension)
GROUND GND Pin 8

* = CS devrait logiquement être connecté à D10 sur un Arduino Uno ou au pin 16 sur un ATMega328 (Slave Select), mais la librairie ci-après utilise le D8 / pin 14 par défaut.

Malheureusement, ce module Ethernet n’est pas compatible avec la librairie Ethernet standard fournie avec l’IDE Arduino. Heureusement, une librairie Arduino (compatible > 1.0) existe, EtherCard.

Pour l’installer, rien de plus simple : téléchargez le ZIP de la librairie, décompressez le dans le dossier « libraries » de votre dossier d’installation Arduino, et renommez le en « EtherCard ».

(Re)lancez votre IDE Arduino, vous devriez désormais voir EtherCard apparaître dans Fichier / Exemples.

Vous pouvez tester le bon fonctionnement de votre module en prenant l’exemple « backSoon », qui ne compile toutefois pas dans sa version de base. Si comme moi vous n’utilisez pas DHCP  (STATIC à 1, ligne 6), vous pouvez commenter le code suivant lignes 60-63 :

if (!STATIC && ether.dhcpExpired()) {
Serial.println("Acquiring DHCP lease again");
ether.dhcpSetup();
}

Téléversez le sketch sur votre Arduino Uno ou ATMega328, et vous devriez accéder à une page « Back Soon » en visitant l’adresse IP configurée dans votre code.

Edit du 21/04/2013 :

Le bug DHCP de la librairie est désormais corrigé.

Proxmox / OpenVZ : réseau public + privé

Logo Proxmox

Proxmox Virtual Environment est un serveur open source de virtualisation, basé sur KVM et OpenVZ.

Il permet ainsi sur un serveur (host) physique de disposer de plusieurs machines virtuelles (VM). Dans le cas d’hébergement web, on mettra par exemple 1 VM pour Apache/PHP, 1 VM pour MySQL, etC.

Si vous utilisez ce mode de fonctionnement sur internet (et non en réseau local), un inconvénient majeur est le fait de nécessiter une IP publique pour chaque VM si vous souhaitez pouvoir y accéder directement depuis l’extérieur.

C’est le cas par exemple pour un serveur dédié que vous pouvez louer chez OVH (Kimsufi inclus) ou autre : vous disposerez dans le meilleur des cas, outre l’IP du host physique, de 3 IP (failover) pour vos VM. Dépassées ces 3 VM, vous ne pourrez donc plus leur assigner d’IP publique.

La meilleure solution consiste alors à utiliser du NAT (oui, le même que sur vos routeurs à la maison) : il est possible grâce à iptables de définir des redirections de ports depuis le host physique vers des VM sans IP publique.

Configuration initiale

Il vous faut tout d’abord choisir une plage d’IP non routées sur Internet type 192.168.x.x. Partons avec 192.168.0.0/24 (soit 192.168.0.1 à 192.168.0.255).

Configurez votre VM en mode « réseau virtuel » VENET avec l’IP de votre choix définie dans la range définie précédemment, prenons 192.168.0.11.

Démarrez votre VM : vous devriez pouvoir y accéder depuis votre host (ping, connexion SSH si serveur installé).

Il vous reste deux dernières commandes à lancer pour permettre à vos VM de communiquer avec l’extérieur :

echo 1 > /proc/sys/net/ipv4/ip_forward # On autorise le host à transmettre des données extérieures aux VM internes
iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o vmbr0 -j MASQUERADE # On active le NAT, en sortie via l'interface vmbr0 (à modifier si besoin)

Redirection de ports

Il vous reste à mettre en place les redirections de ports souhaitées. Par exemple, si nous souhaitons que le port 8080 de notre host redirige vers le port 80 de notre VM 192.168.0.11 :

iptables -t nat -A PREROUTING -i vmbr0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 192.168.0.11:80

Si vous avez un serveur qui écoute sur le port 80 de votre VM, essayer maintenant d’accéder à votre host sur le port 8080.

Reverse Proxy

Malheureusement, la redirection de ports sera très vite limitante si vous souhaitez par exemple avoir plusieurs VMs hébergeant un serveur web.

Dans ce cas de figure, une solution existe : l’utilisation d’un reverse proxy (type Apache).

Son fonctionnement est simple : il est positionné en frontal HTTP et/ou HTTPS sur votre host, et redirige les requêtes vers les différentes VM (sur leurs IP locales) en fonction du nom de domaine.

Pour mettre en place un reverse proxy de ce type, rien de plus simple également ; nous allons utiliser le serveur HTTP Apache. Première étape, l’activation du mod_proxy :

sudo a2enmod proxy

Créez maintenant un fichier /etc/apache2/sites-available/monsite :

<IfModule mod_ssl.c>
 <VirtualHost *:80>
  ErrorLog /var/log/apache2/error.log
  CustomLog /var/log/apache2/access.log combined
  <Proxy https://192.168.0.11/>
   Order Deny,Allow
   Allow from all
  </Proxy>
  ServerName mon.domaine.fr
  ProxyRequests Off
  ProxyPass / https://192.168.0.11/
  ProxyPassReverse / https://192.168.0.11/
 </VirtualHost>
</IfModule>

Enregistre le fichier puis activez le site nouvellement créé et redémarrez Apache :

sudo a2ensite monsite
sudo service apache2 restart

Il ne vous reste plus qu’à tester dans votre navigateur que le domaine défini dans votre fichier de configuration Apache redirige bien vers le serveur web de votre VM.

Microchip MCP23008 : multiplexage 8-bits I2C

Lors de la réalisation de circuits à base de microcontrôleurs (Arduino Uno avec µC ATMega 328 par exemple), il arrive très fréquemment d’être limités par le nombre de pins d’entrées/sorties, et particulièrement dans le cas d’accessoires communiquant en parallèle (keypad, écran LCD, etc.), utilisant ainsi de nombreux pins sur nos µC.

Une des solutions afin de réduire significativement le nombre de pins nécessaires est d’utiliser un « port expander » afin de multiplexer les signaux : nous parlerons ici du MCP23008 de Microchip, fonctionnant sur le bus I2C.

Microchip MCP23008

Caractéristiques principales

MCP23008
Pins 18
Tension de fonctionnement 1.8 à 5.5V
Bus I2C
Entrées / sorties 8
Débit maximal 1700 kb/s

Connexion à votre microcontrôleur

Pin MCP23008 Pin Arduino Uno Pin ATMega328P
1 (I2C clock) 5 28
2 (I2C data) 4 27
3, 4, 5 (address) GND GND
6 (power), 18 (reset) VCC VCC
9 GND GND
10 à 17 (GP0 à GP7) I/O pin I/O pin

Attention à bien utiliser la même tension entre votre µC et le MCP23008, ou un convertisseur de niveau.

Mapping pins Microchip MCP23008

Librairie Adafruit MCP23008

Si vous souhaitez utiliser le MCP23008 avec votre Arduino (testé avec un Uno) ou µC ATMega avec bootloader Arduino, Adafruit met à disposition sur GitHub une librairie prête à l’emploi, à installer dans votre dossier « libraries » de l’IDE Arduino.

Cette librairie est fournie avec 2 exemples : button et toggle. Son utilisation est très simple, voici un exemple (inspiré de « toggle ») pour faire clignoter en alternance 2 LED connectées aux E/S GP0 (pin 10) et GP1 (pin 11) du MCP23008 :

#include <Wire.h>
#include "Adafruit_MCP23008.h"

Adafruit_MCP23008 mcp;

void setup() {
  mcp.begin();      // Utilisation de l'adresse "0" par défaut
  mcp.pinMode(0, OUTPUT);
  mcp.pinMode(1, OUTPUT);
}

void loop() {

  mcp.digitalWrite(0, HIGH);
  mcp.digitalWrite(1, LOW);
  delay(1000);
  mcp.digitalWrite(0, LOW);
  mcp.digitalWrite(1, HIGH);
  delay(1000);
}

Interruptions

Comme nous venons de le voir, il est très simple d’utiliser le MCP23008 pour gérer des sorties.

Dans le cas de l’utilisation des pins GPIO en tant qu’entrées, deux cas de figure se présentent :

  • Vous souhaitez lire des états à intervalles réguliers ou lors d’une action en particulier
  • Vous souhaitez détecter un changement d’état, pour gérer un keypad ou des boutons par exemple

Dans le premier cas, il vous suffira d’utiliser quand nécessaire la méthode digitalRead de la librairie Adafruit MCP23008.

Dans le second cas, vous serez obligé de lire constamment l’état du ou des pins afin de détecter un changement d’état : votre programme ne fera donc que ça, comme le montre l’exemple ci-dessous :

#include <Wire.h>
#include "Adafruit_MCP23008.h"

Adafruit_MCP23008 mcp;

volatile int pinState = 0;

void setup() {
  mcp.begin();      // Utilisation de l'adresse "0" par défaut
  mcp.pinMode(0, INPUT); // Pin GP0 en entrée
  pinState = digitalRead(0); // On initialise la variable d'état du pin GP0
}

void loop() {
  if(mcp.digitalRead(0) != pinState) {
    // do something ...
    pinState = !pinState;
  }
  delay(5);
}

A noter que dans le cas de pins définis en entrée sur votre MCP23008, il est possible de les « tirer vers un état haut » à la manière d’une résistance de pull-up, avec la méthode pullUp.

Si le programme réalisait d’autre opérations au moment où l’on presse un bouton par exemple, il se pourrait qu’un changement d’état ne soit pas « capturé » par mcp.digitalRead(0).

Une des solutions à ce problème est d’utiliser le mécanisme d’interruptions présent dans le MCP23008 (pin 8 / INT). Malheureusement, la librairie Adafruit ne supporte pas (encore) les interruptions ; vous pourrez toutefois télécharger à la fin de cet article une version modifiée de cette librairie gérant les interruptions.

Les registres suivants (sur 8 bits) sont utilisés dans le MCP23008 pour gérer les interruptions :

  • GPINTEN (0x02) : permet de définir si les interruptions sont activées (1) ou non (0) sur un pin
MCP23008 GP7 GP6 GP5 GP4 GP3 GP2 GP1 GP0
Valeur par défaut 0 0 0 0 0 0 0 0
Mode R/W R/W R/W R/W R/W R/W R/W R/W

Ainsi, si l’on souhaite activer la détection des interruptions sur le pin GP0, il faudra définir le registre à : 0b00000001 soit 0x01.

A noter que ce les registres DEFVAL et INCON doivent également être définis pour les pins définis à 1 dans GPINTEN (détection des interruptions activée).

  • INTCON (0x04) : définit si l’interruption doit être déclenchée par un changement d’état d’un pin par rapport à une valeur par défaut dans DEFVAL (1) ou par rapport à son état précédent (0)
MCP23008 GP7 GP6 GP5 GP4 GP3 GP2 GP1 GP0
Valeur par défaut 0 0 0 0 0 0 0 0
Mode R/W R/W R/W R/W R/W R/W R/W R/W
  • DEFVAL (0x03) : utile quand INTCON est à 1 pour un pin donné, définit l’état par défaut d’un pin
MCP23008 GP7 GP6 GP5 GP4 GP3 GP2 GP1 GP0
Valeur par défaut 0 0 0 0 0 0 0 0
Mode R/W R/W R/W R/W R/W R/W R/W R/W
  • IOCON (0x05) : registre de configuration du MCP23008 ; le bit intéressant ici est le 1 (INTPOL) : s’il est défini à 1, le pin INT sera « active-high », s’il est à 0, le pin INT sera « active-low », ce qui correspond à l’état sur ce pin quand une interruption sera déclenchée.
MCP23008 SEQOP DISSLW HAEN ODR INTPOL
Valeur par défaut 0 0 0 0 0
Mode R/W R/W R/W R/W R/W

Attention, par défaut le pin INT est « active-low » et sera donc à un état haut tant qu’une interruption n’est pas envoyée. Si vous décidez de changer ce paramètre à 1, le pin INT au démarrage du MCP23008 sera tout de même durant quelques millisecondes en état haut (active-low) avant de passer en état bas (active-high). Si vous écoutez une interruption de type « CHANGE » sur votre Arduino/µC, celle-ci sera alors déclenchée. Une solution consiste à « attacher l’interruption » (attachInterrupt()) qu’après avoir configuré le MCP23008 dans son setup().

  • INTF (0x07) : ce registre indique quels pins (actifs [1] dans GPINTEN) ont déclenché une interruption
MCP23008 GP7 GP6 GP5 GP4 GP3 GP2 GP1 GP0
Mode R R R R R R R R
  • INTCAP (0x08) : ce registre est une capture de l’état des pins (1 = haut, 0 = bas) lors du déclenchement d’une interruption
MCP23008 GP7 GP6 GP5 GP4 GP3 GP2 GP1 GP0
Mode R R R R R R R R

Les registres INTF et INTCAP sont « nettoyés » (= remis à 0) lors de la lecture du registre INTCAP ou du registre GPIO. Pour plus de détails sur ce point précis, n’hésitez pas à vous référer à la page 19 de la datasheet (lien ci-dessous).

Un exemple concret

Prenons un cas concret : vous souhaitez générer une interruption lors de passage à l’état haut bas (0) du pin GP0 (qui sera donc par défaut à l’état haut) du MCP23008.

Les valeurs des différents registres seront les suivantes :

  • GPINTEN = 00000001 = 0x01 = 1 : on active les interruptions pour le pin GP0 (bit 0 mis à 1)
  • INTCON = 00000001 = 0x01 = 1 : l’interruption sera déclenchée par un changement d’état par rapport à la valeur par défaut
  • DEFVAL = 00000001 = 0x01 = 1 : la valeur par défaut de GP0 est 1 (état haut)
Lorsque GP0 passera à un état bas, une interruption sera déclenchée et nous aurons :
  • INTF = 00000001 = 0x01 = 1  : c’est le pin GP0 qui a déclenché l’interruption
  • INTCAP = 00000000 = 0x00 = 0 : le pin GP0 (comme tous les autres) était à l’état 0 (bas) au moment de l’interruption

Version modifiée de la librairie Adafruit

La librairie fournie par Adafruit n’offrant malheureusement pas le support des interruptions pour le MCP23008, j’y ai apporté quelques modifications dans cette version.

Outre les méthodes standard de la librairie d’origine, voici les méthodes disponibles pour gérer les interruptions :

void Adafruit_MCP23008::pinIntPolarity(uint8_t p);

Définition de l’état actif  (active-state) du pin INT du MCP23008.

uint8_t p : polarité (1 = HIGH, 0 = LOW)

 
void Adafruit_MCP23008::pinInt(uint8_t p, uint8_t m);

Activation des interruptions sur des pins du MCP23008.

uint8_t p : port (0 à 7)
uint8_t m : mode (1 = actif, 0 = inactif)

 
void Adafruit_MCP23008::pinIntControl(uint8_t p, uint8_t c);

Comparaison de l’état d’un pin avec son état par défaut (DEFVAL) ou sa valeur précédente.

uint8_t p : port (0 à 7)
uint8_t c : control mode (1 = DEFVAL, 0 = valeur précédente)

 
void Adafruit_MCP23008::pinIntDefval(uint8_t p, uint8_t v);

Valeur par défaut du pin pour comparaison.

uint8_t p : port (0 à 7)
uint8_t v : valeur (1 = HIGH, 0 = LOW)

 
uint8_t Adafruit_MCP23008::readIntFlag(void);

Lecture du registre INTF indiquant le/les pin(s) ayant déclenché l’interruption.

Cette méthode ne retourne pas le n° du pin (0 à 7) mais la valeur du registre.

 
uint8_t Adafruit_MCP23008::readIntCapture(void);

Lecture du registre INTCAP indiquant l’état des pins au moment de l’interruption.

Liens utiles

Reminder : AVR Dragon, Atmel Studio 6 et debugWire

Atmel AVR Dragon

Contrairement à certains billets plus détaillés, celui-ci est plus un reminder qu’un vrai tutorial.

En effet, j’ai récemment acheté un AVR Dragon de chez Atmel (environ 50 €) qui permet de programmer et débugger les microcontrôleurs Atmel (dont mes ATMega328P).

Le mode la plus simple à utiliser pour programmer ou modifier les fuses son µC est le SPI/ISP (schéma de branchement).

Pour débugger il faudra activer le mode debugWire : attention à ne pas l’activer manuellement via le fuse DWEN, mais à laisser Atmel Studio l’activer lorsque vous démarrez le debug de votre application.

Là où la situation se corse, et c’est le pourquoi de ce billet, c’est pour quitter le mode debugWire.

Il faut en fait tout simplement maintenir alimenté (à la même tension que le AVR Dragon, soit +5V) le microcontrôleur lorsque vous cliquez sur « Debug / Disable debugWire and close« . Vous pouvez alors à nouveau programmer votre µC en SPI.

Dovecot : régénérer des certificats SSL

Après avoir testé plusieurs outils dont Courier [Imap Server], sans jamais en être complètement satisfait, j’ai vite été conquis par Dovecot, et notamment son support des règles de filtrage Sieve.

Si vous utilisez comme moi la version disponible dans les dépôts Ubuntu/Debian, en IMAPS (IMAP over SSL, port tcp/993), le certificat auto-généré n’est valable que 365 jours, vous affichant un joli message d’erreur à la fin de sa validité.

Afin de le renouveller, voici une procédure très simple issue du « mkcert.sh » fourni dans les sources de Dovecot. Il vous suffit d’exécuter les commandes ci-après :

$ sudo service dovecot stop
$ sudo mv /etc/ssl/certs/dovecot.pem /etc/ssl/certs/dovecot.pem.bak
$ sudo mv /etc/ssl/private/dovecot.pem /etc/ssl/private/dovecot.pem.bak
$ sudo openssl req -new -x509 -nodes -out /etc/ssl/certs/dovecot.pem -keyout /etc/ssl/private/dovecot.pem -days 365
$ sudo chmod 0600 /etc/ssl/private/dovecot.pem
$ sudo openssl x509 -subject -fingerprint -noout -in /etc/ssl/certs/dovecot.pem
$ sudo service dovecot start

Si vous souhaitez que votre certificat soit valable plus d’un an, vous pouvez modifier la variable « days » dans la première commande OpenSSL.

ATMega328P vs ATMega1284P

ATMega328P-PU vs ATMega1284P-PU

Tableau de comparaison

ATMega328-PU ATMega1284-PU
Packaging PDIP PDIP
Pins 28 40
I/O max 23 32
PWM 6 6
ADC channels 8 8
SPI 2 3
I2C 1 1
UART 1 2
Flash 32 Kbytes 128 Kbytes
SRAM 2 Kbytes 16 Kbytes
EEPROM 1024 bytes 4096 bytes

Je reviendrai plus particulièrement au cours d’un prochain billet sur le ATMega1284, afin de vous faire part de mon retour d’expérience avec ce microcontrôleur. D’ici là, n’hésitez pas à vous rendre sur la page GitHub de Maniacbug  et son billet de blog traitant du sujet.

Liens vers les datasheets officielles :

Arduino RF 433Mhz & VirtualWire : envoyer des bytes/octets

Grove RF Link Kit 433 Mhz

Les émetteurs et récepteurs RF 433 Mhz sont extrêmement pratiques et surtout peu coûteux pour la mise en oeuvre de communication sans-fil entre plusieurs dispositifs électroniques.

La solution la plus simple sur Arduino pour effectuer les liaisons est d’utiliser la librairie VirtualWire (version 1.9 actuellement), donc l’utilisation est très bien détaillée dans la documentation officielle VirtualWire.

Cependant, tous les exemples que j’ai pû trouver sur internet expliquent comment transférer un tableau de caractères (char[]), mais difficile de trouver des exemples pour transférer des byte ou int.

Voici donc un premier boût de code côté émetteur détaillant comment faire envoyer des bytes :

Transmission de byte

#include <VirtualWire.h>

byte msg[3]; /* Tableau de 3 bytes */

void setup() {
Serial.begin(9600);
vw_setup(2000);
}

void loop() {
  msg[0] = B00000001; /* = 1 */
  msg[1] = B00000010; /* = 2 */
  msg[2] = B00000011; /* = 3 */
  vw_send((uint8_t *)msg, sizeof(msg));
  vw_wait_tx();
}

Côté réception, vous pouvez au choix analyser/comparer les valeurs une par une (reçues une par une) ou les mettre dans un buffer (tableau).

Authentification en 2 étapes sous Linux (SSH/PAM) avec Google Authenticator

Logo Google Authenticator

Logo Google Authenticator

Depuis plusieurs mois déjà, les utilisateurs d’un compte Google ont la possibilité de mettre en place une vérification en 2 étapes lors de leur connexion (2-steps authentication), en passant par cette page, permettant ainsi d’ajouter une couche de sécurité supplémentaire à leur compte.

La méthode la plus simple afin de générer le code temporaire nécessaire à la 2ème étape d’authentification est d’utiliser l’application mobile (Android, iOS et Blackberry) open source Google Authenticator.

Google propose également un module PAM permettant de mettre en place une authentification en 2 étapes sur un poste Linux / Ubuntu.

Connectez-vous à votre poste avec le compte que vous souhaitez sécuriser et depuis une console téléchargez libpam : http://code.google.com/p/google-authenticator/downloads/list puis décompressez l’archive.

Quelques librairies sont à installer afin de permettre la compilation du module et la génération d’un QR Code :

sudo apt-get install libpam0g-dev libqrencode3
cd libpam-google-authenticator-*
make
sudo make install

Lors de l’installation, plusieurs questions vous serons posées, lisez-les avec attention afin de sélectionner l’option adaptée à votre contexte pour chacune d’entre elles.

Installez l’application mobile Google Authenticator sur votre téléphone (version Android sur Google Play, version iOS sur l’App Store) puis ajoutez votre compte en scannant le QR Code qui est apparu dans votre console (ou visible depuis le lien qui vous a été fourni) : une nouvelle ligne apparaît donc dans votre application mobile avec un nouveau code toutes les 30 secondes.

Reste maintenant à rendre obligatoire l’utilisation du module libpam-google-authenticator lors d’une connexion avec votre compte.

Le plus simple ici est d’ajouter la ligne suivante à la fin de votre fichier /etc/pam.d/common-auth (sans oublier d’en faire une copie de sauvegarde au préalable) :

auth required pam_google_authenticator.so

Si vous vous connectez à votre poste via SSH, il est également nécessaire de modifier les deux paramètres de configuration suivants dans votre /etc/ssh/sshd_config :

ChallengeResponseAuthentication yes
UsePAM yes

Redémarrez ensuite votre serveur SSH.

Par défaut, les codes générés sont basés sur l’heure, il est donc impératif que votre téléphone (sur lequel sera généré le code) et votre ordinateur soient à la bonne et même heure (synchronisation NTP). Veillez également par sécurité à noter les codes de secours forunis permettant de se connecter en cas de perte de votre mobile par exemple.

Vous pouvez désormais tester cette authentification en 2 étapes en vous connectant via une console, SSH ou Gnome (GDM) par exemple, qui vous demdanderont le code de vérification. Par défaut, il vous sera également demandé lors d’un sudo.

Deux petites remarques pour l’instant d’après mon expérience :

  • Si vous utilisez une clé SSH pour vous connecter (avec mot de passe, pas testé sans), le code de vérification ne vous sera pas demandé
  • Cette authentification en 2 étapes peut ne pas être supportée par certains clients ou avoir des comportement hasardeux, comme avec Proftpd par exemple qui se contente du seul mot de passe

Attention, en cas de mauvaise manipulation, votre accès pourrait être bloqué. Je ne pourrai en aucun cas en être tenu pour responsable.