current the pi is running a access control proximity reader through reading a CSV file. accepted codes trigger a pin which fires a relay and opens the automatic gate.
we currently goto the pi locally and update the csv file on site for any changes needed.
we want to update the csv file away from site and then have a simple way of loading it to the pi without hooking a screen up etc.
my idea is the following
1: put the updated file (lets say database.csv) on a memory stick.
2: goto site and plug the usb stick into the pi
3: press a button (a physical button connected to the pi) and it overwrites the existing csv file with the new
any help on doing this ?
i have posted current script below
many thanks in advance
Code: Select all
#!/usr/bin/env python
import pigpio, csv
FILE_TO_READ = 'database.csv'
CSV_ID_KEY = 'Number :'
CSV_NAME_KEY = 'Name :'
CSV_TEL_KEY = 'Tel No :'
class decoder:
"""
A class to read Wiegand codes of an arbitrary length.
The code length and value are returned.
EXAMPLE
#!/usr/bin/env python
import time
import pigpio
import wiegand
def callback(bits, code):
print("bits={} code={}".format(bits, code))
pi = pigpio.pi()
w = wiegand.decoder(pi, 14, 15, callback)
while True:
time.sleep(60)
w.cancel()
pi.stop()
"""
def __init__(self, pi, gpio_0, gpio_1, callback, bit_timeout=5):
"""
Instantiate with the pi, gpio for 0 (green wire), the gpio for 1
(white wire), the callback function, and the bit timeout in
milliseconds which indicates the end of a code.
The callback is passed the code length in bits and the value.
"""
self.pi = pi
self.gpio_0 = gpio_0
self.gpio_1 = gpio_1
self.callback = callback
self.bit_timeout = bit_timeout
self.in_code = False
self.pi.set_mode(gpio_0, pigpio.INPUT)
self.pi.set_mode(gpio_1, pigpio.INPUT)
self.pi.set_pull_up_down(gpio_0, pigpio.PUD_UP)
self.pi.set_pull_up_down(gpio_1, pigpio.PUD_UP)
self.cb_0 = self.pi.callback(gpio_0, pigpio.FALLING_EDGE, self._cb)
self.cb_1 = self.pi.callback(gpio_1, pigpio.FALLING_EDGE, self._cb)
def _cb(self, gpio, level, tick):
"""
Accumulate bits until both gpios 0 and 1 timeout.
"""
if level < pigpio.TIMEOUT:
if self.in_code == False:
self.bits = 1
self.num = 0
self.in_code = True
self.code_timeout = 0
self.pi.set_watchdog(self.gpio_0, self.bit_timeout)
self.pi.set_watchdog(self.gpio_1, self.bit_timeout)
else:
self.bits += 1
self.num = self.num << 1
if gpio == self.gpio_0:
self.code_timeout = self.code_timeout & 2 # clear gpio 0 timeout
else:
self.code_timeout = self.code_timeout & 1 # clear gpio 1 timeout
self.num = self.num | 1
else:
if self.in_code:
if gpio == self.gpio_0:
self.code_timeout = self.code_timeout | 1 # timeout gpio 0
else:
self.code_timeout = self.code_timeout | 2 # timeout gpio 1
if self.code_timeout == 3: # both gpios timed out
self.pi.set_watchdog(self.gpio_0, 0)
self.pi.set_watchdog(self.gpio_1, 0)
self.in_code = False
self.callback(self.bits, self.num)
def cancel(self):
"""
Cancel the Wiegand decoder.
"""
self.cb_0.cancel()
self.cb_1.cancel()
def readFile(filename):
data = []
with open(filename, 'r') as file:
reader = csv.DictReader(file)
data = [row for row in reader]
return data
def authenticateFromFile(id):
for row in readFile(FILE_TO_READ):
if CSV_ID_KEY in row and row[CSV_ID_KEY] == id:
return row
return False
if __name__ == "__main__":
import time
import RPi.GPIO as GPIO
import pigpio
import wiegand
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
def callback(bits, value):
user = authenticateFromFile('{}'.format(value))
if user:
print("User='{}' Tel='{}' Wiegand bits={} Card Number={}".format(user[CSV_NAME_KEY], user[CSV_TEL_KEY], bits, value))
file = open("www/events.txt", "w")
file.write("Last Access: Wiegand bits={}\n".format(bits))
file.write("\nCard value={}".format(value))
GPIO.setup(18,GPIO.OUT)
print("door released")
GPIO.output(18,GPIO.LOW)
time.sleep(5)
print("door secure")
GPIO.output(18, GPIO.HIGH)
else:
print("Access Denied = Wiegand bits={} Card Number={}".format(bits, value))
file = open("www/events.txt", "w")
file.write("Access Denied = Wiegand bits={} Card Number={}".format(bits, value))
pi = pigpio.pi()
w = wiegand.decoder(pi, 14, 15, callback)
while True:
time.sleep(60)
w.cancel()
pi.stop()