Arduino Episode 9 : NFC (PN532 + LCD)

Projet sympa et presque complétement abouti.

Ici, un lecteur de tag NFC connecté sur un Arduino Nano + écran LCD pour afficher l'UID du tag (en Hexa, en Décimal et en mode MSB (reverse HEXA ou reverse Decimal).

Branchements:

NANO - LCD ou PN532
GND -- (LCD) GND

5V -- (LCD) VCC
A5-- (LCD) SCL
A4-- (LCD) SDA

3V3-- (PN532) 5V

GND --(PN532) GND
D9 -- (PN532) (non connecté)
D10 -- (PN532) SCL
D11 -- (PN532) MOSI
D12 -- (PN532) MISO
D13 -- (PN532) SCK

La boite :
-Une boite en carton
-une ouverture pour l'écran (tient tout seul)
-une ouverture pour le cable d'alimentation
-le lecteur NFC fixé à la paroi avant de la boite
et le reste (cables, arduino, rallonge de cable USB) jeté en vrac


Code: 

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_PN532.h>
#include <LiquidCrystal_I2C.h>
#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();
LiquidCrystal_I2C lcd(0x27, 20, 4);

// If using the breakout with SPI, define the pins for SPI communication.
#define PN532_SCK (13)
#define PN532_MOSI (12)
#define PN532_SS (10)
#define PN532_MISO (11)

// If using the breakout or shield with I2C, define just the pins connected
// to the IRQ and reset lines. Use the values below (2, 3) for the shield!
#define PN532_IRQ (2)
#define PN532_RESET (3) // Not connected by default on the NFC Shield

// Uncomment just _one_ line below depending on how your breakout or shield
// is connected to the Arduino:

// Use this line for a breakout with a SPI connection:
//Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);

// Use this line for a breakout with a hardware SPI connection. Note that
// the PN532 SCK, MOSI, and MISO pins need to be connected to the Arduino's
// hardware SPI SCK, MOSI, and MISO pins. On an Arduino Uno these are
// SCK = 13, MOSI = 11, MISO = 12. The SS line can be any digital IO pin.
Adafruit_PN532 nfc(PN532_SS);

// Or use this line for a breakout or shield with an I2C connection:
//Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

void setup(void) {
Serial.begin(115200);
Serial.println("Hello!");

lcd.init();

nfc.begin();

uint32_t versiondata = nfc.getFirmwareVersion();
if (! versiondata) {
Serial.print("Didn't find PN53x board");
while (1); // halt
}

// Got ok data, print it out!
Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX);
Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC);
Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);

// Set the max number of retry attempts to read from a card
// This prevents us from waiting forever for a card, which is
// the default behaviour of the PN532.
nfc.setPassiveActivationRetries(0xFF);

// configure board to read RFID tags
nfc.SAMConfig();

Serial.println("Waiting for an ISO14443A card");
lcd.backlight();
}

void loop(void) {
boolean success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer to store the returned UID
uint8_t uidLength; // Length of the UID (4 or 7 bytes depending on ISO14443A card type)

lcd.clear();
lcd.setCursor(5,1);
lcd.print("DISPONIBLE");
lcd.setCursor(5,2);
lcd.print("==========");



// Wait for an ISO14443A type cards (Mifare, etc.). When one is found
// 'uid' will be populated with the UID, and uidLength will indicate
// if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);

if (success) {

Serial.println("Found a card!");
Serial.print("UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
String cardIDH = "";
String cardIDRH = "";
uint32_t cardIDD;
uint32_t cardIDRD;


for (uint8_t i=0; i < uidLength; i++)
{
//Serial.print(" 0x");Serial.print(uid[i], HEX);
cardIDH += String(uid[i], HEX);
cardIDRH = String(uid[i], HEX) + cardIDRH;

cardIDRD += (uint32_t) uid[i] << (i*8);
cardIDD += (uint32_t) uid[int(uidLength)-i-1] << (i*8);

}

//cardIDD = (uint32_t) uid[3] << 0 | (uint32_t) uid[2] << 8 | (uint32_t) uid[1] << 16 | (uint32_t) uid[0] << 24;
//cardIDRD = (uint32_t) uid[0] << 0 | (uint32_t) uid[1] << 8 | (uint32_t) uid[2] << 16 | (uint32_t) uid[3] << 24;

Serial.println("");
Serial.print("UID HexaDecimal : ");Serial.println(cardIDH);
Serial.print("UID Reverse HexaDecimal : ");Serial.println(cardIDRH);
Serial.print("UID Decimal : ");Serial.println(cardIDD);
Serial.print("UID Reverse Decimal : ");Serial.println(cardIDRD);
Serial.println("");Serial.println("");

lcd.clear();

lcd.setCursor(0,0);
lcd.print("HEX :"+cardIDH);

lcd.setCursor(0,1);
lcd.print("DEC :");
lcd.setCursor(5,1);
lcd.print(cardIDD);

lcd.setCursor(0,2);
lcd.print("RHEX:"+cardIDRH);

lcd.setCursor(0,3);
lcd.print("RDEC:");
lcd.setCursor(5,3);
lcd.print(cardIDRD);

// Wait 1 second before continuing
delay(10000);
lcd.clear();
}
else
{
// PN532 probably timed out waiting for a card
Serial.println("Timed out waiting for a card");
}
}

.

Arduino Episode 8 : RFID (RC522 + LCD)

Arduino nano et LCD et RFID

J'ai vu chez ma Veto un super truc pour lire la puce electronique de mon chat.
Je me suis dis je vais faire pareil, j'ai un écran LCD, un arduino et un lecteur RFID.
(Mauvaise fréquence pour le lecteur RFID mais c'est pas grave)
(Je voulais utiliser mon nouveau MAX7219, mais le lecteur RFID utilise les mêmes ports I2C donc il aurait fallu acheter une carte d'entrée sortie, donc je me suis rabatu sur l'écran LCD qui intégre un module arduino qui gère l'I2C(si j'ai bien compris) de plus, les pins sont différentes, et les alimentations également :D )

Branchements:

NANO / LCD
 GND sur GND
5V sur 5V
A4 sur SDA
A5 sur SCL

NANO / RFID-RC522
D10 sur SDA
D13 sur SCK
D11 sur MOSI
D12 sur MISO
ne pas brancher l'IRQ du RC522
GND<> GND
D9 sur RST
3.3V<> 3.3V

Code:

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


#define SS_PIN 10
#define RST_PIN 9
 
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class

MFRC522::MIFARE_Key key; 

// Init array that will store new NUID 
byte nuidPICC[4];

//config ecran
RCSwitch mySwitch = RCSwitch();
LiquidCrystal_I2C lcd(0x27, 20, 4);


void setup() { 
  Serial.begin(9600);
  lcd.init();
  SPI.begin(); // Init SPI bus
  rfid.PCD_Init(); // Init MFRC522 

  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }

  Serial.println(F("This code scan the MIFARE Classsic NUID."));
  Serial.print(F("Using the following key:"));
  printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
}
 
void loop() {

lcd.backlight();




  // Look for new cards
  if ( ! rfid.PICC_IsNewCardPresent())
    return;

  // Verify if the NUID has been readed
  if ( ! rfid.PICC_ReadCardSerial())
    return;

  Serial.print(F("PICC type: "));
  MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
  Serial.println(rfid.PICC_GetTypeName(piccType));

  // Check is the PICC of Classic MIFARE type
  if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&  
    piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
    piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
    Serial.println(F("Your tag is not of type MIFARE Classic."));
    return;
  }

  if (rfid.uid.uidByte[0] != nuidPICC[0] || 
    rfid.uid.uidByte[1] != nuidPICC[1] || 
    rfid.uid.uidByte[2] != nuidPICC[2] || 
    rfid.uid.uidByte[3] != nuidPICC[3] ) {
    Serial.println(F("A new card has been detected."));

    // Store NUID into nuidPICC array
    for (byte i = 0; i < 4; i++) {
      nuidPICC[i] = rfid.uid.uidByte[i];
    }
   
    Serial.println(F("The NUID tag is:"));
    Serial.print(F("In hex: "));
    printHex(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
    Serial.print(F("In dec: "));
    printDec(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
  }
  else Serial.println(F("Card read previously."));

  // Halt PICC
  rfid.PICC_HaltA();

  // Stop encryption on PCD
  rfid.PCD_StopCrypto1();
}


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

  }
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print(cardID);
}

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

Un code plus simple que le mien:
https://www.hackster.io/ravee-tansangworn/reading-rfid-card-or-key-ring-and-display-on-lcd-b2f70d

#include "LiquidCrystal_I2C.h"
#include "RFID.h"

#define SS_PIN      A2
#define RST_PIN     D3

int led1 = D7;

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
LiquidCrystal_I2C lcd(0x27,20,4);

void setup()
{ 
  lcd.init();
  lcd.backlight();
    SPI.begin();
    SPI.setClockDivider(SPI_CLOCK_DIV8);
 pinMode(led1, OUTPUT);
    mfrc522.PCD_Init();
}

void loop() {
    
    digitalWrite(led1, LOW);
    // Look for new cards, if nothing found, quit
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
     return;
    
    }
    
    // Select one of the cards, if nothing found, quit
    if ( ! mfrc522.PICC_ReadCardSerial()) {
     return;
    }
    
    String cardID = "";
    
    for (byte i = 0; i < mfrc522.uid.size; i++) {
        cardID += String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : "");
        cardID += String(mfrc522.uid.uidByte[i], HEX);
    }
    digitalWrite(led1, HIGH);
    lcd.print(cardID);
    mfrc522.PICC_HaltA();
    delay(10000);
    lcd.clear();
}

NodeMCU Episode 1 : Début et LCD

Le nodeMCU est un microcontroleur au même titre que l'arduino mais doté d'une puce ESP8266 ajoutant la possibilité d'utiliser les réseaux Wifi.

Raspberry Pi: MicroOrdinateur
Arduino: Carte de microControleur
Atmel: Puce microcontroleur (présent dans l'arduino)
ESP8266 :Puce Wifi
ESP32 : Nouvelle Génération de l'ESP8266
NodeMCU: MicroControleur avec un ESP8266

Comme l'arduino, il suffit de brancher en microUSB sur un PC et d'envoyer son code avec le logiciel ARDUINO IDE.
Arduino IDE ne comprend pas la librairie pour ce matériel, une petite installation est nécessaire.

Fichier / Préférence / URL de gestionnaire de carte supplémentaire : (ajouter ce lien)
http://arduino.esp8266.com/versions/2.4.2/package_esp8266com_index.json
Puis, Outils / Type de Carte / Gestionnaire de carte / rechercher : ESP8266 et l'installer
Encore Outils / Type de Carte : NodeMCU 0.9 (ESP 12 Module)
Encore Outils / Upload Speed: 115200


1°)Branchement
LCD > NodeMCU
GND > GND
VCC > VU
SDA > D2
SCL > D1

2°)Code :Ajouter et téléverser le code 

//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <wire.h>
#include <liquidcrystal_i2c.h>

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display

void setup()
{
  lcd.init();                      // initialize the lcd
  lcd.init();
  // Print a message to the LCD.
  lcd.backlight();
  lcd.setCursor(3,0);
  lcd.print("Hello, world!");
  lcd.setCursor(2,1);
  lcd.print("Ywrobot Arduino!");
   lcd.setCursor(0,2);
  lcd.print("Arduino LCM IIC 2004");
   lcd.setCursor(2,3);
  lcd.print("Power By Ec-yuan!");
}

void loop()
{
}

Arduino Episode 4 : LCD + 433MHz

(Arduino Nano)
Au même titre que mon raspberry, j'ai voulu utiliser mon Arduino pour afficher des informations sur mon écran LCD:

1°) Branchement :
GND sur GND
VCC sur 5V
SDA sur A4
SCL sur A5

Branchement du module 433Mhz
VCC sur 5V
GND sur GND
DATA sur D2

1BIS°) Interessant:
Il existe une fonction sur pour allumer l'écran:

lcd.backlight();
et une pour le mettre en veille.

lcd.noBacklight();

2°) Librairie sur l'outil ARDUINO IDE
Croquis / Inclure une Bibliothèque / Ajouter la bibliothèque ZIP :
http://downloads.arduino.cc/libraries/github.com/marcoschwartz/LiquidCrystal_I2C-1.1.2.zip

3°) Inclure et téléverser le code :

#include <liquidcrystal_i2c.h>


RCSwitch mySwitch = RCSwitch();
LiquidCrystal_I2C lcd(0x27, 20, 4);


void setup() {
lcd.init();
}

void loop() {
lcd.backlight();

lcd.setCursor(0,0);
lcd.print(" Test Ecran LCD");

lcd.setCursor(0,1);
lcd.print(" sur");

lcd.setCursor(0,2);
lcd.print("Arduino");

lcd.setCursor(0,3);
lcd.print("Nano");
}



Et si on rajoute un module 433 voici le code

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


RCSwitch mySwitch = RCSwitch();
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup() {
Serial.begin(9600);
mySwitch.enableReceive(0); // Receiver on interrupt 0 => that is pin #2
lcd.init();
}

void loop() {
lcd.backlight();
if (mySwitch.available()) {
output(mySwitch.getReceivedValue(), mySwitch.getReceivedBitlength(), mySwitch.getReceivedDelay(), mySwitch.getReceivedRawdata(),mySwitch.getReceivedProtocol());


lcd.setCursor(0,0);
lcd.print("value: ");
lcd.setCursor(7,0);
lcd.print(mySwitch.getReceivedValue());

lcd.setCursor(0,1);
lcd.print("delai: ");
lcd.setCursor(7,1);
lcd.print(mySwitch.getReceivedDelay());

lcd.setCursor(0,2);
lcd.print("longu:");
lcd.setCursor(7,2);
lcd.print(mySwitch.getReceivedBitlength());

lcd.setCursor(0,3);
lcd.print("Proto: ");
lcd.setCursor(7,3);
lcd.print(mySwitch.getReceivedProtocol());
mySwitch.resetAvailable();
}
}

et la fonction OutPut, comprise dans les exemples

static const char* bin2tristate(const char* bin);
static char * dec2binWzerofill(unsigned long Dec, unsigned int bitLength);

void output(unsigned long decimal, unsigned int length, unsigned int delay, unsigned int* raw, unsigned int protocol) {

if (decimal == 0) {
Serial.print("Unknown encoding.");
} else {
const char* b = dec2binWzerofill(decimal, length);
Serial.print("Decimal: ");
Serial.print(decimal);
Serial.print(" (");
Serial.print( length );
Serial.print("Bit) Binary: ");
Serial.print( b );
Serial.print(" Tri-State: ");
Serial.print( bin2tristate( b) );
Serial.print(" PulseLength: ");
Serial.print(delay);
Serial.print(" microseconds");
Serial.print(" Protocol: ");
Serial.println(protocol);
}

Serial.print("Raw data: ");
for (unsigned int i=0; i<= length*2; i++) {
Serial.print(raw[i]);
Serial.print(",");
}
Serial.println();
Serial.println();
}

static const char* bin2tristate(const char* bin) {
static char returnValue[50];
int pos = 0;
int pos2 = 0;
while (bin[pos]!='\0' && bin[pos+1]!='\0') {
if (bin[pos]=='0' && bin[pos+1]=='0') {
returnValue[pos2] = '0';
} else if (bin[pos]=='1' && bin[pos+1]=='1') {
returnValue[pos2] = '1';
} else if (bin[pos]=='0' && bin[pos+1]=='1') {
returnValue[pos2] = 'F';
} else {
return "not applicable";
}
pos = pos+2;
pos2++;
}
returnValue[pos2] = '\0';
return returnValue;
}

static char * dec2binWzerofill(unsigned long Dec, unsigned int bitLength) {
static char bin[64];
unsigned int i=0;

while (Dec > 0) {
bin[32+i++] = ((Dec & 1) > 0) ? '1' : '0';
Dec = Dec >> 1;
}

for (unsigned int j = 0; j< bitLength; j++) {
if (j >= bitLength - i) {
bin[j] = bin[ 31 + i - (j - (bitLength - i)) ];
} else {
bin[j] = '0';
}
}
bin[bitLength] = '\0';

return bin;
}