Si un champ magnétique est détecté, il est transmis à la sortie numérique. Les contacts Reed ont la propriété que leurs deux minces ressorts de contact, situés à l'intérieur du tube de verre, se rapprochent l'un de l'autre si un champ magnétique se trouve à proximité.

Cela ferme un contact électrique, qui transmet ensuite le signal.

Sortie numérique : Si un champ magnétique est détecté, un signal est émis ici.

Sortie analogique: Valeur mesurée directe de l'unité de détection

LED1: Indique que le capteur est alimenté en tension.

LED2: Indique qu'un champ magnétique a été détecté.

Fonctionnalité du capteur

Ce capteur possède trois composants fonctionnels sur sa carte de circuit imprimé. La première est l'unité de détection située à l'avant du module, qui mesure physiquement l'environnement actuel et le transmet sous forme de signal analogique à la deuxième unité, l'amplificateur. Celui-ci amplifie le signal en fonction de la résistance réglée sur le potentiomètre rotatif et l'envoie à la sortie analogique du module.

**Le signal est inversé ; si une valeur élevée est mesurée, cela se traduit par une valeur de tension plus faible à la sortie analogique.

La troisième unité est un comparateur, qui commute la sortie numérique et la LED lorsque le signal tombe en dessous d'une certaine valeur. Au moyen du potentiomètre rotatif, la sensibilité peut être réglée comme indiqué sur la figure suivante :

Ce capteur ne donne pas de valeurs absolues (par exemple, la température exactement mesurée en °C ou l'intensité du champ magnétique en mT), mais il s'agit d'une mesure relative : une valeur limite est définie par rapport à la situation environnementale normale donnée et un signal est donné qui peut être traité ultérieurement si cette valeur limite est dépassée ou si une autre condition que le cas normal s'est produite.

Ce comportement est idéal pour la surveillance de la température (KY-028), les capteurs de proximité (KY-024, KY-025, KY-036), des moniteurs d'alarme (KY-037, KY-038) ou des codeurs (KY-026).

Affectation des broches

Exemple de code Arduino

Affectation des broches Arduino

Arduino Capteur
5V +V
Masse GND
Pin 3 Signal numérique
Pin A0 Signal analogique

Le programme lit la valeur de la tension actuelle, qui peut être mesurée sur la sortie analogique, et la sort sur l'interface série.

En outre, l'état de la broche numérique est également indiqué dans la console, ce qui signifie que la valeur est passée sous la valeur limite ou non.

// Déclaration et initialisation des broches d'entrées
int Analog_Eingang = A0; // Entrée analogique
int Digital_Eingang = 3; // Entrée digitale
  
void setup ()
{
  pinMode (Analog_Eingang, INPUT);
  pinMode (Digital_Eingang, INPUT);
       
  Serial.begin (9600); // Sortie série à 9600 bauds
}
  
// Le programme lit les valeurs des broches d'entrée et les envoie à la sortie série
void loop ()
{
  float Analog;
  int Digital;
    
  //Les valeurs sont lues, sont converties en tension...
  Analog = analogRead (Analog_Eingang) * (5.0 / 1023.0); 
  Digital = digitalRead (Digital_Eingang);
    
  //... et envoyées à la sortie série.
  Serial.print ("Tension analogique:"); Serial.print (Analog, 4);  Serial.print ("V, ");
  Serial.print ("Limite:");
  
  if(Digital==1)
  {
      Serial.println (" atteinte");
  }
  else
  {
      Serial.println (" pas encore atteinte");
  }
  Serial.println ("----------------------------------------------------------------");
  delay (200);
}

Télécharger l'exemple de programme

KY025-Arduino.zip

Exemple de code Raspberry Pi

Affectation des broches Raspberry Pi

Raspberry Pi Capteur
GPIO 24 [Pin 18] Signal numérique
3,3V [Pin 1] +V
Masse [Pin 6] GND
KY-053 A0 Signal analogique
Capteur KY-053
Signal analogique A0
+V 3,3V [Pin 1]
GND Masse [Pin 6]
Raspberry Pi KY-053
GPIO 3 [Pin 5] SCL
Gpio 2 [Pin 3] SDA

Capteur analogique, il faut donc respecter les points suivants.

Contrairement à l'Arduino, le Raspberry Pi n'a pas d'entrées analogiques ou il n'y a pas d'ADC (convertisseur analogique numérique) intégré dans la puce du Raspberry Pi. Cela limite le Raspberry Pi, si vous voulez utiliser des capteurs, où les valeurs de sortie ne sont pas numériques [valeur de tension dépassée -> valeur numérique ON | valeur de tension sous-cotée -> valeur numérique OFF | exemple : bouton enfoncé [ON] bouton relâché [OFF]], mais il doit s'agir d'une valeur variable continue (exemple : potentiomètre -> autre position = autre valeur de tension).

Pour éviter ce problème, notre kit de capteur X40 a le KY-053, un module avec ADC précis de 16 bits, que vous pouvez utiliser sur le Raspberry pour l'étendre avec 4 entrées analogiques. Il est connecté au Raspberry Pi via I2C, prend en charge la mesure analogique et transmet la valeur numérique au Raspberry Pi.

Ainsi, nous recommandons de connecter le module KY-053 avec ledit ADC entre les capteurs analogiques de cet ensemble. Pour plus d'informations, veuillez consulter la page d'information sur le convertisseur analogique-numérique KY-053.

Le programme utilise les bibliothèques Python ADS1x15 et I2C correspondantes d'Adafruit pour piloter l'ADC ADS1115. Ceux-ci ont été publiés au lien suivant https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15 sous la licence MIT. Les bibliothèques requises ne sont pas incluses dans le paquet de téléchargement ci-dessous.

Le programme lit les valeurs actuelles des broches d'entrée et les affiche dans la console sous forme de valeur en [mV].

Veuillez noter que vous devez activer I2C sur votre Raspberry Pi avant d'utiliser cet exemple.

#!/usr/bin/python
# coding=utf-8
# Ce code utilise les librairies Python ADS1115 et I2C pour la Raspberry Pi
# Ces librairies sont publiées sous licence BSD sur le lien ci-dessous
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep
 
# Les modules nécessaires sont importés et mis en place
import time, signal, sys, os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
 
# Les variables utilisées sont initialisées
delayTime = 0.2
 
# attribution d'adresse ADS1x15 ADC
 
ADS1015 = 0x00  # 12-bit ADC
ADS1115 = 0x01  # 16-bit
 
# Choix du gain
gain = 4096  # +/- 4.096V
# gain = 2048  # +/- 2.048V
# gain = 1024  # +/- 1.024V
# gain = 512   # +/- 0.512V
# gain = 256   # +/- 0.256V
 
# Choix de la fréquence d'échantillonnage ADC (SampleRate)
# sps = 8    # 8 échantillons par seconde
# sps = 16   # 16 échantillons par seconde
# sps = 32   # 32 échantillons par seconde
sps = 64   # 64 échantillons par seconde
# sps = 128  # 128 échantillons par seconde
# sps = 250  # 250 échantillons par seconde
# sps = 475  # 475 échantillons par seconde
# sps = 860  # 860 échantillons par seconde
 
# choix du canal ADC (1-4)
adc_channel = 0    # Channel 0
# adc_channel = 1    # Channel 1
# adc_channel = 2    # Channel 2
# adc_channel = 3    # Channel 3
 
# initialisation du convertisseur
adc = ADS1x15(ic=ADS1115)
 
# Sélection de la broche d'entrée du signal numérique
Digital_PIN = 24
GPIO.setup(Digital_PIN, GPIO.IN, pull_up_down = GPIO.PUD_OFF)
 
#############################################################################################################
 
# ########
# boucle de programme principale
# ########
# Le programme lit les tensions en entrées et les transmet à la console.
 
try:
    while True:
        #Les valeurs de tension sont enregistrées
        analog = adc.readADCSingleEnded(adc_channel, gain, sps)
 
        # Envoi vers la console
        if GPIO.input(Digital_PIN) == False:
            print "Tension analogique:", analog,"mV, ","Limite: pas encore atteinte"
        else:
            print "Tension analogique:", analog, "mV, ", "Limite: atteinte"
        print "---------------------------------------"
 
        # Reset + Delay
        button_pressed = False
        time.sleep(delayTime)
 
 
 
except KeyboardInterrupt:
    GPIO.cleanup()

Exemple de téléchargement de programme

KY025-RPi.zip

Pour commencer avec la commande :

sudo python3 KY025-RPi.py

Exemple de code Micro:Bit

Affectation des broches Micro:Bit :

Micro:Bit Capteur
Pin 0 A0
Pin 1 D0
3V +V
Masse GND

Ceci est un exemple MakeCode pour Micro:Bit qui fait essentiellement la même chose que les exemples pour les deux autres variantes. Cependant, cet exemple est plus proche de celui du Raspberry Pi que de celui de l'Arduino.

Téléchargement d'un exemple de programme

microbit-KY-025.zip