samedi 20 juin 2015

Arduino LCD 1602 I2C Funduino - Configuration Installation et Test du LCD Arduino 1602

Arduino LCD I2C 1602 Funduino


Dans ce tutoriel je vais vous présenter l'écran LCD Arduino1602 Funduino, c'est un module que j'ai acheté sur le site aliexpress.com et j'ai eu  beaucoup de mal à le faire fonctionner sur ma carte Arduino MEGA2560.

C'est pourquoi j'ai décider de mettre en place ce tuto afin d'aider les personnes qui pourraient encore chercher à configurer cet écran Arduino LCD 1602 Funduino.

Pour réaliser ce montage il va vous falloir :

- Une carte Arduino MEGA2560
- Un LCD 1602 Funduino
- Des câbles Dupont Male/Femelle
- Un Câble usb pour connecter au PC

Voici l'écran LCD 1602 Funduino dont je vous parle :

Arduino Lcd I2C 1602 - Arduino Funduino Tuto - Lcd Arduino I2c
Lcd Arduino I2c - Tuto installation et configuration Arduino LCD I2C Funduino




Maintenant passons au branchement du LCD 1602 à la carte de programmation Arduino MEGA.

Sur le module 1602 nous avons les ports, SDA, SCL, GND et VCC.

Sur la carte Arduino vous allez brancher le VCC au 5V et le GND au GND, jusque la rien de bien compliquer, c'est pour le SDA et le SCL que ca peut s'avérer plus difficile à comprendre.

Dans un tutoriel en anglais j'ai vu que cette personne branche les câbles de cette façon :

- SDA ==> A4
- SCL ==> A5

Dans mon cas j'ai du connecter le SDA au SDA et le SCL au SCL de ma carte Arduino alors faites attention à vérifier vos branchements avant de modifier des lignes de code.

Afin de vérifier si votre écran LCD 1602 est bien détecter par votre carte Arduino vous pouvez charger le programme Scanner_I2C.
Il  va vous permettre de savoir si votre écran est bien brancher et d'identifier l'adresse du lcd à modifier ou non dans le programme du LCD.


Voici un exemple pour que vous compreniez mieux ce que je veux dire :

Arduino I2C LCD
Branchement sur les pins A4 et A5 qui ne fonctionne pas (No I2C devices found)
Arduino Lcd I2C
Branchement sur les pins SDA et SCL, cela fonctionne et l'adresse du LCD 1602 est 0x27 ! (I2C device found at address 0x27)

Une fois que vous aurez réussis à brancher correctement votre LCD au Arduino il faudra installer la librairie disponible pour celui-ci :

 Librairie LiquidCrystal_I2C

Lorsque vous aurez installer cette librairie, chargez ce code et voyez si un Hello World s'affiche à l'écran.

//Test Ecran LCD 1602 Funduino

// Librairies

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

// Adresse de L'ecran LCD 1602 Funduino
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address


/*-----( Declare Variables )-----*/
//none

void setup()   /*----( SETUP: RUNS ONCE )----*/
{
  Serial.begin(9600);  // Used to type in characters

  lcd.begin(16,2);         // initialize the lcd for 20 chars 4 lines and turn on backlight

// ------- Quick 3 blinks of backlight  -------------
  for(int i = 0; i< 3; i++)
  {
    lcd.backlight();
    delay(250);
    lcd.noBacklight();
    delay(250);
  }
  lcd.backlight(); // finish with backlight on 
  
//-------- Write characters on the display ----------------
// NOTE: Cursor Position: CHAR, LINE) start at 0 
  lcd.setCursor(3,0); //Start at character 4 on line 0
  lcd.print("Hello, world!");
  delay(1000);
  lcd.setCursor(2,1);
  lcd.print("From YourDuino");
  delay(1000); 
  lcd.setCursor(0,2);
  lcd.print("20 by 4 Line Display");
  lcd.setCursor(0,3);
  delay(2000);  
  lcd.print("http://YourDuino.com");
  delay(8000);
// Wait and then tell user they can start the Serial Monitor and type in characters to
// Display. (Set Serial Monitor option to "No Line Ending")
  lcd.setCursor(0,0); //Start at character 0 on line 0
  lcd.print("Start Serial Monitor");
  lcd.setCursor(0,1);
  lcd.print("Type chars 2 display");  

lcd.setCursor(0,0);

}/*--(end setup )---*/


void loop()   /*----( LOOP: RUNS CONSTANTLY )----*/
{
  {
    // when characters arrive over the serial port...
    if (Serial.available()) {
      // wait a bit for the entire message to arrive
      delay(100);
      // clear the screen
      lcd.clear();
      // read all the available characters
      while (Serial.available() > 0) {
        // display each character to the LCD
        lcd.write(Serial.read());
      }
    }
  }

}/* --(end main loop )-- */


/* ( THE END ) */

Voila j’espère vous avoir aider à faire fonctionner votre ecran Arduino LCD 1602 Funduino, si vous avez des questions n'hésitez à m'en faire part en laissant un commentaire et j'y répondrais au plus vite.

Lecteur RFID Arduino RC522A - Mise en place Test et lecture d'un badge et d'une carte RFID

  Lecteur RFID Arduino RC522A - Test et Lecture Bade et Carte


Dans ce tutoriel je vous présente comment configurer et installer un lecteur de carte RFID compatible avec la carte de programmation Arduino.

Le lecteur RFID Arduino que j'utilise est le RFID-RC522A, il m'a été livré avec un badge et une carte RFID.


Pour comparer à d'autres versions voici les images :
Lecteur RFID Ardunio RC522A
Module Lecteur RFID Arduino RC522A - Avant
Arduino lecteur RFID RC522A
Module Lecteur RFID Arduino RC522A - Arrière


Une fois le lecteur RFID-RC522A présenté nous pouvons passer à la partie câblage, sur ce module nous avons plusieurs connections qui sont le SDA, le SCK, le MOSI, le MISO, le GND, le RST et le 3.3V.

Sur notre carte Arduino, dans mon cas la MEGA2560 il va falloir câbler comme il suit.

- SDA  ==> 53
- SCK ==> 52
- MOSI ==> 51
- MISO ==> 50
- GND ==> GND
- RST(Reset) ==> 9 (PWM)
- 3.3V ==> 3.3V

Pour illustrer tout ça voici le montage que j'ai réalisé à l'aide de câbles dupont mâle/femelle :

Arduino RFID RC522A

Ensuite il va falloir configurer le programme de notre carte Arduino afin de fonctionner correctement avec le lecteur RFID RC522A.

Pour cela il va falloir que vous téléchargiez la librairie qui  va bien qui est disponible ici :

Librairie RFID-Master

Je vous laisse le soin d'installer cette libraire au bon endroit et ensuite il ne vous reste plus qu'à essayer le fichier suivant pour tester le bon fonctionnement de votre montage Arduino + RFID.

Uploadez ce code sur votre carte Arduino et ouvrez le  Moniteur Série une fois que cela est terminé, et en passant votre badge ou votre carte RFID devant le lecteur vous devriez voir apparaître un test de lecture comme celui-ci :

lecteur rfid rc522a arduino
Test de lecture d'un Badge RFID sur Arduino avec le Module RFID-RC522A


// Test Code RFID RC522A - Read and Write

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN         5           // Configurable, see typical pin layout above
#define SS_PIN          53          // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.

MFRC522::MIFARE_Key key;

/**
 * Initialize.
 */
void setup() {
    Serial.begin(9600); // Initialize serial communications with the PC
    while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
    SPI.begin();        // Init SPI bus
    mfrc522.PCD_Init(); // Init MFRC522 card

    // Prepare the key (used both as key A and as key B)
    // using FFFFFFFFFFFFh which is the default at chip delivery from the factory
    for (byte i = 0; i < 6; i++) {
        key.keyByte[i] = 0xFF;
    }

    Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write."));
    Serial.print(F("Using key (for A and B):"));
    dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE);
    Serial.println();
   
    Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1"));
}

/**
 * Main loop.
 */
void loop() {
    // Look for new cards
    if ( ! mfrc522.PICC_IsNewCardPresent())
        return;

    // Select one of the cards
    if ( ! mfrc522.PICC_ReadCardSerial())
        return;

    // Show some details of the PICC (that is: the tag/card)
    Serial.print(F("Card UID:"));
    dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
    Serial.println();
    Serial.print(F("PICC type: "));
    byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
    Serial.println(mfrc522.PICC_GetTypeName(piccType));

    // Check for compatibility
    if (    piccType != MFRC522::PICC_TYPE_MIFARE_MINI
        &&  piccType != MFRC522::PICC_TYPE_MIFARE_1K
        &&  piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
        Serial.println(F("This sample only works with MIFARE Classic cards."));
        return;
    }

    // In this sample we use the second sector,
    // that is: sector #1, covering block #4 up to and including block #7
    byte sector         = 1;
    byte blockAddr      = 4;
    byte dataBlock[]    = {
        0x01, 0x02, 0x03, 0x04, //  1,  2,   3,  4,
        0x05, 0x06, 0x07, 0x08, //  5,  6,   7,  8,
        0x08, 0x09, 0xff, 0x0b, //  9, 10, 255, 12,
        0x0c, 0x0d, 0x0e, 0x0f  // 13, 14,  15, 16
    };
    byte trailerBlock   = 7;
    byte status;
    byte buffer[18];
    byte size = sizeof(buffer);

    // Authenticate using key A
    Serial.println(F("Authenticating using key A..."));
    status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
    if (status != MFRC522::STATUS_OK) {
        Serial.print(F("PCD_Authenticate() failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
        return;
    }

    // Show the whole sector as it currently is
    Serial.println(F("Current data in sector:"));
    mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
    Serial.println();

    // Read data from the block
    Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
    Serial.println(F(" ..."));
    status = mfrc522.MIFARE_Read(blockAddr, buffer, &size);
    if (status != MFRC522::STATUS_OK) {
        Serial.print(F("MIFARE_Read() failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
    }
    Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":"));
    dump_byte_array(buffer, 16); Serial.println();
    Serial.println();

    // Authenticate using key B
    Serial.println(F("Authenticating again using key B..."));
    status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid));
    if (status != MFRC522::STATUS_OK) {
        Serial.print(F("PCD_Authenticate() failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
        return;
    }

    // Write data to the block
    Serial.print(F("Writing data into block ")); Serial.print(blockAddr);
    Serial.println(F(" ..."));
    dump_byte_array(dataBlock, 16); Serial.println();
    status = mfrc522.MIFARE_Write(blockAddr, dataBlock, 16);
    if (status != MFRC522::STATUS_OK) {
        Serial.print(F("MIFARE_Write() failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
    }
    Serial.println();

    // Read data from the block (again, should now be what we have written)
    Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
    Serial.println(F(" ..."));
    status = mfrc522.MIFARE_Read(blockAddr, buffer, &size);
    if (status != MFRC522::STATUS_OK) {
        Serial.print(F("MIFARE_Read() failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
    }
    Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":"));
    dump_byte_array(buffer, 16); Serial.println();
       
    // Check that data in block is what we have written
    // by counting the number of bytes that are equal
    Serial.println(F("Checking result..."));
    byte count = 0;
    for (byte i = 0; i < 16; i++) {
        // Compare buffer (= what we've read) with dataBlock (= what we've written)
        if (buffer[i] == dataBlock[i])
            count++;
    }
    Serial.print(F("Number of bytes that match = ")); Serial.println(count);
    if (count == 16) {
        Serial.println(F("Success :-)"));
    } else {
        Serial.println(F("Failure, no match :-("));
        Serial.println(F("  perhaps the write didn't work properly..."));
    }
    Serial.println();
       
    // Dump the sector data
    Serial.println(F("Current data in sector:"));
    mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
    Serial.println();

    // Halt PICC
    mfrc522.PICC_HaltA();
    // Stop encryption on PCD
    mfrc522.PCD_StopCrypto1();
}

/**
 * Helper routine to dump a byte array as hex values to Serial.
 */
void dump_byte_array(byte *buffer, byte bufferSize) {
    for (byte i = 0; i < bufferSize; i++) {
        Serial.print(buffer[i] < 0x10 ? " 0" : " ");
        Serial.print(buffer[i], HEX);
    }
}

Voila j’espère que ce tutoriel sur le module RFID Arduino RC522A pourra vous aider dans vos recherches et n'hésitez pas à me laisser un commentaire si vous avez une question ou une suggestion à faire à propose de l'un de mes tutoriels.

Arduino et DHT11 - Capteur de Température et d'Humidité

Capteur de Température et d'Humidité DHT11 Arduino


Dans ce tutoriel je vais vous apprendre à utiliser un module pour la carte de programmation Arduino qui est le DHT11.

Ce module DHT11 est une sonde permettant de mesurer la température et l'humidité, contrairement à un DS18B20 ou à un LM35 qui sont fait seulement pour fonctionner comme capteur de température et non pour capter l'humidité.
Il vous faudra donc identifier quel module utiliser selon les besoins de votre projet.

Sonde DHT11 Température et Humidité - Face Avant

Sonde DHT11 Température et Humidité - Face Arrière


Pour utiliser cette sonde vous avez seulement besoin :

- d'une carte Arduino ( MEGA2560 de préférence c'est plus simple)
- de câbles Dupont Mâle et Femelle 
- d'un module DHT11
- d'un câble usb pour communiquer avec le PC


Cette sonde est très simple à utiliser, elle dispose de 3 pins qui sont  le VCC, le OUT et le GND.

Pour que ce module DHT11 fonctionne avec arduino il vous faudra brancher le VCC au 5V, le OUT à un pin Digital ( exemple: D5 ) et le GND au GROUND.

Voici un exemple de câblage pour vous faire une idée.

Carte Arduino + Sonde Température et Humidité DHT11


Une fois les branchements effectués il va falloir installer la librairie DHTLib qui est disponible ici : Librairie DHT11 - DHTLib

Ensuite, vous avez le choix de copier/coller la version test de DHTLib traduite en français par mes soins ou bien de charger le fichier DHT11_test à partir de la librairie DHTLib sur le logiciel Arduino.

DHT11_Test  Français :


//
//    DHT11 - Version Test
// Traduite en français par le site MakeDuino.blogspot.fr
//



// Charger la Librairie
#include <dht.h>

dht DHT;

// Choisir le numéro du port Digital du DHT11
#define DHT11_PIN 5

void setup()
{
  Serial.begin(115200);
  Serial.println("DHT TEST PROGRAM ");
  Serial.print("LIBRARY VERSION: ");
  Serial.println(DHT_LIB_VERSION);
  Serial.println();
  Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
}

void loop()
{
  // Lecture des Données - Température et Humidité
  Serial.print("DHT11, \t");
  int chk = DHT.read11(DHT11_PIN);
  switch (chk)
  {
    case DHTLIB_OK: 
        Serial.print("OK,\t");
        break;
    case DHTLIB_ERROR_CHECKSUM:
        Serial.print("Checksum error,\t");
        break;
    case DHTLIB_ERROR_TIMEOUT:
        Serial.print("Time out error,\t");
        break;
    case DHTLIB_ERROR_CONNECT:
        Serial.print("Connect error,\t");
        break;
    case DHTLIB_ERROR_ACK_L:
        Serial.print("Ack Low error,\t");
        break;
    case DHTLIB_ERROR_ACK_H:
        Serial.print("Ack High error,\t");
        break;
    default:
        Serial.print("Unknown error,\t");
        break;
  }
  // Affichage des Données - Température et Humidité
  Serial.print(DHT.humidity, 1);
  Serial.print(",\t");
  Serial.println(DHT.temperature, 1);

  delay(2000);
}
//
// END OF FILE
//


Voila j’espère vous avoir aider à faire fonctionner votre capteur de température DHT11 sous Arduino et si vous avez des questions où bien des améliorations à porter sur mon tutoriel n'hésitez pas à laisser un commentaire.