class FingerPrintScan:
    def __init__(self):
        self.f = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000)
        if (self.f.verifyPassword() == False):
            raise ValueError('The given fingerprint sensor password is wrong!')
        print('Currently used templates: ' + str(self.f.getTemplateCount()) +
              '/' + str(self.f.getStorageCapacity()))
        self.current_buffer = 0x01

    def scan_fingerprint(self):
        while (self.f.readImage() == False):
            pass

    def is_fingerprint_exist(self):
        result = self.f.searchTemplate()
        positionNumber = result[0]
        print(positionNumber)
        return positionNumber >= 0

    def get_template_id(self):
        result = self.f.searchTemplate()
        positionNumber = result[0]
        print(positionNumber)
        return positionNumber

    def save_fingerprint(self):
        self.f.createTemplate()
        return self.f.storeTemplate()

    def clear_all_fingerprint(self):
        for i in range(self.f.getTemplateCount()):
            if self.f.deleteTemplate(i):
                print('Template deleted - ' + str(i))

    def clear_fingerprint(self, start, end):
        for i in range(start, end):
            if self.f.deleteTemplate(i):
                print('Template deleted - ' + str(i))

    def save_to_char_buffer(self):
        self.f.convertImage(self.current_buffer)
        self.current_buffer = self.current_buffer + 1

    def save_as_image(self, file_name):
        imageDestination = os.getcwd() + '/' + file_name + '.png'
        self.f.downloadImage(imageDestination)
Example #2
0
class Fingerprint:
    def __init__(self):
        # Set fingerprint sensor to ttyUSB0 with buadrate 57600
        self.fingerprintSensor = PyFingerprint('/dev/ttyUSB0', 57600,
                                               0xFFFFFFFF, 0x00000000)
        # Flag for checking sensor available
        self.fingerprintSensorValid = False
        self.fingerprintTemplateValid = False
        self.fingerprintCharValid = False
        self.verify()

    def verify(self):
        # Verify fingerprintsensor
        try:
            if (self.fingerprintSensor.verifyPassword() is False):
                print('Fingerprint password is wrong!')

            self.fingerprintSensorValid = True
            print('Fingerprint sensor is available!')
        except Exception as e:
            print('Something wrong : ' + str(e))

        print('-' * LINEWIDTH)

    def createTemplate(self):
        if (self.fingerprintSensorValid):
            try:
                time.sleep(2)
                print('Waiting for finger...')
                # wait for finger
                while (self.fingerprintSensor.readImage() is False):
                    pass
                print('Finger read.')
                print('Start convert fingerprint image...')
                self.fingerprintSensor.convertImage(0x01)
                print('Converted.')
                time.sleep(2)
                # double check
                # waiting for finger remove
                while (self.fingerprintSensor.readImage()):
                    pass
                print('Waiting for finger...')
                # wait for finger
                while (self.fingerprintSensor.readImage() is False):
                    pass
                print('Finger read.')
                print('Start convert fingerprint image...')
                self.fingerprintSensor.convertImage(0x02)
                print('Converted.')
                print('Create fingerprint template...')
                self.fingerprintSensor.createTemplate()
                print('Created.')
                print('Download fingerprint template...')
                self.fingerprintTemplate = self.fingerprintSensor.downloadCharacteristics(
                )
                self.fingerprintTemplateValid = True
            except Exception as e:
                print('Something wrong : ' + str(e))
        print('-' * LINEWIDTH)

    def scanOneTime(self):
        if (self.fingerprintSensorValid):
            try:
                self.fingerprintCharValid = False
                print('Waiting for finger...')
                # wait for finger
                startTime = time.time()
                timeout = False
                while (self.fingerprintSensor.readImage() is False
                       and timeout is False):
                    if time.time() - startTime > 20:
                        timeout = True
                print('Finger read.')
                # print('Start convert fingerprint image...')
                self.fingerprintSensor.convertImage(0x01)
                # print('Converted.')
                # print('Download fingerprint characteristic...')
                self.fingerprintChar = self.fingerprintSensor.downloadCharacteristics(
                )
                self.fingerprintCharValid = True
                self.fingerptintCompare = False
                self.fingerptintCompareValid = False
                self.userID = 0
            except Exception as e:
                print('Something wrong : ' + str(e))
        print('-' * LINEWIDTH)

    def fetchAllFingerprint(self):
        # fetch all fingerprint from web database
        fetchEndPoint = "htt]://203.154.59.215:8080/api/data/fingerprint"
        res = urllib2.urlopen(fetchEndPoint)
        content = res.content
        pass

    def compare(self):
        if self.fingerprintCharValid:
            # upload template to address 0x02
            self.fingerprintSensor.uploadCharacteristics(
                0x02, self.fingerprintTemplate)
            score = self.fingerprintSensor.compareCharacteristics()
            if score > 0:
                self.fingerptintCompare = True
                self.userID = 1111111111111
            self.fingerptintCompareValid = True

    def downloadImage(self):
        if (self.fingerprintSensorValid):
            try:
                print('Waiting for finger...')
                # wait for finger
                while (self.fingerprintSensor.readImage() is False):
                    pass

                # save fingerprint image
                print('Saving fingerprint image...')
                self.fingerprintSensor.downloadImage(
                    '/home/pi/healthios/img/fingerprint_img.png')
                print('Fingerprint saved!')
            except Exception as e:
                print('Something wrong : ' + str(e))
        print('-' * LINEWIDTH)
Example #3
0
def finger():
    try:
        f = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000)

        if (f.verifyPassword() == False):
            raise ValueError(
                'La ContraseƱa del sensor de huellas dactilares dada es incorrecta!'
            )

    except Exception as e:
        print('No se puedo inicializar el sensor de huellas dactilares!')
        print('Mensaje de exepcion: ' + str(e))
        exit(1)

    ## Tries to enroll new finger
    while True:
        try:
            print('Waiting for finger...')

            ## Wait that finger is read
            while (f.readImage() == False):
                pass

            ## Converts read image to characteristics and stores it in charbuffer 1
            f.convertImage(0x01)

            ## Checks if finger is already enrolled
            result = f.searchTemplate()
            positionNumber = result[0]

            if (positionNumber >= 0):
                print('Template already exists at position #' +
                      str(positionNumber))
                exit(0)

            time.sleep(2)

            print('Waiting for same finger again...')

            ## Wait that finger is read again
            while (f.readImage() == False):
                pass

            ## Converts read image to characteristics and stores it in charbuffer 2
            f.convertImage(0x02)

            ## Compares the charbuffers
            if (f.compareCharacteristics() == 0):
                raise Exception('Fingers do not match')

                print('Fingers do not match', str(positionNumber))

            ## Creates a template
            f.createTemplate()

            ## Saves template at new position number

            positionNumber = f.storeTemplate()

            f.loadTemplate(positionNumber, 0x01)
            char_store = str(f.downloadCharacteristics(0x01))
            char_store1 = char_store.translate("")

            var = ''
            for x in char_store1:
                var += x

            return positionNumber, var

            break

        except Exception as e:
            print('Error')
            print('Scanea de Nuevo!')

            time.sleep(2)
Example #4
0
try:

    print('Aproxime o dedo...')

    # Aguardando reconhecer dedo no leitor

    while (f.readImage() == False):

        pass

    # Converter a imagem lida para caracteristicas e salva no 1 buffer

    f.convertImage(0x01)

    f.createTemplate()

    # Salva as caracteristicas

    positionNumber = f.downloadCharacteristics()

    print(positionNumber)

except Exception as e:

    print('Operation failed!')

    print('Exception message: ' + str(e))

    exit(1)
Example #5
0
def enroll():
    mylcd.lcd_clear()
    mylcd.lcd_display_string('Enter Password:'******'4209':
        mylcd.lcd_clear()
        mylcd.lcd_display_string('Enter ID Number', 1)
        r = raw_input("Enter ID Number: ")
        mylcd.lcd_display_string(r, 2, 2)
        sleep(2)
        ## GETTING INFORMATION FROM DATABASE
        conn = sqlite3.connect('/home/pi/attendance/app.db')
        curs = conn.cursor()
        db_val = curs.execute(
            'SELECT rollnum from finger_store where rollnum in (values(?))',
            [r])
        coun = (len(list(db_val)))
        if coun >= 1:
            mylcd.lcd_clear()
            mylcd.lcd_display_string('ID Number Already', 1)
            mylcd.lcd_display_string('Taken', 2, 2)
            sleep(2)
            conn.commit()
            conn.close()
        else:
            conn.commit()
            conn.close()
            ## Enrolls new finger
            ##

            ## Tries to initialize the sensor
            try:
                f = PyFingerprint('/dev/serial0', 9600, 0xFFFFFFFF, 0x00000000)

                if (f.verifyPassword() == False):
                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Contact Admin', 1)
                    sleep(2)
                    raise ValueError(
                        'The given fingerprint sensor password is wrong!')

            except Exception as e:
                mylcd.lcd_clear()
                mylcd.lcd_display_string('Contact Admin', 1)
                sleep(2)
                print('The fingerprint sensor could not be initialized!')
                print('Exception message: ' + str(e))
                startChoice()

            ## Gets some sensor information
            mylcd.lcd_clear()
            mylcd.lcd_display_string('Currently used', 1)
            mylcd.lcd_display_string('templates: ', 2)
            mylcd.lcd_display_string(str(f.getTemplateCount()), 2, 13)
            sleep(2)
            print('Currently used templates: ' + str(f.getTemplateCount()))

            ## Tries to enroll new finger
            try:
                mylcd.lcd_clear()
                mylcd.lcd_display_string('Waiting for Finger', 2, 2)

                ## Wait that finger is read
                while (f.readImage() == False):
                    pass

                ## Converts read image to characteristics and stores it in charbuffer 1
                f.convertImage(0x01)

                ## Checks if finger is already enrolled
                result = f.searchTemplate()
                positionNumber = result[0]

                if (positionNumber >= 0):
                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Template already', 1)
                    mylcd.lcd_display_string('exists at  ', 2)
                    mylcd.lcd_display_string('position # ', 3)
                    mylcd.lcd_display_string(str(positionNumber), 3, 13)
                    sleep(3)
                    print('Template already exists at position #' +
                          str(positionNumber))
                    startChoice()
                else:
                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Remove finger...', 2, 2)
                    print('Remove finger...')
                    time.sleep(2)

                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Waiting for same', 2)
                    mylcd.lcd_display_string(' finger again', 3)
                    print('Waiting for same finger again...')

                    ## Wait that finger is read again
                    while (f.readImage() == False):
                        pass

                    ## Converts read image to characteristics and stores it in charbuffer 2
                    f.convertImage(0x02)

                    ## Compares the charbuffers
                    if (f.compareCharacteristics() == 0):
                        mylcd.lcd_clear()
                        mylcd.lcd_display_string('Fingers not matched', 2)
                        sleep(2)
                        raise Exception('Fingers do not match')
                    ## Creates a template
                    f.createTemplate()

                    ## Saves template at new position number
                    positionNumber = f.storeTemplate()
                    ## Loads the found template to charbuffer 1
                    f.loadTemplate(positionNumber, 0x01)

                    ## Downloads the characteristics of template loaded in charbuffer 1
                    characterics = str(
                        f.downloadCharacteristics(0x01)).encode('utf-8')

                    ## Hashes characteristics of template
                    cre_hash = hashlib.sha256(characterics).hexdigest()
                    conn = sqlite3.connect('/home/pi/attendance/app.db')
                    curs = conn.cursor()
                    curs.execute(
                        'INSERT INTO finger_store(rollnum, hashval, id) values(?, ?, ?)',
                        (r, cre_hash, positionNumber))
                    conn.commit()
                    conn.close()
                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Finger enrolled', 2)
                    mylcd.lcd_display_string('Successfully!', 3, 2)
                    sleep(2)
                    print('New template position #' + str(positionNumber))
                    startChoice()

            except Exception as e:
                print('Operation failed!')
                print('Exception message: ' + str(e))
                startChoice()

    else:
        mylcd.lcd_clear()
        mylcd.lcd_display_string('Your Not Authorized!', 2)
        sleep(2)
class FingerprintController(object):
    def __init__(self):
        self.sensor = None
        self.lcd = None
        self.cur_state = None

    def connect(self, dev):
        logging.info("Attempting to open serial device %s", dev)
        self.sensor = PyFingerprint(dev, 57600, 0xFFFFFFFF, 0x00000000)
        if not self.sensor.verifyPassword():
            raise ValueError('The given fingerprint sensor password is wrong!')
        logging.info("Serial device opened")
        logging.info(
            "Currently used templates: %s/%s" %
            (self.sensor.getTemplateCount(), self.sensor.getStorageCapacity()))

        self.lcd = LCD()

        self.send_update_packet({"status": "idle"})

    def send_update_packet(self, data):
        logging.info("=> %s" % data)
        resp = requests.post(url=API_UPDATE_SELF_STATE,
                             data={
                                 "token": ID_TOKEN,
                                 "state": json.dumps(data),
                             })
        logging.info("  <= %s", resp.json())

    def request_mode(self):
        try:
            logging.info("Requesting state...")
            data = requests.post(url=API_SELF_STATE,
                                 data={
                                     "token": ID_TOKEN,
                                 },
                                 timeout=10)
            logging.info("Received response: %s", data)
            data = data.json()
            return data['state']
        except KeyboardInterrupt:
            sys.exit(0)
        except:
            logging.exception("Failed requesting state, idling...")
            return 'idle'

    def loop_forever(self):
        funcs = {
            'enroll': self.state_enroll,
            'auth': self.state_auth,
            'idle': self.state_idle,
        }

        while True:
            mode = self.request_mode()
            action = funcs.get(mode, None)

            if not action:
                logging.warning("Ignoring invalid mode from server: %s", mode)
                self.state_idle()
                continue

            logging.info("Performing action '%s'", mode)

            try:
                action()
                if mode != 'idle':
                    time.sleep(5)
            except Exception as ex:
                self.send_update_packet({
                    "status": "general_error",
                    "message": ex.message
                })

    def state_idle(self):
        self.lcd.setText("Waiting...")
        self.lcd.setRGB(255, 150, 0)

        time.sleep(1)

    def state_enroll(self):
        self.send_update_packet({"status": "enroll_wait"})

        self.lcd.setRGB(0, 255, 0)
        self.lcd.setText("Place finger on the sensor.")

        while not self.sensor.readImage():
            pass

        self.sensor.convertImage(0x01)

        result = self.sensor.searchTemplate()
        position_num = result[0]

        if position_num >= 0:
            self.send_update_packet({
                "status": "enroll_fail",
                "reason": "Fingerprint already enrolled."
            })
            return

        self.lcd.setText("Lift finger off the sensor.")

        self.send_update_packet({"status": "enroll_lift"})
        time.sleep(2)

        self.lcd.setText("Place your\nfinger again.")

        self.send_update_packet({"status": "enroll_wait2"})

        while not self.sensor.readImage():
            pass

        self.sensor.convertImage(0x02)

        if not self.sensor.compareCharacteristics():
            self.lcd.setRGB(255, 0, 0)
            self.lcd.setText("Fingerprints do not match.")
            self.send_update_packet({
                "status": "enroll_fail",
                "reason": "Fingerprints do not match."
            })
            return

        self.sensor.createTemplate()
        characteristics = self.sensor.downloadCharacteristics(0x01)
        hash = hashlib.sha256(str(characteristics).encode('utf-8')).hexdigest()

        position_num = self.sensor.storeTemplate()

        self.lcd.setText("Fingerprint added!")
        self.send_update_packet({"status": "enroll_success", "hash": hash})

    def state_auth(self):
        self.send_update_packet({"status": "auth_wait"})

        self.lcd.setRGB(0, 255, 0)
        self.lcd.setText("Place finger on the sensor.")

        while not self.sensor.readImage():
            pass

        self.sensor.convertImage(0x01)

        result = self.sensor.searchTemplate()

        position_num = result[0]
        accuracy = result[1]

        if position_num == -1:
            self.lcd.setRGB(255, 0, 0)
            self.lcd.setText("Unknown\nfingerprint!")
            self.send_update_packet({
                "status": "auth_fail",
                "reason": "Unknown fingerprint!"
            })
            return

        self.lcd.setText("Successfully\nauthenticated!")
        logging.info("Found template at position #%d, score %d", position_num,
                     accuracy)
        self.send_update_packet({"status": "auth_success"})
class FingerprintController:

    f = None
    RESULT_ERROR = -1
    RESULT_TEMPLATE_ALREADY_EXISTS = -2
    RESULT_FINGER_DO_NOT_MATCH = -3
    RESULT_NO_MATCH = -4

    def __init__(self):
        try:
            self.f = PyFingerprint('/dev/ttyS0', 57600, 0xFFFFFFFF, 0x00000000)
            if self.f.verifyPassword() == False:
                raise ValueError(
                    'The given fingerprint sensor password is wrong!')
        except Exception as e:
            logger.exception(
                'The fingerprint sensor could not be initialized!')

    def __del__(self):
        del self.f

    def exists_user(self, username):
        return models.exists_user(username, models.session_factory())

    def add_user_step1(self):
        try:
            print('Waiting for finger...')

            ## Wait that finger is read
            while self.f.readImage() == False:
                pass

            ## Converts read image to characteristics and stores it in charbuffer 1
            self.f.convertImage(0x01)

            ## Checks if finger is already enrolled
            result = self.f.searchTemplate()
            positionNumber = result[0]

            if positionNumber >= 0:
                logger.warn('Template already exists at position #{}',
                            str(positionNumber))
                return self.RESULT_TEMPLATE_ALREADY_EXISTS

            return 0

        except Exception as e:
            logger.exception('Error while adding a user (step1).')
            return self.RESULT_ERROR

    def add_user_step2(self, username):
        try:
            print('Waiting for finger...')

            ## Wait that finger is read again
            while self.f.readImage() == False:
                pass

            ## Converts read image to characteristics and stores it in charbuffer 2
            self.f.convertImage(0x02)

            ## Compares the charbuffers
            if self.f.compareCharacteristics() == 0:
                return self.RESULT_FINGER_DO_NOT_MATCH

            ## Creates a template
            self.f.createTemplate()

            ## Saves template at new position number
            template_index = self.f.storeTemplate()
            logger.info(
                'Finger enrolled successfully. New template position #{}',
                str(template_index))

            ## save user in DB
            models.add_user(username, template_index, models.session_factory())
            return 0

        except Exception as e:
            logger.exception('Error while adding a user (step2).')
            return self.RESULT_ERROR

    def delete_user(self, username):
        user = models.get_user_by_name(username, models.session_factory())
        if None == user:
            logger.info('User \"{}\" does not exists and can not be deleted.',
                        username)
            return
        position = user.template
        models.delete_user(username, models.session_factory())
        self.f.deleteTemplate(position)
        logger.info('User \"{}\" with template position #{} deleted.',
                    username, str(position))

    def search_user(self):
        try:
            logger.info('Waiting for finger...')

            ## Wait that finger is read
            while self.f.readImage() == False:
                pass

            ## Converts read image to characteristics and stores it in charbuffer 1
            self.f.convertImage(0x01)

            ## Searchs template
            result = self.f.searchTemplate()

            positionNumber = result[0]
            accuracyScore = result[1]

            if positionNumber == -1:
                logger.warn('No fingerprint match found')
                return self.RESULT_NO_MATCH
            else:
                logger.info(
                    'Found template at position #{} with accuracy score of {}',
                    str(positionNumber), str(accuracyScore))
                return positionNumber

        except Exception as e:
            logger.exception(
                'Error while searching for a fingerprint template.')
            return self.RESULT_ERROR

    def delete_database(self):
        self.f.deleteDatabase()
    while ( FP.readImage() == False ):
        pass

    ## Converts read image to characteristics and stores it in charbuffer 2
    FP.convertImage(0x02)

    ## Compare the finger characteristics of CharBuffer1 with CharBuffer2 and return the accuracy score
    result = FP.compareCharacteristics() 
    
    if (result==0):
        raise ValueError('ERROR! Not match')
    else:
        print 'OK accuracy score %d' % result
	
    ## creates a template
    FP.createTemplate()

    ## Saves template at new position number
    if ( FP.storeTemplate(args.id) == True ):
        print 'Finger enrolled successfully at ID=%d' % args.id

        try:
            print 'Saving ID to config file: %s' % JSON_FILE
	    with open(JSON_FILE) as data_file:
		datas = json.load(data_file)    
		
	    new_entry = dict()
	    match = False
	    for item in datas["moneybox"]:
		if item["id"] == args.id:
		    match = True
def checkFP():
    # Enrolls new finger
    ##
    # return 8
    # Tries to initialize the sensor
    try:
        f = PyFingerprint('/dev/ttyS0', 57600, 0xFFFFFFFF, 0x00000000)

        if (f.verifyPassword() == False):
            raise ValueError('The given fingerprint sensor password is wrong!')

    except Exception as e:
        print('The fingerprint sensor could not be initialized!')
        print('Exception message: ' + str(e))
        exit(1)

    # ## Gets some sensor information
    # print('Currently used templates: ' + str(f.getTemplateCount()) +'/'+ str(f.getStorageCapacity()))

    ## Tries to enroll new finger
    try:
        print('Waiting for finger...')

        ## Wait that finger is read
        while (f.readImage() == False):
            pass

        ## Converts read image to characteristics and stores it in charbuffer 1
        f.convertImage(0x01)

        ## Checks if finger is already enrolled
        result = f.searchTemplate()
        positionNumber = result[0]

        if (positionNumber >= 0):
            print('Template already exists at position #' +
                  str(positionNumber))
            exit(0)

        print('Remove finger...')
        time.sleep(2)

        #     print('Waiting for same finger again...')

        #     ## Wait that finger is read again
        #     while ( f.readImage() == False ):
        #         pass

        #     ## Converts read image to characteristics and stores it in charbuffer 2
        #     f.convertImage(0x02)

        #     ## Compares the charbuffers
        #     if ( f.compareCharacteristics() == 0 ):
        #         raise Exception('Fingers do not match')

        ## Creates a template
        f.createTemplate()

        ## Saves template at new position number
        positionNumber = f.storeTemplate()
        print('Finger enrolled successfully!')
        print('New template position #' + str(positionNumber))
        return positionNumber

    except Exception as e:
        print('Operation failed!')
        print('Exception message: ' + str(e))
        exit(1)
def enroll():
    global employee
    global r
    global fun
    print(employee)
    r = employee
    print('employee ID:', r)
    print('')
    conn = sqlite3.connect('/home/pi/Desktop/beta/employee.db')
    c = conn.cursor()
    db_val = c.execute(
        'SELECT employ_num FROM finger_store WHERE employ_num IN (VALUES(?))',
        [r])
    coun = (len(list(db_val)))
    if coun >= 1:
        mylcd.lcd_clear()
        mylcd.lcd_display_string(' ID Already Exists', 2)
        print('ID Already Exists')
        print('')
        time.sleep(2)
        conn.commit()
        conn.close()
        main_menu()
    else:
        conn.commit()
        conn.close()

        try:
            f = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000)

            if (f.verifyPassword() == False):
                print('Contact Admin')
                print('')
                time.sleep(2)
                raise ValueError('The given fingerprint sensor password wrong')

        except Exception as e:
            mylcd.lcd_clear()
            mylcd.lcd_display_string('   Contact  Admin', 2)
            print('Contact Admin')
            print('')
            time.sleep(2)
            print('The fingerprint sensor could not be initialized')
            print('Exception message: ' + str(e))
            print('')
            main_menu()

        print('Currently used templates: ' + str(f.getTemplateCount()))
        print('')

        try:
            mylcd.lcd_clear()
            mylcd.lcd_display_string('*Waiting For Finger*', 2)
            print('*Waiting For Finger*')
            print('')

            # Wait for finger to be read

            while (f.readImage() == False):
                pass

            f.convertImage(0x01)

            result = f.searchTemplate()
            positionNumber = result[0]

            if (positionNumber >= 0):
                mylcd.lcd_clear()
                mylcd.lcd_display_string('Fingerprint  Already', 2)
                mylcd.lcd_display_string('       Exists', 3)
                print('Fingerprint Already Exists' + str(positionNumber))
                print('')
                time.sleep(2)
                main_menu()
            else:
                mylcd.lcd_clear()
                mylcd.lcd_display_string('  *Remove  Finger*', 2)
                print('*Remove Finger*')
                print('')
                time.sleep(2)
                mylcd.lcd_clear()
                mylcd.lcd_display_string('*Place Finger Again*', 2)
                print('*Place Finger Again*')
                print('')

                # waiting for second read
                while (f.readImage() == False):
                    pass

                f.convertImage(0X02)

                if (f.compareCharacteristics() == 0):
                    mylcd.lcd_clear()
                    mylcd.lcd_display_string('Fingers Do Not Match', 2)
                    print('Fingers Do Not Match')
                    print('')
                    time.sleep(2)

                f.createTemplate()

                positionNumber = f.storeTemplate()

                f.loadTemplate(positionNumber, 0X01)

                characteristics = str(
                    f.downloadCharacteristics(0x01)).encode('utf-8')

                cre_hash = hashlib.sha256(characteristics).hexdigest()
                conn = sqlite3.connect('/home/pi/Desktop/beta/employee.db')
                c = conn.cursor()
                c.execute(
                    'INSERT INTO finger_store (employ_num, hashval, id) '
                    'VALUES (?,?,?)', (r, cre_hash, positionNumber))
                conn.commit()
                conn.close()
                mylcd.lcd_clear()
                mylcd.lcd_display_string('    Fingerprint', 2)
                mylcd.lcd_display_string('    Registered', 3)
                print('Fingerprint Registered In Position' +
                      str(positionNumber))
                print('')
                time.sleep(2)
                admin_menu()

        except Exception as e:
            print('Operation failed- Exception message: ' + str(e))
            print('')
            main_menu()