PEOPLE’S EDUCATION SOCIETY
SIDDHARTH COLLEGE OF ARTS, SCIENCE & COMMERCE
(BUDDHA BHAVAN)
(Affiliated to University of Mumbai)
PURSHOTTAMDAS THAKURDAS MARG, OUTRAM ROAD, FORT, MUMBAI, MAHARASHTRA 400001
__________________________________________________________________
DEPARTMENT OF INFORMATION TECHNOLOGY
CERTIFICATE
Class: T.Y.BSc.(IT) Year: 2022 - 2023
This is to certify that the practical entitled Internet of Things in this journal is
the work of Miss. Tejaswinee Dinkar Kamble of T.Y.BSc.(IT) Roll No. 11 has
satisfactorily completed the required number of practicals and worked for
Semester 5 of the academic year 2022 – 2023 in the college laboratory as laid
down by the university.
________ ________ _________
Coordinator External Examiner Internal Examiner
__________
Date: College Seal
1
INDEX
Sr.No. Practical Name Page No. Date Remark
01. Displaying Different LED patterns 3-5 09/08/2022
using Raspberry Pi
02. Displaying Time Over 4-Digit-7 6-8 16/08/2022
Segment display using Raspberry Pi
03. Raspberry Pi based Oscilloscope 9-10 27/08/2022
04. Fingerprint sensor interfacing with 11-17 13/09/2022
Raspberry Pi
05. Raspberry Pi GPS module Interface 18-24 20/09/2022
06. visitor Monitoring with Raspberry Pi 25-26 27/09/2022
& Pi Camera
07. Interfacing Raspberry Pi with RFID 27-31 11/10/2022
2
Practical 1: Displaying Different LED patterns using Raspberry Pi
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(12,GPIO.OUT)
GPIO.setup(13,GPIO.OUT)
GPIO.setup(16,GPIO.OUT)
GPIO.setup(20,GPIO.OUT)
GPIO.setup(21,GPIO.OUT)
GPIO.setup(23,GPIO.OUT)
GPIO.setup(24,GPIO.OUT)
GPIO.setup(25,GPIO.OUT)
switch0 = 7
switch1 = 8
switchPressCount = 0
GPIO.setup(switch0, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(switch1, GPIO.IN, pull_up_down=GPIO.PUD_UP)
pins = [12,13,16,20,21,23,24,25]
def blink():
for j in range(0,8):
GPIO.output(pins[j],False)
time.sleep(0.5)
for j in range(0,8):
3
GPIO.output(pins[j],True)
time.sleep(0.5)
def toggle():
for j in range(0,8):
if j%2 == 0:
GPIO.output(pins[j],False)
else:
GPIO.output(pins[j],True)
time.sleep(0.5)
for j in range(0,8):
if j%2 == 1:
GPIO.output(pins[j],False)
else:
GPIO.output(pins[j],True)
time.sleep(0.5)
def incremental():
for j in range(0,8):
GPIO.output(pins[j],False)
for j in range(0,8):
GPIO.output(pins[j],True)
time.sleep(0.5)
print('LED Pattern')
while True:
try:
switchPressed = GPIO.input(switch0)
if switchPressed == False:
switchPressCount += 1
switchPressCount %= 3
if switchPressCount == 0:
blink();
4
if switchPressCount == 1:
toggle();
if switchPressCount == 2:
incremental();
except KeyboardInterrupt as e:
print('Cleaning GPIO')
GPIO.cleanup()
print('Cleaning GPIO')
GPIO.cleanup()
5
Practical 2: Displaying Time Over 4-Digit-7 Segment display using Raspberry Pi
import RPi.GPIO as GPIO
import time, datetime
now = datetime.datetime.now()
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
#GPIO ports for the 7seg pins
segment8 = (26,19,13,6,5,11,9,10)
for segment in segment8:
GPIO.setup(segment, GPIO.OUT)
GPIO.output(segment, 0)
#Digit 1
GPIO.setup(7, GPIO.OUT)
GPIO.output(7, 0) #Off initially
#Digit 2
GPIO.setup(8, GPIO.OUT)
GPIO.output(8, 0) #Off initially
#Digit 3
GPIO.setup(25, GPIO.OUT)
GPIO.output(25, 0) #Off initially
#Digit 4
GPIO.setup(24, GPIO.OUT)
GPIO.output(24, 0) #Off initially
null = [0,0,0,0,0,0,0]
zero = [1,1,1,1,1,1,0]
one = [0,1,1,0,0,0,0]
two = [1,1,0,1,1,0,1]
three = [1,1,1,1,0,0,1]
four = [0,1,1,0,0,1,1]
five = [1,0,1,1,0,1,1]
6
six = [1,0,1,1,1,1,1]
seven = [1,1,1,0,0,0,0]
eight = [1,1,1,1,1,1,1]
nine = [1,1,1,1,0,1,1]
def print_segment(charector):
if charector == 1:
for i in range(7):
GPIO.output(segment8[i], one[i])
if charector == 2:
for i in range(7):
GPIO.output(segment8[i], two[i])
if charector == 3:
for i in range(7):
GPIO.output(segment8[i], three[i])
if charector == 4:
for i in range(7):
GPIO.output(segment8[i], four[i])
if charector == 5:
for i in range(7):
GPIO.output(segment8[i], five[i])
if charector == 6:
for i in range(7):
GPIO.output(segment8[i], six[i])
if charector == 7:
for i in range(7):
GPIO.output(segment8[i], seven[i])
if charector == 8:
for i in range(7):
GPIO.output(segment8[i], eight[i])
if charector == 9:
for i in range(7):
GPIO.output(segment8[i], nine[i])
if charector == 0:
7
for i in range(7):
GPIO.output(segment8[i], zero[i])
return;
while 1:
now = datetime.datetime.now()
hour = now.minute
minute = now.second
h1 = hour/10
h2 = hour % 10
m1 = minute /10
m2 = minute % 10
print (h1,h2,m1,m2)
delay_time = 0.001 #delay to create virtual effect
GPIO.output(7, 1) #Turn on Digit One
print_segment (h1) #Print h1 on segment
time.sleep(delay_time)
GPIO.output(7, 0) #Turn off Digit One
GPIO.output(8, 1) #Turn on Digit One
print_segment (h2) #Print h1 on segment
GPIO.output(10, 1) #Display point On
time.sleep(delay_time)
GPIO.output(10, 0) #Display point Off
GPIO.output(8, 0) #Turn off Digit One
GPIO.output(25, 1) #Turn on Digit One
print_segment (m1) #Print h1 on segment
time.sleep(delay_time)
GPIO.output(25, 0) #Turn off Digit One
GPIO.output(24, 1) #Turn on Digit One
print_segment (m2) #Print h1 on segment
time.sleep(delay_time)
GPIO.output(24, 0) #Turn off Digit One
#time.sleep(1)
8
Practical 3: Raspberry Pi based Oscilloscope
import time
import matplotlib.pyplot as plt
#import numpy
from drawnow import *
# Import the ADS1x15 module.
import Adafruit_ADS1x15
# Create an ADS1115 ADC (16-bit) instance.
adc = Adafruit_ADS1x15.ADS1115()
GAIN = 1
val = [ ]
cnt = 0
plt.ion()
# Start continuous ADC conversions on channel 0 using the previous gain value.
adc.start_adc(0, gain=GAIN)
print('Reading ADS1x15 channel 0')
#create the figure function
def makeFig():
plt.ylim(-5000,5000)
plt.title('Osciloscope')
plt.grid(True)
plt.ylabel('ADC outputs')
plt.plot(val, 'ro-', label='Channel 0')
plt.legend(loc='lower right')
while (True):
# Read the last ADC conversion value and print it out.
value = adc.get_last_result()
print('Channel 0: {0}'.format(value))
# Sleep for half a second.
9
time.sleep(0.5)
val.append(int(value))
drawnow(makeFig)
plt.pause(.000001)
cnt = cnt+1
if(cnt>50):
val.pop(0)
10
Practical 4: Fingerprint sensor interfacing with Raspberry Pi
import binascii
import time
class GT511C3:
def __init__(self, serial):
self.serial = serial
def writeCMD(self, paramBytes, cmdBytes):
paramBytes.reverse()
cmdBytes.reverse()
checksum = 256
data = []
i = 0;
data.append(0x55)
data.append(0xAA)
data.append(0x01)
data.append(0x00)
for param in paramBytes:
data.append(param & 0xFF)
checksum += (param & 0xFF)
for cmd in cmdBytes:
data.append(cmd & 0xFF)
checksum += (cmd & 0xFF)
data.append(checksum & 0xFF)
data.append(checksum>>8 & 0xFF)
#print(data)
self.serial.write(data)
def getACK(self):
11
data = bytearray(12)
self.serial.readinto(data)
resp = ""
for c in data:
resp += str(c) + " "
#sprint(resp)
return data
def isACK(self, response):
return response[8] == 0x30
def open(self):
self.writeCMD([0,0,0,0], [0, 1])
return self.isACK(self.getACK())
def cmosLED(self, turnOn):
param = [0,0,0,0]
if turnOn:
param[3] = 1
self.writeCMD(param, [0, 0x12])
return self.isACK(self.getACK())
def isPressFinger(self):
self.writeCMD([0,0,0,0], [0, 0x26])
resp = self.getACK()
if self.isACK(resp):
respParam = resp[4]+resp[5]+resp[6]+resp[7]
return respParam == 0
return False
def captureFinger(self, goodQuality=False):
print('Put Finger On Sensor')
while not self.isPressFinger():
12
time.sleep(0.01)
param = [0,0,0,0]
if goodQuality:
param[3] = 1
self.writeCMD(param, [0, 0x60])
return self.isACK(self.getACK())
def enrollStart(self, id):
if id == -1:
param = [0xFF, 0xFF, 0xFF, 0xFF]
else:
param = [0, 0, 0, id & 0xFF]
self.writeCMD(param, [0, 0x22])
resp = self.getACK()
if not self.isACK(resp):
return resp[6]<<8 + resp[7]
return 0xFFFF
def enrollFirst(self):
return self.enroll(0x23)
def enrollSecond(self):
return self.enroll(0x24)
def enrollThird(self):
return self.enroll(0x25)
def enroll(self, count):
param = [0,0,0,0]
self.writeCMD(param, [0, count&0xFF])
resp = self.getACK()
if not self.isACK(resp):
return resp[6]<<8 + resp[7]
13
return 0xFFFF
def identify(self):
self.writeCMD([0,0,0,0], [0, 0x51])
resp = self.getACK()
if self.isACK(resp):
respParam = resp[4]
return respParam
return -1
def deleteAll(self):
self.writeCMD([0,0,0,0], [0, 0x41])
return self.isACK(self.getACK())
FingerPrintTest
import FingerPrintGT511C3
import serial
import time
serialPort = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=1)
if not serialPort.isOpen():
serialPort.open()
print('Serial Port Opend!')
fps = FingerPrintGT511C3.GT511C3(serialPort)
def enroll():
print('Enter ID(0-199) for storing fingerprint')
id = input('Please Enter Unused ID')
print('Enrolling at ' + str(id))
fps.cmosLED(True)
fps.enrollStart(int(id))
fps.captureFinger(True)
fps.enrollFirst()
14
print('Remove Finger')
while fps.isPressFinger():
time.sleep(0.1)
fps.captureFinger(True)
fps.enrollSecond()
print('Remove Finger')
while fps.isPressFinger():
time.sleep(0.1)
fps.captureFinger(True)
fps.enrollThird()
print('Remove Finger')
while fps.isPressFinger():
time.sleep(0.1)
print('Enroll Success ' + str(id))
fps.cmosLED(False)
print(' ')
def openFPS():
print('Opening FPS')
if fps.open():
print('FPS Open Sucess')
else:
print('FPS Open Failed')
raise Exception('')
def blinkLED():
if fps.cmosLED(True):
print('FPS LED ON')
time.sleep(2)
fps.cmosLED(False)
else:
print('FAILED: FPS LED ON')
raise Exception('Error While Blinking LED')
15
def search():
print('Searching...')
fps.cmosLED(True)
fps.captureFinger(True)
foundAt = fps.identify()
if not foundAt == -1:
print('Match Foundd at ' + str(foundAt))
else:
print('Not Found')
fps.cmosLED(False)
print('')
def deleteAll():
print('Deleting All Previous Records')
fps.deleteAll()
time.sleep(00.0001)
openFPS()
#blinkLED()
while(True):
print('Select Operation To Perform :')
print('1. Delete All Existing Records')
print('2. Enroll New Fingerprint')
print('3. Search Fingerprint')
print('4. Exit')
option = input()
print(option)
if option == 1:
deleteAll()
16
if option == 2:
enroll()
if option == 3:
search()
if option == 4:
break
print('Exiting program...')
17
Practical 5: Raspberry Pi GPS module Interface
import time
import serial
import string
import pynmea2
import RPi.GPIO as GPIO
# Refer GPIO PIN Numbers
LCD_RS = 7
LCD_E = 8
LCD_D4 = 21
LCD_D5 = 23
LCD_D6 = 24
LCD_D7 = 25
LCD_WIDTH = 16
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0X80
LCD_LINE_2 = 0XC0
E_PULSE = 0.0005
E_DELAY = 0.0005
GPIO.setmode(GPIO.BCM)
GPIO.setup(LCD_E, GPIO.OUT)
GPIO.setup(LCD_RS, GPIO.OUT)
GPIO.setup(LCD_D4, GPIO.OUT)
GPIO.setup(LCD_D5, GPIO.OUT)
GPIO.setup(LCD_D6, GPIO.OUT)
GPIO.setup(LCD_D7, GPIO.OUT)
18
def lcd_init():
lcd_byte(0X33,LCD_CMD)
lcd_byte(0X32,LCD_CMD)
lcd_byte(0X28,LCD_CMD)
lcd_byte(0X0C,LCD_CMD)
lcd_byte(0X06,LCD_CMD)
lcd_byte(0X01,LCD_CMD)
def lcd_string(msg):
msg = msg.ljust(LCD_WIDTH, ' ')
for i in range(LCD_WIDTH):
lcd_byte(ord(msg[i]),LCD_CHR)
def lcd_byte(bits,mode):
GPIO.output(LCD_RS, mode)
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x10==0x10:
GPIO.output(LCD_D4, True)
if bits&0x20==0x20:
GPIO.output(LCD_D5, True)
if bits&0x40==0x40:
GPIO.output(LCD_D6, True)
if bits&0x80==0x80:
GPIO.output(LCD_D7, True)
time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
19
time.sleep(E_DELAY)
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x01==0x01:
GPIO.output(LCD_D4, True)
if bits&0x02==0x02:
GPIO.output(LCD_D5, True)
if bits&0x04==0x04:
GPIO.output(LCD_D6, True)
if bits&0x08==0x08:
GPIO.output(LCD_D7, True)
time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)
lcd_init()
lcd_byte(LCD_LINE_1, LCD_CMD)
#create a serial object
ser = serial.Serial("/dev/ttyUSB0", baudrate = 9600, timeout = 0.5)
while 1:
try:
data = ser.readline()
print("Reading ..." + data)
20
#wait for the serial port to churn out data
if data[0:6] == '$GPGGA': # the long and lat data are always contained in the GPGGA string of the NMEA
data
msg = pynmea2.parse(data)
#parse the latitude and print
latval = msg.lat
concatlat = "lat:" + str(latval)
print(concatlat)
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string(concatlat)
#parse the longitude and print
longval = msg.lon
concatlong = "long:"+ str(longval)
print(concatlong)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string(concatlong)
time.sleep(0.5)#wait a little before picking the next data.
finally:
GPIO.cleanup()
LCD
import RPi.GPIO as GPIO
import time
# Refer GPIO PIN Numbers
LCD_RS = 7
LCD_E = 8
LCD_D4 = 21
LCD_D5 = 23
LCD_D6 = 24
LCD_D7 = 25
21
LCD_WIDTH = 16
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0X80
LCD_LINE_2 = 0XC0
E_PULSE = 0.0005
E_DELAY = 0.0005
def main():
GPIO.setmode(GPIO.BCM)
GPIO.setup(LCD_E, GPIO.OUT)
GPIO.setup(LCD_RS, GPIO.OUT)
GPIO.setup(LCD_D4, GPIO.OUT)
GPIO.setup(LCD_D5, GPIO.OUT)
GPIO.setup(LCD_D6, GPIO.OUT)
GPIO.setup(LCD_D7, GPIO.OUT)
lcd_init()
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Future Chip")
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Technologies")
time.sleep(3)
def lcd_init():
lcd_byte(0X33,LCD_CMD)
lcd_byte(0X32,LCD_CMD)
lcd_byte(0X28,LCD_CMD)
lcd_byte(0X0C,LCD_CMD)
lcd_byte(0X06,LCD_CMD)
22
lcd_byte(0X01,LCD_CMD)
def lcd_string(msg):
msg = msg.ljust(LCD_WIDTH, ' ')
for i in range(LCD_WIDTH):
lcd_byte(ord(msg[i]),LCD_CHR)
def lcd_byte(bits,mode):
GPIO.output(LCD_RS, mode)
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x10==0x10:
GPIO.output(LCD_D4, True)
if bits&0x20==0x20:
GPIO.output(LCD_D5, True)
if bits&0x40==0x40:
GPIO.output(LCD_D6, True)
if bits&0x80==0x80:
GPIO.output(LCD_D7, True)
time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
23
if bits&0x01==0x01:
GPIO.output(LCD_D4, True)
if bits&0x02==0x02:
GPIO.output(LCD_D5, True)
if bits&0x04==0x04:
GPIO.output(LCD_D6, True)
if bits&0x08==0x08:
GPIO.output(LCD_D7, True)
time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)
if __name__=='__main__':
try:
print("Running LCD Code...")
main()
finally:
print("Cleanning GPIO")
GPIO.cleanup()
24
Practical 6: visitor Monitoring with Raspberry Pi & Pi Camera
import RPi.GPIO as GPIO
import time
import picamera
import datetime
buzzer = 6
switch0 = 7
readyLED = 8
MOTOR_P = 12
MOTOR_M = 13
GPIO.setmode(GPIO.BCM)
GPIO.setup(buzzer,GPIO.OUT)
GPIO.setup(readyLED,GPIO.OUT)
GPIO.setup(MOTOR_P,GPIO.OUT)
GPIO.setup(MOTOR_M,GPIO.OUT)
GPIO.setup(switch0, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.output(MOTOR_P, False)
GPIO.output(MOTOR_M, False)
GPIO.output(buzzer, False)
GPIO.output(readyLED, True)
camera = picamera.PiCamera()
print('Running Visitor Monitoring ..')
while True:
try:
25
switchPressed = GPIO.input(switch0)
if switchPressed == False:
GPIO.output(readyLED, False)
GPIO.output(buzzer, True)
while GPIO.input(switch0) == False:
time.sleep(0.001)
GPIO.output(buzzer, False)
camera.start_preview()
time.sleep(2)
camera.stop_preview()
timestamp = datetime.datetime.now().strftime("%m_%d_%Y_%H_%M_%S")
imagename = "images/visitor_" + timestamp + ".jpg"
print('Capturing Image ' + imagename)
camera.capture(imagename)
print('Opening Door...')
GPIO.output(MOTOR_P, True)
GPIO.output(MOTOR_M, False)
time.sleep(0.8)
GPIO.output(MOTOR_P, False)
GPIO.output(MOTOR_M, False)
time.sleep(1.5)
GPIO.output(MOTOR_P, False)
GPIO.output(MOTOR_M, True)
print('Closing Door...')
time.sleep(0.81)
GPIO.output(MOTOR_P, False)
GPIO.output(MOTOR_M, False)
GPIO.output(readyLED, True)
except Exception as e:
print('Cleaning GPIO')
GPIO.cleanup()
GPIO.cleanup()
26
Practical 7: Interfacing Raspberry Pi with RFID
#!/usr/bin/env python
# -*- coding: utf8 -*-
# Copyright 2014,2018 Mario Gomez <[email protected]>
# This file is part of MFRC522-Python
# MFRC522-Python is a simple Python implementation for
# the MFRC522 NFC Card Reader for the Raspberry Pi.
# MFRC522-Python is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# MFRC522-Python is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with MFRC522-Python. If not, see <http://www.gnu.org/licenses/>.
'''
| Name | Pin # | Pin name |
|:------:|:-------:|:------------:|
| SDA | 24 | GPIO8 |
27
| SCK | 23 | GPIO11 |
| MOSI | 19 | GPIO10 |
| MISO | 21 | GPIO9 |
| IRQ | None | None |
| GND | Any | Any Ground |
| RST | 22 | GPIO25 |
| 3.3V | 1 | 3V3 |
'''
import RPi.GPIO as GPIO
import MFRC522
import signal
import time
continue_reading = True
buzzer = 33 #13
errorLED = 35 #19
readyLED = 37 #26
GPIO.setmode(GPIO.BOARD)
GPIO.setup(buzzer,GPIO.OUT)
GPIO.setup(readyLED,GPIO.OUT)
GPIO.setup(errorLED,GPIO.OUT)
GPIO.output(buzzer, False)
GPIO.output(errorLED, False)
GPIO.output(readyLED, False)
# Capture SIGINT for cleanup when the script is aborted
def end_read(signal,frame):
28
global continue_reading
print ("Ctrl+C captured, ending read.")
continue_reading = False
GPIO.cleanup()
# Hook the SIGINT
signal.signal(signal.SIGINT, end_read)
# Create an object of the class MFRC522
MIFAREReader = MFRC522.MFRC522()
# Welcome message
print("Welcome to the MFRC522 data read example")
print("Press Ctrl-C to stop.")
orignalID = ""
def getHexChar(d):
if d > 9:
if d == 10:
return "A"
if d == 11:
return "B"
if d == 12:
return "C"
if d == 13:
return "D"
if d == 14:
return "E"
if d == 15:
return "F"
else:
return str(d)
29
def getHex(no):
LSB = no & 0x0F
MSB = (no>>4) & 0x0F
return getHexChar(MSB) + getHexChar(LSB)
# This loop keeps checking for chips. If one is near it will get the UID and authenticate
while continue_reading:
# Scan for cards
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
# If a card is found
if status == MIFAREReader.MI_OK:
print("Card detected")
# Get the UID of the card
(status,uid) = MIFAREReader.MFRC522_Anticoll()
# If we have the UID, continue
if status == MIFAREReader.MI_OK:
GPIO.output(buzzer, True)
# Print UID
rfid = getHex(uid[0]) + " " + getHex(uid[1]) + " " + getHex(uid[2]) + " " + getHex(uid[3])
print("Card read UID: " + rfid)
if len(orignalID) < 2:
orignalID = rfid
if rfid == orignalID:
print('Approved')
GPIO.output(readyLED, True)
else:
30
print('Rejected')
GPIO.output(errorLED, True)
time.sleep(1)
GPIO.output(readyLED, False)
GPIO.output(errorLED, False)
GPIO.output(buzzer, False)
'''
# This is the default key for authentication
key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]
# Select the scanned tag
MIFAREReader.MFRC522_SelectTag(uid)
# Authenticate
status = MIFAREReader.MFRC522_Auth(MIFAREReader.PICC_AUTHENT1A, 8, key, uid)
# Check if authenticated
if status == MIFAREReader.MI_OK:
MIFAREReader.MFRC522_Read(8)
MIFAREReader.MFRC522_StopCrypto1()
else:
print("Authentication error")
31
