ARDUINO: KEYPAD

Keypad

Dans ce tutoriel, je vais vous montrer comment configurer un clavier sur l'Arduino. Je vais d'abord expliquer comment l'Arduino détecte les touches, puis je vais vous montrer comment trouver le brochage de n'importe quel clavier. Comme un exemple simple, je vais vous montrer comment afficher les touches sur le moniteur série et un écran LCD.

Je vais utiliser un  clavier  à membrane matricielle 4X4 dans cet article, mais il y a aussi des diagrammes de code et de câblage pour  les claviers matriciels 3X4.

Les calviers sont un excellent moyen de permettre aux utilisateurs d’intéragir avec vos projet.vous pouvez les utiliser pour naviguer dans les menu, entrer des mots de passe et contrôler des jeux et des robots.

Cet exemple utilise la bibliothèque keypad arduino.

Matériels requis

      ·      Carte Arduino

      ·      Keypad

      ·      LCD

      ·      fils de raccordement

Comment fonctionne les claviers

Les boutons d'un clavier sont disposés en rangées et en colonnes. Un clavier 3X4 a 4 lignes et 3 colonnes, et un clavier 4X4 a 4 lignes et 4 colonnes:

Sous chaque clé se trouve un interrupteur à membrane. Chaque commutateur d'une rangée est connecté aux autres commutateurs de la rangée par une trace conductrice sous le tampon. Chaque commutateur dans une colonne est connecté de la même manière - un côté du commutateur est connecté à tous les autres commutateurs dans cette colonne par une trace conductrice. Chaque rangée et chaque colonne est portée à une seule broche, pour un total de 8 broches sur un clavier 4X4:

Appuyer sur un bouton ferme le commutateur entre une trace de colonne et une trace de ligne, permettant au courant de circuler entre une broche de colonne et une broche de rangée.

Le schéma d'un clavier 4X4 montre comment les lignes et les colonnes sont connectées:

L'Arduino détecte quel bouton est enfoncé en détectant la broche de ligne et de colonne connectée au bouton.

Cela se passe en quatre étapes:

1. Tout d'abord, lorsque vous n'appuyez sur aucun bouton, toutes les broches de la colonne sont maintenues ÉLEVÉES et toutes les broches de la rangée sont maintenues LOW:

2. Lorsqu'un bouton est enfoncé, la goupille de la colonne est tirée vers le bas car le courant de la colonne HAUTE s'écoule vers la broche de la ligne BAS:

3. L'Arduino sait maintenant dans quelle colonne se trouve le bouton, donc maintenant il doit juste trouver la rangée dans laquelle se trouve le bouton. Il le fait en commutant chacune des broches de la ligne HIGH, et en même temps en lisant toute la colonne broches pour détecter quelle broche de colonne retourne à HAUT:

4. Lorsque la broche de la colonne redevient haute, l'Arduino a trouvé la broche de ligne qui est connectée au bouton:

À partir du diagramme ci-dessus, vous pouvez voir que la combinaison de la ligne 2 et de la colonne 2 ne peut que signifier que le bouton numéro 5 a été enfoncé.

Schématique

La disposition des broches pour la plupart des claviers à membrane ressemblera à ceci:

Suivez les schémas ci-dessous pour connecter le clavier à un Arduino Uno, selon que vous avez un clavier 3X4 ou 4X4:

On connecte maintenant l’afficheur pour visualiser le bouton appuyé comme suit :

 Code

/ *
       DIY Electronics par Bessem BELGHITH 

      Imprimer  bouton enfoncé d’un KEYPAD sur un LCD
 * / 

#include <LiquidCrystal.h>;

#include <Keypad.h>;

const byte ROWS = 4; // 4 lignes

const byte COLS = 3; //3 colonnes

char keys[ROWS][COLS] = {

    {'1','2','3'},

    {'4','5','6'},

    {'7','8','9'},

    {'*','0','#'}

};

byte rowPins[ROWS] = {10, 9, 8, 7}; //connecter au pins des lignes du keypad

byte colPins[COLS] = {13, 12, 11}; //connecter au pins des colonnes du keypad

LiquidCrystal lcd(A0, A1, A2, A3, A4, A5);

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup() {

   lcd.begin(16, 2);

  lcd.print("KEYPAD TEST ");

}

void loop() {

char key = keypad.getKey();

    if (key) {

        lcd.setCursor(0, 1);

        lcd.print(key);

    }

}

ARDUINO: ServoMoteur

ServoMoteur

Contrôlez la position d'un servomoteur avec votre Arduino et un potentiomètre.

Cet exemple utilise la bibliothèque servo Arduino .

Matériels requis

      ·      Carte Arduino

      ·      Servomoteur

      ·      Potentiomètre 10k ohm

      ·      fils de raccordement

Circuit

Les servomoteurs ont trois fils: l'alimentation, la masse et le signal. Le fil d'alimentation est généralement rouge et doit être connecté à la broche 5V de la carte Arduino ou Genuino. Le fil de terre est généralement noir ou marron et doit être connecté à une broche de masse sur la carte. La broche de signal est généralement jaune ou orange et doit être connectée à la broche 9 sur la carte.

Le potentiomètre doit être câblé de sorte que ses deux broches externes soient connectées à l'alimentation (+ 5V) et à la masse, et que sa broche centrale soit connectée à l'entrée analogique 0 de la carte.

Schématique

Code

/ *
       DIY Electronics par Bessem BELGHITH 

      Contrôle d'une position d'asservissement à l'aide d'un potentiomètre (résistance variable)
 * / 

#include <Servo.h>

Servo myservo ;  // crée un objet servo pour contrôler un servo 

int potpin = 0 ;  // broche analogique utilisée pour connecter le potentiomètre 
int val ;    // variable pour lire la valeur de la pin analogique 

void setup ( ) {
  myservo. attach ( 9 );  // attache le servo sur la broche 9 à l'objet asservi 
}

void loop ( ) {
  val = analogRead ( potpin ) ;                   // lit la valeur du potentiomètre (valeur comprise entre 0 et 1023)
  val = map ( val , 0 , 1023 , 0 , 180 ) ;     // mise à l'échelle pour l'utiliser avec le servo (valeur entre 0 et 180)
  myservo. write ( val ) ;                         // définit la position d'asservissement en fonction du délai de mise à l'échelle
   delay( 15 ) ;                                         // attend que le servo arrive 

}

ARDUINO: Digital Read Serial

Digital Read Serial

Cet exemple vous montre comment surveiller l'état d'un commutateur en établissant une communication série entre votre Arduino et votre ordinateur via USB.

Matériels requis

      ·      Carte Arduino

      ·      Un bouton poussoir

      ·      Résistance de 10k ohm

      ·      fils de raccordement

      ·      plaque à trous

Circuit

Connectez trois fils à la carte. Les deux premiers, rouge et noir, se connectent aux deux longues rangées verticales sur le côté de la carte de test pour permettre l'accès à l'alimentation 5 volts et à la masse. Le troisième fil passe de la broche numérique 2 à une branche du bouton-poussoir. Cette même pin du bouton se connecte à travers une résistance pull-down (ici 10k ohms) à la masse. L'autre pin du bouton se connecte à l'alimentation 5 volts.

Les boutons poussoirs ou les commutateurs connectent deux points dans un circuit lorsque vous les appuyez. Lorsque le bouton-poussoir est ouvert (non pressé) il n'y a pas de connexion entre les deux branches du bouton-poussoir, donc la broche est connectée à la masse (à travers la résistance pull-down) et indique LOW ou 0. Lorsque le bouton est fermé), il fait une connexion entre ses deux pins, reliant la broche à 5 volts, de sorte que la broche se lit comme HIGH, ou 1.

Si vous déconnectez la broche d'E/S numérique de tout, la LED peut clignoter de manière erratique. C'est parce que l'entrée est "flottante" - c'est-à-dire qu'elle n'a pas une connexion solide à la tension ou à la masse, et elle retournera au hasard soit HAUTE, soit BASSE. C'est pourquoi vous avez besoin d'une résistance de pull-down dans le circuit.

Schématique

Code

Dans le programme ci-dessous, la toute première chose que vous ferez dans la fonction de configuration est de commencer les communications série, à 9600 bits de données par seconde, entre votre carte et votre ordinateur avec la ligne:

Serial.begin(9600);

Ensuite, initialisez la broche numérique 2, la broche qui lira la sortie de votre bouton, en entrée:

pinMode(2,INPUT);

Maintenant que votre configuration est terminée, déplacez-vous dans la boucle principale de votre code. Lorsque votre bouton est pressé, 5 volts circulent librement dans votre circuit, et quand il n'est pas pressé, la broche d'entrée sera connectée à la masse à travers la résistance de 10k ohms. Ceci est une entrée numérique, ce qui signifie que le commutateur ne peut être que dans un état activé (vu par votre Arduino comme un "1" ou HIGH) ou un état éteint (vu par votre Arduino comme un "0", ou LOW), avec rien entre.

La première chose que vous devez faire dans la boucle principale de votre programme est d'établir une variable pour contenir les informations provenant de votre commutateur. Puisque les informations provenant du commutateur seront soit "1" soit "0", vous pouvez utiliser un int type de données . Appelez cette variable sensorValue, et réglez-la pour qu'elle soit identique à celle qui est en train d'être lue sur la broche numérique 2. Vous pouvez accomplir tout cela avec une seule ligne de code:

int sensorValue = digitalRead(2);

Une fois que le bord a lu l'entrée, faites-le imprimer cette information sur l'ordinateur en tant que valeur décimale. Vous pouvez le faire avec la commande Serial.println () dans notre dernière ligne de code:

Serial.println(sensorValue);

Maintenant, lorsque vous ouvrez votre moniteur série dans le logiciel Arduino (IDE), vous verrez un flux de "0" si votre commutateur est ouvert, ou "1" si votre commutateur est fermé.

/ *
      DIY Electronics par Bessem BELGHITH 

      DigitalReadSerial
      Lit une entrée numérique sur la broche 2, imprime le résultat sur le          moniteur série
* / 

    // La broche numérique 2 est dotée d'un bouton-poussoir. Donnez-lui un      nom: 
  int pushButton = 2 ;

  // la routine d'installation s'exécute une fois lorsque vous appuyez sur      reset: 
  void setup ( ) {
  // initialise la communication série à 9600 bits par seconde: 
  Serial . commencer ( 9600 ) ;
  // fait de la broche du bouton une entrée: 
  pinMode (pushButton , INPUT ) ;
}

   // le sous-programme de la boucle est répété indéfiniment: 
void loop ( ) {
  // lecture de la broche d'entrée: 
  int buttonState = digitalRead ( pushButton ) ;
  // affiche l'état du bouton: 
  Serial. println ( buttonState ) ;
  delay ( 1 ) ;        // délai entre les lectures pour la stabilité 
}

ARDUINO: Lecture analogique

Lecture analogique

Cet exemple vous montre comment lire l'entrée analogique du monde physique à l'aide d'un potentiomètre. 

Un potentiomètre est un dispositif mécanique simple qui fournit une quantité variable de résistance lorsque son arbre est tourné. En passant la tension à travers un potentiomètre et dans une entrée analogique sur votre carte, il est possible de mesurer la quantité de résistance produite par un potentiomètre comme une valeur analogique. Dans cet exemple, vous surveillerez l'état de votre potentiomètre après avoir établi une communication série entre votre Arduino et votre ordinateur exécutant le logiciel Arduino (IDE).

Matériels requis

     ·      Carte Arduino

     ·      Potentiomètre 10k ohm

Circuit

Connectez les trois fils du potentiomètre à votre tableau. Le premier se relie de l'une des broches externes du potentiometer à la masse. La seconde se relie de l'autre broche externe du potentiomètre à 5 volts. Le troisième se relie de la broche médiane du potentiomètre à la broche analogique A0.

En tournant l'arbre du potentiomètre, vous modifiez la quantité de résistance. Cela modifie la tension au niveau de la broche centrale. Lorsque la résistance entre le centre et le côté connecté à 5 volts est proche de zéro (et la résistance de l'autre côté est proche de 10k ohms), la tension à la broche centrale s'approche de 5 volts. Lorsque les résistances sont inversées, la tension au niveau de la broche centrale est proche de 0 volt ou de la masse. Cette tension est la tension analogique que vous lisez en entrée.

Les cartes Arduino ont un circuit interne appelé un convertisseur analogique-numérique ou ADC qui lit cette tension changeante et la convertit en un nombre entre 0 et 1023. Lorsque l'arbre est complètement tourné dans une direction, il y a 0 volts allant à la broche, et la valeur d'entrée est 0. Lorsque l'arbre est tourné tout le chemin dans le sens opposé, il y a 5 volts allant à la broche et la valeur d'entrée est 1023. Entre-deux, analogRead () renvoie un nombre entre 0 et 1023, proportionnel à la tension appliquée sur la broche.

Schématique

Code

Dans l'esquisse ci-dessous, la seule chose que vous faites dans la fonction de configuration est de commencer les communications série, à 9600 bits de données par seconde, entre votre carte et votre ordinateur avec la commande:

Serial.begin(9600);

Ensuite, dans la boucle principale de votre code, vous devez établir une variable pour stocker la valeur de résistance (qui sera comprise entre 0 et 1023, parfait pour un int type de données ) venant de votre potentiomètre:

int sensorValue = analogRead(A0);

Enfin, vous devez imprimer cette information dans votre fenêtre de moniteur série. Vous pouvez le faire avec la commande Serial.println () dans votre dernière ligne de code:

Serial.println(sensorValue)

Maintenant, lorsque vous ouvrez votre moniteur série dans le logiciel Arduino (IDE) (en cliquant sur l'icône qui ressemble à un objectif, sur la droite, dans la barre supérieure verte ou en utilisant le raccourci clavier Ctrl + Shift + M), vous devriez voir un flux régulier de nombres allant de 0 à 1023, en corrélation avec la position du pot. Lorsque vous tournez votre potentiomètre, ces chiffres répondent presque instantanément.

/ *
   DIY Electronics par Bessem BELGHITH 

   AnalogReadSerial

  cet exemple Lit une entrée analogique sur la broche 0, imprime le résultat    sur le moniteur série.
  La représentation graphique est disponible à l'aide du traceur série

  Fixez la broche centrale d'un potentiomètre à la broche A0 et les broches    extérieures à + 5V et à la masse.


* / 

// la routine d'installation s'exécute une fois lorsque vous appuyez sur reset: 
void setup ( ) {
  // initialise la communication série à 9600 bits par seconde: 
  Serial.begin ( 9600 ) ;
}

// le sous-programme de la boucle s'exécute encore et encore pour toujours: 
void loop ( ) {
  // lit l'entrée sur la broche analogique 0: 
  int sensorValue = analogRead ( A0 ) ;
  // affiche la valeur que vous avez lu: 
  Serial . println ( sensorValue ) ;
  delay ( 1 ) ;        // délais entre les lectures pour la stabilité 
}

ARDUINO: BLINK

Notre premier programme Arduino

Cet exemple montre la chose la plus simple que vous pouvez faire avec un Arduino pour voir la sortie physique: il clignote la LED embarquée.

Matériels requis

      ·      Carte Arduino

      ·      LED 

      ·      Résistance de 220 ohms

Circuit

Cet exemple utilise le voyant intégré de la plupart des cartes Arduino. Cette LED est connectée à une broche numérique et son numéro peut varier d'un type de carte à un type de carte.
Si vous souhaitez allumer une LED externe avec cette esquisse, vous devez construire ce circuit, où vous connectez une extrémité de la résistance à la broche numérique correspondant à la constante pinLed. Connectez la longue jambe de la LED (la jambe positive, appelée l'anode) à l'autre extrémité de la résistance. Connectez la jambe courte de la LED (la jambe négative, appelée la cathode) à la GND. Dans le diagramme ci-dessous, nous montrons une carte UNO qui a D13 comme valeur pinLed.

La valeur de la résistance en série avec la LED peut être d'une valeur différente de 220 ohms; la LED s'allume également avec des valeurs allant jusqu'à 1K ohm.

Schématique

Code

Après avoir construit le circuit branchez votre carte Arduino dans votre ordinateur, démarrez le logiciel Arduino (IDE) et entrez le code ci-dessous. Vous pouvez également le charger à partir du menu Fichier / Exemples / 01.Basics / Blink. La première chose que vous faites est d'initialiser la broche pinLed en tant que broche de sortie avec la ligne

pinMode(pinLed, OUTPUT);

Dans la boucle principale, vous allumez la LED avec la ligne:

digitalWrite(pinLed, HIGH);

Ceci fournit 5 volts à l'anode de LED. Cela crée une différence de tension entre les broches de la LED et l'allume. Ensuite, vous l'éteignez avec la ligne:

digitalWrite(pinLed, LOW);

///////////////////////////////////////////////////////////////////////

////////            DIY Electronic par Bessem Belghith         ////////                                                     

////////  Allumer une diode Led pendant 1 seconde puis fermer  ////////

////////               la diode led  pendant une seconde       ////////

///////////////////////////////////////////////////////////////////////

// La roche 13 a une LED connectée sur la plupart des cartes Arduino.
void setup ( ) {
  // initialise la broche numérique pinLed en sortie. 
  pinMode ( pinLed , OUTPUT ) ;
}

// la boucle fonctionne encore et encore pour toujours 
void loop ( ) {
  digitalWrite ( pinLed , HIGH ) ;   // Allumer LED 
  delay ( 1000 ) ;                  // attendre une seconde 
  digitalWrite ( pinLed , LOW ) ;    // éteindre LED  
  delay ( 1000 ) ;                   // attend une seconde 
}