NE555 Module Générateur d'Impulsions Fréquence / Cycle

NE555 Module Générateur d’Impulsions Fréquence / Cycle

28,00 DH

Disponibilité:

Rupture de stock

UGS : 0162 Catégories : ,

Description

Module Générateur d’Impulsions Fréquence / Duty Cycle Variable NE555

Le module générateur d’impulsions variable NE555 est équipé de deux potentiomètres pour ajuster la fréquence et le cycle de service des impulsions produites. Il est couramment utilisé dans les projets électroniques nécessitant des signaux d’onde carrée précis avec des caractéristiques ajustables.

Caractéristiques en détail

  • Tension d’alimentation : 5V à 15V DC
  • Plage de fréquence des impulsions : 0,6 Hz à 200 kHz
  • Cycle de service : Ajustable de 0,4% à 99,6%
  • Dimensions : 30 x 20 mm
  • Consommation de courant : 3 mA à 5V
  • Amplitude de tension de sortie : 4,5V à 5V, 11,5V à 12V

Fonctionnement

Le module fonctionne en mode astable avec le NE555 produisant une série continue d’impulsions. En ajustant les deux potentiomètres, on peut modifier la fréquence et le cycle de service des impulsions générées. Les broches de configuration permettent de changer la plage de fréquence à l’aide de cavaliers (jumpers).

Applications

  • Génération de signaux d’horloge pour les microcontrôleurs
  • Contrôle de la vitesse des moteurs pas à pas
  • Génération de tonalités audio
  • Modulation de largeur d’impulsion (PWM)
  • Déclenchement d’événements périodiques

Brochage

  • VCC : Alimentation (5V – 15V)
  • GND : Masse
  • OUT : Sortie des impulsions

Configurations de Plage de Fréquence

Le module possède plusieurs cavaliers (jumpers) pour sélectionner différentes plages de fréquence :

  • Jumper 1 (LF) : 1Hz à 50Hz
  • Jumper 2 (IF) : 50Hz à 1kHz
  • Jumper 3 (HF) : 1kHz à 10kHz
  • Jumper 4 (VHF) : 10kHz à 200kHz

Comment l’utiliser

Pour utiliser le module générateur d’impulsions NE555 avec un Arduino, connectez les broches VCC et GND à l’alimentation de l’Arduino. La broche OUT doit être connectée à une entrée numérique pour détecter les impulsions.

Comment l’utiliser avec Arduino Uno

Exemple de code Arduino de base

#define PULSE_PIN 2

void setup() {
Serial.begin(9600);
pinMode(PULSE_PIN, INPUT);
}

void loop() {
int pulseState = digitalRead(PULSE_PIN);
Serial.println(pulseState);
delay(100);
}

But du code

Ce code permet de lire les impulsions numériques générées par le module NE555 et d’afficher leur état sur le moniteur série.

Composants nécessaires pour le code de base

  • Arduino Uno
  • Module générateur d’impulsions NE555
  • Câbles de connexion

Explication détaillée du code de base

  1. Initialisation : La communication série est établie, et la broche pour le module générateur d’impulsions est configurée en entrée.
  2. Lecture et affichage des données : Les impulsions de la broche OUT du module NE555 sont lues et affichées dans le moniteur série.

Brochage détaillé des connexions du code de base

  • VCC : 5V (Arduino)
  • GND : GND (Arduino)
  • OUT : D2 (Arduino)

Exemple de code Arduino avancé pour afficher la fréquence et le cycle de service des impulsions

#include <Wire.h>
#include <LiquidCrystal_I2C.h>


LiquidCrystal_I2C lcd(0x27, 16, 2);
#define PULSE_PIN 2


volatile unsigned long highTime = 0;
volatile unsigned long lowTime = 0;
volatile bool measuringHigh = true;
unsigned long startTime = 0;
float frequency = 0;
float dutyCycle = 0;


void setup() {
  lcd.begin();
  lcd.backlight();
  Serial.begin(9600);
  pinMode(PULSE_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(PULSE_PIN), measurePulse, CHANGE);
  startTime = millis();
}


void loop() {
  unsigned long currentTime = millis();
  if (currentTime - startTime >= 1000) {
    noInterrupts();
    unsigned long totalHighTime = highTime;
    unsigned long totalLowTime = lowTime;
    highTime = 0;
    lowTime = 0;
    startTime = currentTime;
    interrupts();


    if (totalHighTime + totalLowTime > 0) {
      frequency = 1000000.0 / (totalHighTime + totalLowTime);
      dutyCycle = (totalHighTime * 100.0) / (totalHighTime + totalLowTime);
    } else {
      frequency = 0;
      dutyCycle = 0;
    }


    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Freq: ");
    lcd.print(frequency, 2); // Print frequency with 2 decimal places
    lcd.print(" Hz");
    lcd.setCursor(0, 1);
    lcd.print("Duty: ");
    lcd.print(dutyCycle, 2); // Print duty cycle with 2 decimal places
    lcd.print(" %");


    Serial.print("Frequency: ");
    Serial.print(frequency, 2); // Print frequency with 2 decimal places
    Serial.println(" Hz");
    Serial.print("Duty Cycle: ");
    Serial.print(dutyCycle, 2); // Print duty cycle with 2 decimal places
    Serial.println(" %");
  }
}


void measurePulse() {
  if (measuringHigh) {
    highTime += micros() - startTime;
  } else {
    lowTime += micros() - startTime;
  }
  measuringHigh = !measuringHigh;
  startTime = micros();
}

But du code

Ce code lit les impulsions générées par le module NE555 et calcule la fréquence et le cycle de service des impulsions. Ces valeurs sont ensuite affichées sur un écran LCD I2C ainsi que sur le moniteur série.

  • Fonction pulseIn() : Cette fonction mesure avec précision la durée des impulsions hautes et basses en microsecondes.
  • Calcul du Cycle de Service :
    Cycle de Service=Temps HautTemps Haut+Temps Bas×100\text{Cycle de Service} = \frac{\text{Temps Haut}}{\text{Temps Haut} + \text{Temps Bas}} \times 100
  • Calcul de la Fréquence :
    Freˊquence=1Temps Haut+Temps Bas\text{Fréquence} = \frac{1}{\text{Temps Haut} + \text{Temps Bas}}Étant donné que les mesures sont en microsecondes, le calcul de la fréquence est ajusté à :

    Freˊquence=1000000.0Temps Haut+Temps Bas\text{Fréquence} = \frac{1000000.0}{\text{Temps Haut} + \text{Temps Bas}}

  • Affichage sur l’Écran LCD : La fréquence et le cycle de service calculés sont affichés sur un écran LCD 16×2 I2C et imprimés sur le Moniteur Série.

Composants nécessaires pour le code avancé

  • Arduino Uno
  • Module générateur d’impulsions NE555
  • Écran LCD I2C 1602
  • Câbles de connexion

Explication détaillée du code avancé

  1. Inclusion des bibliothèques : #include <Wire.h> et #include <LiquidCrystal_I2C.h> sont nécessaires pour contrôler l’écran LCD.
  2. Initialisation : La configuration de la communication avec l’écran LCD et l’initialisation des broches de l’encodeur sont effectuées dans setup(). Une interruption est également attachée à la broche des impulsions pour compter les impulsions.
  3. Lecture et affichage des données : Les impulsions sont comptées et la fréquence est calculée toutes les secondes. La fréquence et le cycle de service sont ensuite affichés sur l’écran LCD et le moniteur série.

Brochage détaillé des connexions du code avancé

  • VCC (Module NE555) : 5V (Arduino)
  • GND (Module NE555) : GND (Arduino)
  • OUT (Module NE555) : D2 (Arduino)
  • VCC (LCD) : 5V (Arduino)
  • GND (LCD) : GND (Arduino)
  • SCL (LCD) : A5 (Arduino)
  • SDA (LCD) : A4 (Arduino)

Installation de Drivers/bibliothèques

Pour utiliser le générateur d’impulsions et l’écran LCD avec Arduino, installez la bibliothèque LiquidCrystal I2C via l’Arduino IDE :

  1. Ouvrez l’IDE Arduino.
  2. Allez dans le gestionnaire de bibliothèques.
  3. Recherchez “LiquidCrystal I2C”.
  4. Installez la bibliothèque.

 

Mots clés: generator, pulse, oscillator, Générateur d’impulsions, NE555, Arduino, Onde carrée, Pulse generator, 555 timer, Arduino tutorial, NE555 module.

Produits similaires