Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente | ||
projets:puuce [26/01/2018 14:11] – [L'application de gestion : PUUCE.GINFO] pnahoum | projets:puuceold [15/03/2019 10:02] (Version actuelle) – ↷ Nom de la page changé de projets:puuce à projets:puuceold rgrondin | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | ======Projet PUUCE : Cartes magnétiques====== | ||
+ | =====Introduction===== | ||
+ | Le projet PUUCE a été initié en 2017 par pnahoum et a pour objectif d' | ||
+ | |||
+ | L' | ||
+ | |||
+ | |||
+ | =====Le système : vue d' | ||
+ | |||
+ | Le premier objectif est de créer un lecteur de carte qui puisse lire les cartes de type **MiFare Ultralight C** (type des cartes étudiants), | ||
+ | |||
+ | Le système est composé de plusieurs élements interconnectés : | ||
+ | |||
+ | -> __Le lecteur de carte :__ positionné à l' | ||
+ | |||
+ | -> __Le boitier de traitement :__ composé d'une entrée d' | ||
+ | |||
+ | -> __La gâche électrique :__ connectée au boitier de traitement, celle ci s' | ||
+ | |||
+ | -> __Le raspberry PI :__ il est connecté au système via la nappe IDE et connecté en Ethernet au réseau du GINFO. | ||
+ | |||
+ | -> __Un élement " | ||
+ | |||
+ | |||
+ | Chacune des parties de la suivante documentation détaille le fonctionnement de chaque unité de manière séparée. Une note finale explique comment interconnecter les différents éléments pour avoir un système fonctionnel. | ||
+ | |||
+ | ===== Le lecteur de carte ===== | ||
+ | |||
+ | Le lecteur de carte est composé de plusieurs éléments : | ||
+ | * Un boitier interrupteur plastique vidé de son électronique (pour y placer la notre) (ref : [[https:// | ||
+ | * Un module de lecteur MIFARE PN532 miniaturisé (cf : image ci dessous ou lien [[https:// | ||
+ | * Un buzzer piezzo | ||
+ | * Un connecteur de type DB-9 femelle (qui fera le lien avec note boitier de traitement) | ||
+ | |||
+ | Ci dessous vous trouverez les images de ces 4 éléments nécessaires à la réalisation du boitier | ||
+ | |||
+ | {{: | ||
+ | |||
+ | Le principe du lecteur est assez simple. Il doit envoyer au boitier de traitement (via le connecteur DB9) l'UID de la carte lue. Si la carte est lue, le boitier de traitement confirmera la lecture et l' | ||
+ | |||
+ | Le transfert de données est effectué via le Protocole SPI vers le boitier de traitement. Pour cela, il faut brancher correctement le module et activer le module SPI en tournant le pin de réglage au bon endroit sur le module. Ci dessous vous trouverez les images des branchements sur le module lors de la phase de prototypage. | ||
+ | |||
+ | |||
+ | {{: | ||
+ | |||
+ | {{: | ||
+ | |||
+ | Enfin, il faut tout faire rentrer dans l' | ||
+ | |||
+ | {{ : | ||
+ | |||
+ | Le tout est collé à la colle chaude sur l' | ||
+ | |||
+ | A noter qu'une amélioration future possible serait l' | ||
+ | ===== Le boitier de traitement ===== | ||
+ | |||
+ | Le boitier de traitement est le coeur du système. Il permet d' | ||
+ | |||
+ | Il dispose de plusieurs entrées : | ||
+ | * Une entrée d' | ||
+ | * Une entrée d' | ||
+ | * Une sortie (prise circulaire 2,1mm) pour connecter l' | ||
+ | * Un port DB-9 pour connecter le lecteur de carte placé à l' | ||
+ | * Un port IDE male pour transférer les données du lecteurs au Raspberry PI, et alimenter le Raspberry PI | ||
+ | |||
+ | {{: | ||
+ | |||
+ | Il faut savoir que tout ce qui arrive sur le port DB-9 est directement redirigé vers le port IDE male, le boitier de traitement n' | ||
+ | |||
+ | Le tout est placé dans un boitier en bois dont le design n'est pas définitif. | ||
+ | |||
+ | Le schéma est donné ci dessous : | ||
+ | {{ : | ||
+ | ===== La Gâche Electrique ===== | ||
+ | |||
+ | La gâche électrique est très simple. Elle s' | ||
+ | |||
+ | Ce gâche est encastrée dans le dormant de la porte et est connectée à un cable dont la sorte est circulaire 2,1mm. | ||
+ | |||
+ | {{: | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ===== La Raspberry PI ===== | ||
+ | |||
+ | //Nous supposons pour commencer que vous avez une Raspberry PI avec Raspbian d' | ||
+ | Dans le cas de la porte du GINFO, **l'IP du Raspberry PI est 10.61.16.70** | ||
+ | |||
+ | {{ : | ||
+ | |||
+ | La raspberry pi est alimentée et interagit avec le système via son port de 2x20 pins, il faut un cable IDE (Parallel ATA) pour le relier avec le reste du système. | ||
+ | |||
+ | |||
+ | ====Installation de python et des dépendances==== | ||
+ | |||
+ | On se place ou l'on veut et on installe | ||
+ | |||
+ | On commence par installer la bibliothèque PN532 | ||
+ | < | ||
+ | sudo apt-get update | ||
+ | sudo apt-get install build-essential python-dev git | ||
+ | git clone https:// | ||
+ | cd Adafruit_Python_PN532 | ||
+ | sudo python setup.py install | ||
+ | cd .. | ||
+ | rm -R Adafruit_Python_PN532 | ||
+ | </ | ||
+ | |||
+ | On installe ensuite d' | ||
+ | |||
+ | < | ||
+ | sudo apt-get install python-pip | ||
+ | pip install pipenv | ||
+ | pipenv install requests | ||
+ | </ | ||
+ | |||
+ | |||
+ | Enfin, on charge le code du gestionnaire de fichier dans / | ||
+ | <note important> | ||
+ | |||
+ | <file python / | ||
+ | # | ||
+ | import binascii | ||
+ | import sys | ||
+ | import Adafruit_PN532 as PN532 | ||
+ | import time | ||
+ | import requests | ||
+ | import hashlib | ||
+ | import RPi.GPIO as GPIO | ||
+ | import time | ||
+ | |||
+ | # Configuration des pins de sorties pour la Raspberry Pi (numero GPIO): | ||
+ | SS = 8 | ||
+ | MOSI = 25 | ||
+ | MISO = 24 | ||
+ | SCK = 23 | ||
+ | channel_buzzer = 18 | ||
+ | channel_relais = 14 | ||
+ | |||
+ | #Parametres pour accéder à l'API PUUCE (donnant la correspondance pseudo Centrale/ | ||
+ | apikey=" | ||
+ | url = " | ||
+ | uid_porte=" | ||
+ | |||
+ | |||
+ | # | ||
+ | GPIO.cleanup() | ||
+ | GPIO.setmode(GPIO.BCM) | ||
+ | GPIO.setup(channel_relais, | ||
+ | GPIO.output(channel_relais, | ||
+ | |||
+ | # | ||
+ | def buzz(frequency, | ||
+ | GPIO.setmode(GPIO.BCM) | ||
+ | GPIO.setup(channel, | ||
+ | p = GPIO.PWM(channel, | ||
+ | p.start(5) | ||
+ | #ici, rapport_cyclique vaut entre 0.0 et 100.0 | ||
+ | time.sleep(duration) | ||
+ | p.stop() | ||
+ | |||
+ | # | ||
+ | def openrelais(channel): | ||
+ | GPIO.output(channel, | ||
+ | time.sleep(5) | ||
+ | GPIO.output(channel, | ||
+ | |||
+ | # Initialisation du lecteur | ||
+ | pn532 = PN532.PN532(cs=SS, | ||
+ | pn532.begin() | ||
+ | |||
+ | # Récupération du firmware PN532 et affichage | ||
+ | ic, ver, rev, support = pn532.get_firmware_version() | ||
+ | print(' | ||
+ | |||
+ | # | ||
+ | pn532.SAM_configuration() | ||
+ | |||
+ | |||
+ | #Boucle principale de lecture | ||
+ | print(' | ||
+ | while True: | ||
+ | # Vérification si un carte est là | ||
+ | uid = pn532.read_passive_target() | ||
+ | # On recommence la boucle s'il n'y a pas de carte | ||
+ | if uid is None: | ||
+ | continue | ||
+ | #Sinon, on a une carte et donc UID et on continue | ||
+ | #On buzz donc la lecture | ||
+ | buzz(1000, | ||
+ | time.sleep(0.1); | ||
+ | buzz(1000, | ||
+ | time.sleep(0.1); | ||
+ | buzz(1000, | ||
+ | #On récupère l'UID sous forme hexa | ||
+ | uid_encrypted = format(binascii.hexlify(uid)); | ||
+ | | ||
+ | #On prépare la requête POST pour l'API | ||
+ | payload={' | ||
+ | r = requests.post(url, | ||
+ | #Si la requête POST est un succès | ||
+ | if(r.status_code == 200): | ||
+ | reponse = r.text[: | ||
+ | resultat = reponse.split(" | ||
+ | #Si la personne est autorisée on ouvre la porte | ||
+ | if(resultat[1] == " | ||
+ | print(" | ||
+ | buzz(1500, | ||
+ | openrelais(channel_relais); | ||
+ | #Sinon on ouvre pas la porte | ||
+ | else: | ||
+ | print(" | ||
+ | buzz(440,1, channel_buzzer); | ||
+ | print(reponse) | ||
+ | #Dans le cas ou la réponse n'est pas 200, on n' | ||
+ | else: | ||
+ | print(" | ||
+ | print(r.status_code); | ||
+ | print(" | ||
+ | buzz(440,1, channel_buzzer); | ||
+ | |||
+ | #A la fin : reinitialsation uid puis pause d lecture | ||
+ | uid_encrypted = "" | ||
+ | time.sleep(3) # pause 3 secondes | ||
+ | </ | ||
+ | ==== Utilisation de contrôle d' | ||
+ | |||
+ | Depuis les lecteurs, on va interroger **puuce.ginfo/ | ||
+ | |||
+ | ^ Attribut ^ Description ^ Exemple ^ | ||
+ | | **apikey** | La clé de l'api pour lire | - | | ||
+ | | **uid_personne** | L'UID encodé en sha1 par la Raspberru-iPI | - | | ||
+ | | **uid_porte** | L'UID de la porte concernée | uidporteginfo1 | | ||
+ | |||
+ | |||
+ | ===== L' | ||
+ | |||
+ | L' | ||
+ | |||
+ | L' | ||
+ | |||
+ | Elle permet de : | ||
+ | |||
+ | -> Rajouter un utilisateur et l' | ||
+ | |||
+ | -> Affecter un utilisateur à une porte pour qu'il y ai accès | ||
+ | |||
+ | -> Voir l' | ||
+ | |||
+ | <note important> | ||
+ | ===== API ===== | ||
+ | L'API web est documentée sur la page [[projets: |