Communication RF 433 MHz entre Raspberry Pi et Arduino

Cet article a été mise à jour le 8 janvier 2021. À cette occasion, j'ai pu faire fonctionner la communication de l'Arduino vers le Raspberry pi uniquement. Pour une raison que j'ignore, la communication du Raspberry Pi vers l'Arduino ne semble plus fonctionner.

Nous avons déjà abordé la communication entre le Raspberry Pi et l'Arduino au moyen d'un câble USB, ce qui imposait une certaine proximité entre les deux cartes.

Aujourd'hui, nous nous débarrassons du câble:  l'Arduino et le Raspberry Pi s'échangeront des informations par ondes radio, à une fréquence de 433 MHz.


Matériel nécessaire

En plus du Raspberry Pi et de l'Arduino, nous utiliserons un émetteur et un récepteur 433 MHz, le modèle ultra-économique qu'on peut trouver sur eBay pour environ 1 euro.  Une antenne constituée d'un fil conducteur d'environ 17 cm vous permettra d'augmenter considérablement la portée de votre paire émetteur-récepteur.

Émetteur

Récepteur

Installation des bibliothèques 

Du côté de l'Arduino, j'ai utilisé la bibliothèque VirtualWire même si elle n'est plus mise à jour par son auteur (je ne me suis pas encore converti à RadioHead).  Donc, si ce n'est pas déjà fait, vous devriez télécharger et installer VirtualWire dans votre IDE Arduino.

Du côté du Raspberry Pi, j'ai utilisé le module Python rédigé par Joan du Forum Raspberry Pi.  Donc vous téléchargez le fichier vw.py et vous le placez dans le même répertoire que votre script Python (voir plus loin pour les scripts).  Ce n'est pas tout:  ce module requiert la bibliothèque pigpio .  Pour installer cette bibliothèque dans votre Raspberry Pi, vous tapez ces lignes de commande dans le terminal:

wget https://github.com/joan2937/pigpio/archive/master.zip

unzip master.zip

cd pigpio-master

make

sudo make install

Transmission de l'Arduino vers le Raspberry Pi

Branchez l'émetteur à l'Arduino de la façon suivante: 

• Broche DATA de l'émetteur à la sortie 12 de l'Arduino
• Broche Vcc de l'émetteur à la sortie 5 V de l'Arduino
• Broche GND de l'émetteur à une des broches GND de l'Arduino

 Branchez le récepteur au Raspberry Pi de la façon suivante:

• Une des broches DATA du récepteur (peu importe laquelle) à la pin GPIO 11 du Raspberry Pi.
• Broche 5 V du récepteur à une des broches 3,3 V du Raspberry Pi
• Broche GND du récepteur à une des pins GND du Raspberry Pi

Voici le sketch à installer dans l'Arduino (chaque message envoyé par l'Arduino sera numéroté, ce qui nous permet de vérifier si tous les messages envoyés sont reçus).

	// Émission d'un message a 433 MHz par l'Arduino
	// http://electroniqueamateur.blogspot.com/2014/10/communication-rf-433-mhz-entre.html
	// basé sur:
	// transmitter.pde
	//
	// Simple example of how to use VirtualWire to transmit messages
	// Implements a simplex (one-way) transmitter with an TX-C1 module
	//
	// See VirtualWire.h for detailed API docs
	// Author: Mike McCauley (mikem@airspayce.com)
	// Copyright (C) 2008 Mike McCauley
	// $Id: transmitter.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $
	#include <VirtualWire.h>
	int compteur = 0;
	const char *msg = "Bonjour, ici l'Arduino. Message # ";
	char nombre[VW_MAX_MESSAGE_LEN];
	char message[VW_MAX_MESSAGE_LEN];
	void setup()
	{
	Serial.begin(9600); // Debugging only
	// Initialise the IO and ISR
	vw_set_ptt_inverted(true); // Required for DR3100
	vw_setup(2000); // Bits per sec
	}
	void loop()
	{
	compteur++;
	// Conversion du int en tableau de chars
	itoa(compteur,nombre,10); // 10 car décimal
	strcpy (message, msg);
	strcat(message,nombre);
	digitalWrite(13, true); // Flash a light to show transmitting
	vw_send((uint8_t *)message, strlen(message));
	vw_wait_tx(); // Wait until the whole message is gone
	digitalWrite(13, false);
	delay(200);
	}

view raw emetteur433MHz.ino hosted with ❤ by GitHub

Et voici le script Python à installer dans le Raspberry Pi.  N'oubliez pas d'installer ce script dans le même répertoire que le fichier vw.py. 

Avant d'exécuter le script, vous devez mettre en marche le "démon pigpio" au moyen de cette ligne de commande:

sudo pigpiod

	import time
	import pigpio
	#!/usr/bin/env python
	# -*- coding: latin-1 -*-
	'''
	Réception d'un message par le Raspberry Pi,
	reçu à 433 MHz par un récepteur
	relié à la pin GPIO 11
	Nécessite la présence du fichier vw.py dans le
	même répertoire.
	http://www.raspberrypi.org/forums/viewtopic.php?t=84596&p=598087
	http://electroniqueamateur.blogspot.com/2014/10/communication-rf-433-mhz-entre.html
	'''
	import vw
	RX=11
	BPS=2000
	pi = pigpio.pi()
	rx = vw.rx(pi, RX, BPS)
	start = time.time()
	print("En attente de la reception des donnees")
	while (time.time()-start) < 100:
	while rx.ready():
	print("".join(chr (c) for c in rx.get()))
	rx.cancel()
	pi.stop()

view raw recepteur433MHz.py hosted with ❤ by GitHub

Transmission du Raspberry Pi vers l'Arduino 

N.B.: Lors de la mise à jour de cet article le 8 janvier 2021, je ne suis pas parvenu à faire fonctionner la transmission du Raspberry Pi vers l'Arduino.

 Branchez l'émetteur au Raspberry Pi de la façon suivante: 

• Broche DATA de l'émetteur à la pin GPIO 25 du Raspberry Pi
• Broche Vcc de l'émetteur à une des pins 5 V du Raspberry Pi
• Broche GND de l'émetteur à une des pins GND du Raspberry Pi

 Branchez le récepteur à l'Arduino de la façon suivante:

• Une des broches DATA du récepteur (peu importe laquelle) à l'entrée 11 de l'Arduino.
• Broche 5 V du récepteur à la sortie 5 V de l'Arduino 
• Broche GND du récepteur à une des pins GND de l'Arduino

Voici le sketch à installer dans l'Arduino (n'oubliez pas d'afficher le moniteur série, où les résultats reçus seront affichés):

	// Réception d'un signal 433 MHz par Arduino.
	// http://electroniqueamateur.blogspot.com/2014/10/communication-rf-433-mhz-entre.html
	// receiver.pde
	//
	// Simple example of how to use VirtualWire to receive messages
	// Implements a simplex (one-way) receiver with an Rx-B1 module
	//
	// See VirtualWire.h for detailed API docs
	// Author: Mike McCauley (mikem@airspayce.com)
	// Copyright (C) 2008 Mike McCauley
	// $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $
	#include <VirtualWire.h>
	void setup()
	{
	Serial.begin(9600); // Debugging only
	Serial.println("Attente de reception des donnees");
	// Initialise the IO and ISR
	vw_set_ptt_inverted(true); // Required for DR3100
	vw_setup(2000); // Bits per sec
	vw_rx_start(); // Start the receiver PLL running
	}
	void loop()
	{
	uint8_t buf[VW_MAX_MESSAGE_LEN];
	uint8_t buflen = VW_MAX_MESSAGE_LEN;
	if (vw_get_message(buf, &buflen)) // Non-blocking
	{
	int i;
	digitalWrite(13, true); // Flash a light to show received good message
	// Message with a good checksum received, dump it.
	Serial.print("Message recu: ");
	for (i = 0; i < buflen; i++)
	{
	Serial.write(buf[i]);
	//Serial.print(" ");
	}
	Serial.println("");
	digitalWrite(13, false);
	}
	}

view raw recepteur433MHz.ino hosted with ❤ by GitHub

Et voici le script Python à exécuter par le Raspberry Pi (n'oubliez pas d'installer ce script dans le même répertoire que le fichier vw.py). 

Avant d'exécuter le script, vous devez mettre en marche le "démon pigpio" au moyen de cette ligne de commande:

sudo pigpiod

	#!/usr/bin/env python
	# -*- coding: latin-1 -*-
	'''
	Émission d'un message par le Raspberry Pi,
	qui sera transmis à 433 MHz par un émetteur
	relié à la pin GPIO 25
	Nécessite la présence du fichier vw.py dans le
	même répertoire.
	http://www.raspberrypi.org/forums/viewtopic.php?t=84596&p=598087
	http://electroniqueamateur.blogspot.com/2014/10/communication-rf-433-mhz-entre.html
	'''
	import time
	import pigpio
	import vw
	TX=25
	BPS=2000
	pi = pigpio.pi()
	tx = vw.tx(pi, TX, BPS)
	compteur = 0
	start = time.time()
	while (time.time()-start) < 100:
	compteur += 1
	while not tx.ready():
	time.sleep(0.1)
	time.sleep(0.2)
	tx.put("Bonjour, ici le Raspberry Pi! Message #{}.".format(compteur))
	tx.cancel()
	pi.stop()

view raw emetteur433Mhz.py hosted with ❤ by GitHub

Si vous préférez une communication 433 MHz entre deux Arduinos, référez-vous à cet article.  Et j'ai tout plein d'articles sur le Raspberry Pi qui vous plairont peut-être.

Yves Pelletier (Twitter:  @ElectroAmateur)

Amplificateurs Opérationnels (6): Le sommateur et le soustracteur

Nous en sommes donc au sixième article de cette série qui présente des expérimentations effectuées au moyen de l'amplificateur opérationnel.   Dans les livraisons précédentes, nous avons utilisé notre UA741en mode comparateur, suiveur de tension, multivibrateur astable, différentiateur, intégrateur et amplificateur inverseur.  C'est déjà pas mal, mais ce n'est pas terminé:  aujourd'hui, nous allons nous amuser à additionner et soustraire des signaux périodiques.

Première étape:  produire deux signaux périodiques, différents l'un de l'autre, que nous pourrons ensuite additionner ou soustraire.

Production d'un signal en créneau

Notre premier signal sera un signal en créneau (signal carré).  Pour ce faire, nous construisons à nouveau le multivibrateur astable de l'article numéro 3.

 Sans surprise, nous obtenons ce signal à la sortie:

Production d'un signal triangulaire

Le signal de sortie du multivibrateur astable est ensuite acheminé à l'intégrateur de l'article numéro 4.

Nous retrouvons, à la sortie de cet intégrateur, un signal de forme triangulaire.

Essayez maintenant d'imager à quoi pourra ressembler l'addition et la soustraction de ces deux signaux...

Addition des deux signaux

Voici le circuit sommateur qui permettra d'additionner les deux signaux (hé oui, il s'agit d'un troisième amplificateur opérationnel).  Reliez la sortie du multivibrateur à l'entrée 1 du sommateur, et la sortie de l'intégrateur à l'entrée 2 du sommateur.

Si le potentiomètre est réglé au maximum, le signal de sortie devrait être égal à l'addition des deux signaux sans la moindre atténuation, mais l'amplitude de ce signal entraînera probablement une saturation de l'amplificateur opérationnel (signal déformé).  Si le potentiomètre est réglé à une position intermédiaire, le signal de sortie présentera une version atténuée de l'addition des deux signaux.

Et voici ce que ça donne:

En remplaçant les résistances de 10K par des potentiomètres, ce circuit devient un mixeur audio rudimentaire.


Soustraction des deux signaux

Construisons maintenant un circuit à la sortie duquel on retrouvera la soustraction de nos deux signaux:  un tel circuit s'appelle soustracteur, ou amplificateur différentiel.  Ici encore, vous reliez la sortie du multivibrateur à l'entrée 1 du soustracteur, et la sortie de l'intégrateur à l'entrée 2 du soustracteur.

Et voici ce qu'on obtient, cette fois.  Ça ressemble un peu au signal obtenu à la sortie du sommateur, sauf que l'inclinaison est dans l'autre sens.

Continuez d'expérimenter!   Par exemple, vous pourriez produire deux signaux en créneau de fréquences différentes, et voir ce que ça donne quand vous les additionnez.

Article suivant:  Amplificateurs opérationnels (7):  source de courant

Article précédent: Amplificateurs opérationnels (5):  amplificateur inverseur

Yves Pelletier (Twitter:  @ElectroAmateur)

Transmettre les données de l'Arduino vers un tableur (Excel ou Libre Office Calc)

Ce n'est pas la première fois que je vous parle de data logging au moyen de l'Arduino: il y a quelques mois, nous avions vu comment procéder pour que l'Arduino enregistre ses mesures sur un fichier CSV situé sur une carte SD.  Ce fichier CSV pouvait ensuite être lu par Excel.  L'inconvénient de cette méthode, c'est qu'on ne voit pas les données pendant qu'elles sont enregistrées:  on doit interrompre l'acquisition des données pour retirer la carte SD de l'Arduino,  et l'insérer dans un ordinateur muni d'Excel.

Nous avions ensuite expérimenté la transmission de données de l'Arduino (muni d'un shield Ethernet) vers le service en ligne carriots.com, ce qui nous permettait de visualiser un graphique qui se mettait à jour en temps réel.

Mais dans bien des cas, on préférerait pouvoir transmettre les données en temps réel à un ordinateur situé tout près de l'Arduino, pour que celui-ci les affiche sous forme de graphique.  Si on n'a pas besoin d'accéder à ces données à partir d'un autre ordinateur, pourquoi se donnerait-on la peine de les expédier sur internet avec un shield Ethernet ou Wi-Fi?

Pour ce faire, on peut écrire notre propre programme en Processing ou en Python, mais on peut aussi utiliser un tableur comme Excel ou LibreOffice Calc. Et vous savez quoi? Ce n'est pas seulement possible, c'est même plutôt facile!


PLX-DAQ et Excel

Pour utiliser PLX-DAQ, vous aurez besoin d'un ordinateur muni du logiciel Excel. Vous n'avez pas Excel?  Avant de vous précipiter vers les employés de Bill Gates pour leur offrir une partie substantielle de votre argent, lisez plutôt la partie de cet article qui parle de l'utilisation de Libre Office Calc, qui est totalement gratuit.

PLX-DAQ est une macro pour Excel mise au point par la société Parallax pour permettre aux microcontrôleurs qu'elle commercialise d'envoyer des données vers Excel.  C'est gratuit, et ça fonctionne avec n'importe quel microcontrôleur capable de communication série, ce qui inclut bien sûr l'Arduino!

Le circuit

Pour faire un premier essai rapide, un potentiomètre achemine un signal analogique à l'entrée A0 de l'Arduino.  C'est ce signal qui sera envoyé à Excel pour être mis en graphique. Évidemment, l'Arduino doit être relié à un des ports USB de l'ordinateur.

Le sketch Arduino

Le sketch à téléverser dans l'Arduino est plutôt simple:  il consiste en gros à lire la valeur de l'entrée A0, et de la transmettre par liaison série (donc Serial.Print et Serial.Println, comme quand on veut afficher quelque chose dans le moniteur Série).  Chaque fois que la macro PLX-DAQ reçoit la commande DATA suivie d'une liste de données séparées par des virgules, elle place ces données sur la prochaine ligne du tableur.

TIME (en majuscules) est une instruction qui indique à la macro d'insérer l'heure (ce sera l'heure telle que réglée dans l'ordinateur qui exécute Excel).
.

	/***************************************************************************************
	Utilisation de la macro PLX-DAQ de Parallax pour acheminer à Excel les mesures prises
	par l'Arduino.
	http://electroniqueamateur.blogspot.com/2014/10/transmettre-les-donnees-darduino-vers.html
	****************************************************************************************/
	int Mesure_Pin = A0; // nous allons envoyer l'état de l'entrée analogique A0
	void setup() {
	Serial.begin(9600); // initialisation de la communication série à 9600 bps
	Serial.println("CLEARDATA"); // on efface les données déjà présentes, s'il y a lieu
	Serial.println("LABEL,Temps,Mesure"); // titre des colonnes, dans Excel
	}
	void loop() {
	int ValeurMesuree = analogRead(Mesure_Pin); // lecture de la pin A0
	Serial.print("DATA,TIME,"); // envoi du temps et la mesure à Excel
	Serial.println(ValeurMesuree);
	delay(1000); // 1 seconde d'attente entre chaque mesure
	}

view raw datalogging_excel.ino hosted with ❤ by GitHub

.

Installation et utilisation de la macro

Par défaut, Excel est plutôt paranoïaque en ce qui concerne les macros:  en mode "Niveau de sécurité élevé", il refuse de les exécuter, par crainte qu'elles contiennent des virus.  Pour vérifier le niveau de sécurité de votre exemplaire d'Excel (et pour le modifier s'il n'est pas adéquat), choisissez "Options" dans le menu "Outils".

Amplificateur opérationnels (5): L'amplificateur inverseur

Après avoir utilisé notre amplificateur opérationnel comme comparateur, suiveur de tension, multivibrateur astable, intégrateur et différentiateur, nous voyons aujourd'hui comment l'utiliser pour amplifier un signal.


L'amplificateur inverseur (ainsi nommé car la polarité du  signal amplifié est inversée par rapport à celle du signal d'entrée) est simplement constitué d'un amplificateur opérationnel et de deux résistances, tel qu'illustré ci-dessous.

Tentons une petite analyse théorique de ce circuit, en commençant par rappeler l'équation présentée lors du premier article de cette série:

      V_sortie = A ( V⁺ - V ^- )

L'équation peut également s'écrire de cette façon:
             
       V ⁺ - V ^- = V_sortie / A

Puisque le gain A est à toute fin pratique infini, il en découle que l'expression (V_sortie / A) est nulle, donc V ⁺ = V ^-  (les deux tensions d'entrée sont égales entre elles).

L'entrée non-inverseuse étant reliée à la masse, sa tension est nulle, donc la tension de l'entrée inverseuse sera nulle également:

       V ^- = V ⁺ = 0

D'autre part, nous savons que l'impédance d'entrée d'un amplificateur opérationnel est énorme:  pour cette raison, la totalité du courant qui traverse la résistance R₁  sera forcée de traverser également la résistance R₂  (une proportion très négligeable du courant sera dévié dans l'entrée inverseuse de l'amplificateur):

      I₁ = I₂

Et en appliquant la loi d'Ohm, selon laquelle le courant traversant chaque résistance est égal à la différence de potentiel aux bornes de la résistance divisée par la résistance:

     V_entrée/R₁ = - V_sortie/R₂

Donc V_sortie  = (-R₂/R₁) V_entrée

Conclusion:  si la résistance R₂ est plus grande que la résistance R₁, le signal de sortie sera amplifié par rapport au signal d'entrée.

On essaie?

Je vous invite à monter votre propre circuit afin d'expérimenter.  Comme c'est le cas depuis le début de cette série d'articles, j'ai utilisé des amplificateurs opérationnels UA741 alimentés au moyen d'une alimentation ATX d'ordinateur (mais vous pouvez utiliser un autre amplificateur, ainsi qu'une alimentation de laboratoire si vous en avez une).

Comme signal périodique à acheminer à l'entrée de notre amplificateur inverseur, je vous propose un signal triangulaire produit par une combinaison de deux amplificateurs opérationnels (nous avons vu comment procéder lors du quatrième article de cette série).  Bien entendu, si vous disposez d'un générateur de fonctions, vous pouvez le brancher directement à l'entrée de votre amplificateur, ce sera plus simple...

Nous commençons donc par un multivibrateur astable qui produit un signal en créneau:

...à la sortie duquel nous ajoutons un intégrateur, qui transforme le signal en créneau en un signal triangulaire.

À cette étape, la tension à la sortie de notre circuit a une amplitude d'environ 2,5 V (5 V crête à crête)

Acheminons le signal de sortie de l'intégrateur à l'entrée d'un amplificateur inverseur:

Le potentiomètre (R₂) nous permet de modifier le gain de l'amplificateur.  Voici ce qu'on obtient à l'écran de l'oscilloscope si on superpose le signal à l'entrée de l'amplificateur inverseur, et le signal à sa sortie (les deux signaux sont à la même échelle de 2 V/division).  Tel que prévu, le signal amplifié est inversé par rapport au signal de sortie:  lorsque le signal d'entrée est à son maximum positif, le signal de sortie est à son maximum négatif, et vice-versa.  Dans ce cas, R₂ était environ deux fois plus grande que R₁, donc le signal de sortie a une amplitude qui est environ le double de celle du signal d'entrée.

Si on essaie de trop amplifier le signal, toutefois,  l'amplificateur sature et on se retrouve avec un signal de sortie tronqué:

Voilà:  vous êtes maintenant capables d'amplifier un signal au moyen d'un amplificateur opérationnel.

Article suivant:  Amplificateurs opérationnels (6):  sommateur et le soustracteur
Article précédent: Amplificateurs opérationnels (4):  intégrateur et le différentiateur

Yves Pelletier (Twitter:  @ElectroAmateur)

Sonde à ultrasons HC-SR04 et Raspberry Pi

Cet article a été mis à jour le 21 décembre 2020 (compatibilité Python 3).

Le télémètre à ultrasons HC-SR04 permet de détecter la présence d'un obstacle et de déterminer à quelle distance il se trouve. Voici comment utiliser ce capteur avec un Raspberry Pi et un script en langage Python.

Principe de fonctionnement de la sonde HC-SR04

La sonde HC-SR04 est à la fois un émetteur et un récepteur d'ultrasons (des sons dont la fréquence est trop élevée pour être perçus par l'oreille humaine).

La broche "Trig" du HC-SR04 est une entrée: lorsqu'on soumet brièvement cette entrée à une tension de 5 V (ou 3,3 V), la sonde émet une brève impulsion ultrasonore.  Si un objet se trouve devant la sonde, une partie des ultrasons sera réfléchie vers la sonde.  Lorsque la sonde détecte cet écho, la sortie "Echo" (qui est habituellement à une tension de 0 V) prend la valeur 5 V pendent une durée égale au temps écoulé entre l'émission de l'ultrason et la réception de l'écho.

Branchements

Notre sonde comporte 4 broches:

• Vcc sert à alimenter le circuit du HC-SR04, il doit être à une tension de 5 V, nous le brancherons donc à la broche numéro 2 du Raspberry Pi.
• Trig est l'entrée qui nous permet de déclencher l'émission d'un ultrason. Nous la brancherons directement à la broche 8 (GPIO 14) du Raspberry Pi (les 3,3 V produits par cette broche sont suffisants pour faire réagir la sonde).
• Echo est la sortie qui se met à 5 V pendant une durée égale à l'aller-retour de l'ultrason, et ici les choses se compliquent un peu:  soumettre une broche GPIO du Raspberry Pi à une tension de 5 V ne serait pas du tout une bonne idée!   Vous devez impérativement abaisser cette tension à 3,3 V avant de la transmettre à la broche 10 (GPIO 15) du Raspberry Pi.
• Gnd, sans surprise, sera branché à une des nombreuses broches Gnd du Raspberry Pi.

Il va sans dire que les broches 8 (GPIO 14) et 10 (GPIO 15) ne comportent aucune caractéristique spéciale qui aurait favorisé leur choix:  vous pouvez les remplacer par n'importe quelle autre broche GPIO, à la condition de modifier en conséquence le script ci-dessous.

Pour abaisser la tension de la broche "echo" 5 V à 3,3 V,  ont peut envisager deux solutions:  un diviseur de tension constitué de deux résistances en série, ou un circuit intégré spécialement conçu pour la conversion de niveaux logiques, comme le CD4050.

Utilisation d'un diviseur de tension

Avec le diviseur de tension illustré ci-dessous, la tension à la broche 10 (GPIO 15) du Raspberry Pi sera d'environ 3,3 V lorsque celle de la pin "Echo" du HC-SR04 sera à 5 V:

 
Vous pourriez être tenté d'utiliser des résistances plus grandes, comme par exemple 10K et 18K:  je le déconseille car j'ai remarqué que leur utilisation engendre une moins grande précision dans la mesure de la distance (c'est lié à la constante de temps "RC" des condensateurs). 

J'ai placé le HC-SR04 face à un mur situé à une distance d'environ 25 cm, et j'ai pris la mesure de la distance à 10 reprises (voir le script plus bas).

Avec un diviseur de tension constitué d'une résistance de 10K et d'une résistance de 18K, j'ai obtenu une différence de 7 mm entre la mesure la plus basse et la mesure la plus haute.

Avec un diviseur de tension constitué d'une résistance de 1K et d'une résistance de 1,8K, la différence entre la mesure la plus basse et la mesure la plus élevée n'était plus que de 3 mm.

Les résultats sont encore meilleurs si on remplace le diviseur de tension par un CD4050:  la différence entre la mesure la plus petite et la mesure la plus grande n'est plus que de 2 mm.

Utilisation du circuit intégré CD4050


Si vous optez pour l'utilisation du CD4050, vous branchez sa broche 1 à la broche 1 du Raspberry Pi (pour alimenter le circuit intégré avec une tension de 3,3 V) et vous reliez sa broche 8 à une des broches GND du Raspberry Pi.  La broche 10 (GPIO 15) est branchée à la broche 2 du CD4050, et la broche 3 du CD4050 est branché à la broche "Echo" du HC-SR04.

En principe, votre CD4050 aura un comportement plus fiable si vous branchez à la masse toutes ses entrées inutilisées.  J'ai omis de le faire, et ça fonctionnait très bien malgré tout.

Je vous réfère à ce précédent article pour plus de détails concernant l'utilisation du CD4050.

Script en Python

Chaque fois que nous désirons mesurer la distance de l'obstacle situé devant le HC-SR04, notre programme doit soumettre la broche "Trig" à une tension de 3,3 V pendant une fraction de seconde (ce qui déclenche l'émission de l'ultrason), puis mesurer le temps pendant lequel la broche "Echo" est à 3,3 V.

Ensuite, ce temps doit être converti en distance, sachant que la vitesse du son (340 m/s) est égale au double de la distance, divisé par la durée de l'aller-retour.

L'exemple ci-dessous effectue 10 mesures de distances espacées d'une seconde. Pour une mesure plus précise, ça peut être une bonne idée de faire la moyenne de plusieurs mesures consécutives.

-

	#!/usr/bin/env python
	# -*- coding: utf-8 -*-
	'''
	Mesure de distance au moyen d'un apteur ultrasonore HC-SR034
	branché au Raspberry Pi
	Pour plus d'infos:
	http://electroniqueamateur.blogspot.com/2014/10/sonde-ultrasons-hc-sr04-et-raspberry-pi.html
	'''
	import RPi.GPIO as GPIO
	import time
	GPIO.setmode(GPIO.BOARD) ## car je déteste le mode BCM
	print ("Mesure de distance par le capteur ultrasonore HC-SR04")
	trigPin = 8 ## entrée trig du HC-SR04 branchée à la pin 8 (GPIO 14) du Raspi
	echoPin = 10 ## sortie echo du HC-SR04 branchée à la pin 10 (GPIO 15) du Raspi
	GPIO.setup(trigPin,GPIO.OUT)
	GPIO.setup(echoPin,GPIO.IN)
	GPIO.output(trigPin, False)
	for x in range(10): ## on reprend la mesure 10 fois
	time.sleep(1) ## 1 seconde de délai entre chaque mesure
	GPIO.output(trigPin, True) ## on envoie une brève impulsion sur la pin Trig
	time.sleep(0.00001)
	GPIO.output(trigPin, False)
	while GPIO.input(echoPin)==0: ## émission de l'ultrason
	debutImpulsion = time.time()
	while GPIO.input(echoPin)==1: ## retour de l'écho
	finImpulsion = time.time()
	distance = round((finImpulsion - debutImpulsion) * 340 * 100 / 2, 1) ## car vitesse du son = 340 m/s
	print ("Distance mesuree:",distance,"cm") ## affichage à l'écran
	GPIO.cleanup() ## nous sortons proprement

view raw ultrasons.py hosted with ❤ by GitHub

-

Références

Cet article du blog ModMyPi m'a servi de point de départ.

À lire également

Le télémètre laser VL53L1X constitue une autre option pour mesurer une distance au moyen du Raspberry Pi.

Vous trouverez aussi sur ce blog des conseils pour utiliser le télémètre HC-SR04 avec un Arduino Uno,  avec un ATTiny85,  avec une carte STM32 Nucleo programmée avec mbed, avec un microcontrôleur PIC et avec un micro:bit.

Je vous invite également à consulter mes autres projets impliquant le Raspberry Pi.

Yves Pelletier (Twitter:  @ElectroAmateur)

Amplificateurs opérationnels (4): L'intégrateur et le différentiateur

Lors du dernier article de cette série, nous avons construit un multivibrateur astable au moyen d'un amplificateur opérationnel.   Ce circuit produisait un signal en créneau (signal carré).

Cette fois, nous allons transformer ce signal carré en un signal triangulaire au moyen d'un circuit intégrateur.  Puis, nous allons transformer le signal triangulaire en signal carré au moyen d'un circuit différentiateur (ou dérivateur).

Dans un premier temps, je vous invite à construire à nouveau, sur un breadboard, le multivibrateur de la dernière fois (seule modification:  j'ai remplacé la résistance R1 de 10K par 6K8, car ça me donnait un signal triangulaire de meilleur qualité).

 

Sur le breadboard, ça aura l'air de ça:

À la sortie, on obtient un signal carré, comme la dernière fois (oui, je sais, mon oscilloscope n'a pas la même intensité lumineuse partout sur l'écran, c'est irritant!).

Pour transformer ce signal carré en signal triangulaire, nous allons ajouter un deuxième circuit, qu'on appelle un intégrateur (puisque son signal de sortie est l'intégrale du signal d'entrée).

C'est quoi l'intégrale?  C'est une fonction qui décrit l'aire sous une courbe.  Voici notre signal d'entrée:

Je divise l'aire délimitée par ce signal en petits carrés identiques entre eux:

Au temps 0, je n'ai encore traversé aucun petit carré:  l'aire est nulle.
Au temps 1, j'ai traversé 2 petits carrés:  l'aire est de 2 petits carrés.
Au temps 2, j'ai traversé 2 autres petits carrés, pour une aire totale de 4 petits carrés.
Au temps 3, j'ai traversé 2 carrés négatifs, qui sont soustraits de l'aire totale:  donc 2 carrés.
Au temps 4, je soustrait 2 carrés supplémentaires:  l'aire est redevenue nulle.
Au temps 5, je soustrait encore 2 carrés:  l'aire est de -2.
Au temps 6, je soustrait 2 autres carrés:  l'aire est de -4.
Au temps 7, j'additionne 2 carrés:  l'aire est de -2.
Au temps 8, j'additionne 2 carrés:  l'aire est nulle
Au temps 9, j'additionne 2 carrés:  l'aire est de +2.
Au temps 10, j'additionne 2 carrés:  l'aire est de +4.

Si je fais un graphique de l'aire en fonction du temps, ça va donc donner ceci:

Qu'est -ce que je vous disais?  Un signal triangulaire!

Ça, c'est en théorie.  En pratique, voici le circuit intégrateur que je vous invite à construire.  Acheminez le signal de sortie du multivibrateur à l'entrée inverseuse du circuit intégrateur.

 

Notre breadboard se complexifie un peu:

...et voilà ce que nous obtenons à la sortie de ce circuit:  un signal de forme triangulaire, tel que prévu.

Amusons-nous maintenant à dériver ce signal triangulaire.  La dérivée, c'est la pente de notre fonction:  notre signal triangulaire a une pente positive, puis négative, puis positive, puis négative.

La dérivée est le contraire de l'intégrale:  si on intègre un signal carré, ça donne un signal triangulaire, et si on dérive un signal triangulaire, ça donne un signal carré.

Voici le circuit différentiateur qui fera la dérivée de notre signal triangulaire:

 

Le breadboard commence à faire peur:

Et voici le résultat:

Article suivant:  Amplificateurs opérationnels (5):  amplificateur inverseur
Article précédent: Amplificateurs opérationnels (3): multivibrateur astable

Yves Pelletier (Twitter:  @ElectroAmateur)