Embedded Files
Raspberry Pi Driver’s License Age Verification Scanner
Raspberry Pi Driver’s License Age Verification Scanner
Building a Standalone ID Scanner
Building a Standalone ID Scanner
This project started with a simple goal: build a dedicated driver’s license scanner that can sit at a counter, scan the barcode on the back of a license, determine the customer’s age, and immediately give the operator a clear result.
I wanted the system to operate independently without requiring a conventional computer at the counter.
The basic concept became:
Driver’s License → PDF417 Scanner → Raspberry Pi → Decode ID → Calculate Age → Display Result → Log Scan
The finished system is intended to:
Read the PDF417 barcode on the back of a U.S. driver’s license
Decode standard AAMVA data contained in the barcode
Determine the person’s date of birth
Calculate their current age
Clearly display whether they are 21 or older
Check the expiration date when that information is available
Record scan information in a spreadsheet
Eventually provide different audible signals for different scan results
Start automatically when the Raspberry Pi is powered on
The goal is a small, dedicated appliance rather than a general-purpose computer.
SECTION 2: WHAT I LEARNED FIRST
SECTION 2: WHAT I LEARNED FIRST
Not Every Barcode Scanner Can Read a Driver’s License
Not Every Barcode Scanner Can Read a Driver’s License
My first attempt used an older Honeywell MS9590 VoyagerGS USB barcode scanner.
The scanner worked perfectly as a USB device, but scanning a driver’s license produced only a short string of numbers.
That led to an important discovery.
There are multiple barcodes on the back of a driver’s license.
The small conventional barcode can be read by many older 1D laser scanners. The large rectangular barcode made from many stacked rows is a PDF417 2D barcode.
PDF417 is the barcode this project needs.
The PDF417 barcode contains the encoded driver's license information itself. Reading the basic information does not require contacting a state driver's-license database.
A PDF417-capable scanner decodes the information printed on the card and sends that data to the Raspberry Pi.
Important: Reading the barcode is not the same as authenticating a driver's license against a government database. This project reads and evaluates information encoded on the physical card.
SECTION 3: HARDWARE
SECTION 3: HARDWARE
Current Hardware
Current Hardware
Raspberry Pi
microSD card, 32 GB or larger
5V / 3A USB-C Raspberry Pi power supply
Display
Raspberry Pi 4 compatible touchscreen enclosure
Barcode Scanner
PDF417 support
USB connection
Operated in USB/HID keyboard mode
Future Audio
Small speaker mounted to the display enclosure
Audio hardware will be added later
Software will be written with audio support already included
The scanner is connected directly to the Raspberry Pi by USB. Using a wired connection eliminates Bluetooth pairing, battery management, and unnecessary wireless dependencies.
BUILD COST
BUILD COST
I already had the microSD card and Raspberry Pi power supply, so those added no additional cost to this build.
Component
Cost
Raspberry Pi 4 Model B
$82.00
7" Touchscreen Display
$35.00
PDF417 Barcode Scanners, 2
$45.00
32GB+ microSD Card
Already Owned
Raspberry Pi 5V / 3A Power Supply
Already Owned
TOTAL OUT-OF-POCKET COST
$162.00
The scanner purchase included two scanners, so the effective cost was $22.50 each. Only one is required for the build, leaving the second as a spare or for another project.
Total spent on the project: $162.00
SECTION 4: HOW IT WORKS
SECTION 4: HOW IT WORKS
The Data Path
The Data Path
When an ID is scanned, the process is:
1. Scan
The 2D scanner reads the large PDF417 barcode on the back of the driver's license.
2. Decode
The scanner converts the PDF417 barcode into text and sends it to the Raspberry Pi.
3. Parse
The Raspberry Pi searches the AAMVA data for fields such as date of birth and expiration date.
Common AAMVA field identifiers include:
DBB – Date of Birth
DBA – Expiration Date
DAQ – Driver/Customer ID
DCS – Family Name
DAC – First Name
4. Calculate
The software calculates the person's age using the date of birth and the current date.
5. Display
The touchscreen gives the operator an immediate result.
Possible results include:
21+ VERIFIED
UNDER 21
ID EXPIRED
READ ERROR
6. Log
The scan is written to a spreadsheet for recordkeeping.
SECTION 5: SPREADSHEET LOGGING
SECTION 5: SPREADSHEET LOGGING
Recording Each Scan
Recording Each Scan
Each successful scan will create a new row in the scanner log.
The initial system will maintain a local CSV spreadsheet on the Raspberry Pi.
The log can contain fields such as:
Scan Date | Scan Time | Result | Age | Date of Birth | Expiration | First Name | Last Name | License/Customer ID | Issuing Jurisdiction | Raw AAMVA Data
A future version may automatically send the information to a Google Sheet while retaining the local file as a backup.
Because driver's-license barcode data contains personally identifying information, access to the spreadsheet and the Raspberry Pi should be restricted appropriately. Data retention should also be limited to whatever information is actually required for the intended use.
SECTION 6: AUDIO FEEDBACK
SECTION 6: AUDIO FEEDBACK
Future Audible Alerts
Future Audible Alerts
The first version will operate without a speaker.
However, audio support is being included in the software from the beginning so a speaker can be added later without redesigning the application.
The planned sounds are:
🟢 21+ VERIFIED
A short positive two-tone sound
🔴 UNDER 21
A distinctive warning sequence
🟠 EXPIRED ID
A separate warning tone
⚠️ READ ERROR
A low error tone indicating that the ID should be scanned again
The screen will always display the result, so audio will supplement rather than replace the visual indication.
SECTION 7: SOFTWARE SETUP
SECTION 7: SOFTWARE SETUP
Raspberry Pi Operating System
Raspberry Pi Operating System
The Raspberry Pi will run Raspberry Pi OS.
The basic installation process is:
Install Raspberry Pi Imager on another computer.
Insert the microSD card.
Select Raspberry Pi OS.
Configure Wi-Fi and user information if desired.
Write the operating system to the microSD card.
Install the card in the Raspberry Pi.
Connect the touchscreen.
Connect the PDF417 scanner by USB.
Power on the Raspberry Pi.
Complete the initial Raspberry Pi OS configuration.
Before installing the age-verification application, the scanner should be tested independently.
SECTION 8: TEST THE SCANNER FIRST
SECTION 8: TEST THE SCANNER FIRST
Verify PDF417 Output
Verify PDF417 Output
Open a text editor on the Raspberry Pi.
Place the cursor in the document and scan the large PDF417 barcode on the back of a driver's license.
A properly configured scanner should produce considerably more information than a conventional UPC-style barcode.
The output should contain AAMVA field identifiers.
For example, you may see fields beginning with:
DAQ
DCS
DAC
DBA
DBB
If this information appears, the scanner is successfully decoding the PDF417 barcode.
If only a short number appears, verify that you are scanning the large PDF417 barcode and that PDF417 decoding is enabled on the scanner.
SECTION 9: PRIVACY & LIMITATIONS
SECTION 9: PRIVACY & LIMITATIONS
What This Device Does and Does Not Do
What This Device Does and Does Not Do
This device reads information encoded on the driver's license.
It does not automatically contact DPS, DMV, TABC, or another government system.
Therefore:
It can:
Read the encoded DOB, calculate age, read the encoded expiration date, and process other AAMVA information present in the PDF417 barcode.
It cannot, by itself:
Confirm that DPS currently considers the license valid, determine whether a license has subsequently been suspended or revoked, or prove that a sophisticated counterfeit card is genuine.
The scanner should therefore be considered an ID-reading and age-calculation tool, not a government-backed identity authentication system.
SECTION 10: PROJECT STATUS
SECTION 10: PROJECT STATUS
Current Status
Current Status
✓ Raspberry Pi selected
✓ Touchscreen selected
✓ First 1D scanner tested
✓ Discovered PDF417 requirement
✓ PDF417-capable scanner purchased
✓ New scanner successfully reads driver's licenses
✓ Spreadsheet logging added to design
✓ Audio alerts included in software design
○ Install Raspberry Pi OS
○ Install scanner application
○ Test AAMVA parsing
○ Test age calculations
○ Test expiration detection
○ Test spreadsheet logging
○ Configure automatic startup
○ Add enclosure-mounted speaker
○ Field test completed system
Project Goal
Project Goal
The final result will be a small standalone appliance:
Pick up ID → Scan → Get Result → Continue
No keyboard. No navigating through programs. No manually calculating birthdays.
Just a dedicated Raspberry Pi doing one job and doing it quickly.
Build started: 2026
SECTION 11: INSTALL THE SCANNER SOFTWARE
SECTION 11: INSTALL THE SCANNER SOFTWARE
Once Raspberry Pi OS is installed and the PDF417 scanner has been tested, the next step is preparing the Pi for the actual ID-scanner application.
Open Terminal on the Raspberry Pi.
1. Update the Raspberry Pi
1. Update the Raspberry Pi
Copy and paste:
sudo apt update && sudo apt full-upgrade -y
When that finishes, reboot:
sudo reboot
2. Create the Project Folder
2. Create the Project Folder
After the Pi restarts, open Terminal again and enter:
mkdir -p ~/id-scanner
cd ~/id-scanner
This folder will contain the scanner program, scan log, configuration, and eventually the sound files.
3. Check Python
3. Check Python
Raspberry Pi OS normally includes Python. Verify it with:
python3 --version
You should see something similar to:
Python 3.x.x
4. Create the Scanner Program
4. Create the Scanner Program
Enter:
nano ~/id-scanner/id_scanner.py
This opens the text editor where we'll paste the actual program.
Don't write anything in it yet.
The next section of this build contains the complete Python program that receives the PDF417 data, parses the driver's-license fields, calculates age and expiration, displays the result, records the scan in the spreadsheet, and has the hooks ready for our future sound system.
SECTION 12: CREATE THE ID SCANNER PROGRAM
SECTION 12: CREATE THE ID SCANNER PROGRAM
Now we will create the Python program that runs the scanner.
The program will eventually handle five jobs:
Receive the PDF417 data from the USB scanner
Decode the AAMVA driver's-license fields
Calculate the person's age and check the expiration date
Display a large, easy-to-read result on the touchscreen
Record the scan information in a spreadsheet
Audio functions will also be included so different sounds can be added later without rewriting the scanner program.
1. Open the Program File
1. Open the Program File
In Terminal, enter:
nano ~/id-scanner/id_scanner.py
A blank editor window should open.
2. Paste the Program
2. Paste the Program
Copy everything below into the editor:
import tkinter as tkimport csvimport osimport reimport sysimport shutilimport subprocessfrom datetime import datetime, date
# ============================================================# RASPBERRY PI DRIVER LICENSE AGE VERIFICATION SCANNER## Standalone touchscreen ID age-verification system## FEATURES# ------------------------------------------------------------# PDF417 / AAMVA driver's license scanning# Date-of-birth parsing# Automatic age calculation# Expiration checking# Full-screen touchscreen display# CSV spreadsheet logging# Raw AAMVA logging for troubleshooting# Automatic 3-second result reset# PDF417 multi-line scan buffering# Touchscreen Admin menu# View scan log# Export scan log to USB# Safe USB unmount after export# Restart scanner# Reboot Raspberry Pi# Safe Raspberry Pi shutdown# Future sound support# ============================================================
# ============================================================# SETTINGS# ============================================================
PROJECT_DIR = os.path.expanduser("~/id-scanner")
LOG_FILE = os.path.join( PROJECT_DIR, "vinland_id_scans.csv")
# How long a result remains on screen.RESULT_DISPLAY_TIME = 3000
# Scanner is considered finished when no new characters# arrive for this amount of time.## This is important because PDF417 / AAMVA data can contain# line breaks inside the barcode.SCAN_IDLE_TIME = 350
# Hold ADMIN this long to open the Admin menu.ADMIN_HOLD_TIME = 3000
# Future speaker support.SOUND_ENABLED = False
# ============================================================# GLOBAL VARIABLES# ============================================================
scan_buffer = ""
scan_timer = None
reset_timer = None
admin_hold_timer = None
admin_active = False
# ============================================================# AGE CALCULATION# ============================================================
def calculate_age(birth_date):
today = date.today()
age = ( today.year - birth_date.year - ( (today.month, today.day) < (birth_date.month, birth_date.day) ) )
return age
# ============================================================# AAMVA DATE PARSING# ============================================================
def parse_aamva_date(value):
if not value: return None
value = re.sub( r"[^0-9]", "", value )
if len(value) != 8: return None
# Common AAMVA format: MMDDYYYY
try:
return datetime.strptime( value, "%m%d%Y" ).date()
except ValueError: pass
# Fallback for YYYYMMDD.
try:
return datetime.strptime( value, "%Y%m%d" ).date()
except ValueError:
return None
# ============================================================# READ AAMVA FIELD# ============================================================
def get_field(data, code):
# Preferred method: # Look for the field at the beginning of an AAMVA line.
pattern = rf"(?:^|[\r\n]){code}([^\r\n]+)"
match = re.search( pattern, data )
if match:
return match.group(1).strip()
# Fallback for scanners that alter line separators.
pattern = rf"{code}([^\r\n]+)"
match = re.search( pattern, data )
if match:
return match.group(1).strip()
return ""
# ============================================================# PARSE DRIVER LICENSE# ============================================================
def parse_license(data):
return {
"license_number": get_field(data, "DAQ"),
"last_name": get_field(data, "DCS"),
"first_name": get_field(data, "DAC"),
"middle_name": get_field(data, "DAD"),
"expiration": get_field(data, "DBA"),
"dob": get_field(data, "DBB"),
"issue_date": get_field(data, "DBD"),
"sex": get_field(data, "DBC"),
"eye_color": get_field(data, "DAY"),
"height": get_field(data, "DAU"),
"address": get_field(data, "DAG"),
"city": get_field(data, "DAI"),
"state": get_field(data, "DAJ"),
"zip": get_field(data, "DAK"), }
# ============================================================# FUTURE AUDIO SUPPORT# ============================================================
def play_sound(result):
if not SOUND_ENABLED: return
# Future sound hooks: # # VERIFIED # UNDER_21 # EXPIRED # ERROR # # Sound hardware can be added later without changing # the rest of the verification system.
# ============================================================# CREATE SCAN LOG# ============================================================
def create_log():
os.makedirs( PROJECT_DIR, exist_ok=True )
if os.path.exists(LOG_FILE): return
headers = [
"Scan Date", "Scan Time", "Result", "Age",
"License Number",
"First Name", "Middle Name", "Last Name",
"Date of Birth", "Expiration Date", "Issue Date",
"Sex", "Eye Color", "Height",
"Address", "City", "State", "ZIP",
"Raw AAMVA Data" ]
with open( LOG_FILE, "w", newline="", encoding="utf-8" ) as file:
writer = csv.writer(file)
writer.writerow(headers)
# ============================================================# LOG SCAN# ============================================================
def log_scan( fields, result, age, raw_data):
now = datetime.now()
row = [
now.strftime("%Y-%m-%d"), now.strftime("%H:%M:%S"),
result, age,
fields["license_number"],
fields["first_name"], fields["middle_name"], fields["last_name"],
fields["dob"], fields["expiration"], fields["issue_date"],
fields["sex"], fields["eye_color"], fields["height"],
fields["address"], fields["city"], fields["state"], fields["zip"],
raw_data.replace( "\r", "\\r" ).replace( "\n", "\\n" ) ]
try:
with open( LOG_FILE, "a", newline="", encoding="utf-8" ) as file:
writer = csv.writer(file)
writer.writerow(row)
except Exception as error:
print( "LOG ERROR:", error )
# ============================================================# RESULT DISPLAY# ============================================================
def cancel_reset():
global reset_timer
if reset_timer is not None:
try:
root.after_cancel( reset_timer )
except Exception:
pass
reset_timer = None
def reset_display():
global reset_timer
reset_timer = None
if admin_active: return
scanner_frame.config( bg="#111111" )
title_label.config( bg="#111111" )
result_label.config( text="READY", bg="#111111" )
detail_label.config( text="SCAN DRIVER LICENSE", bg="#111111" )
admin_button.config( bg="#333333" )
root.focus_force()
def schedule_reset():
global reset_timer
cancel_reset()
reset_timer = root.after( RESULT_DISPLAY_TIME, reset_display )
def show_result( title, detail, background):
cancel_reset()
scanner_frame.config( bg=background )
title_label.config( bg=background )
result_label.config( text=title, bg=background )
detail_label.config( text=detail, bg=background )
admin_button.config( bg=background )
# ============================================================# PROCESS COMPLETE DRIVER LICENSE SCAN# ============================================================
def process_scan(data):
if admin_active: return
data = data.strip()
if not data: return
cancel_reset()
fields = parse_license(data)
dob = parse_aamva_date( fields["dob"] )
expiration = parse_aamva_date( fields["expiration"] )
# -------------------------------------------------------- # COULD NOT READ DATE OF BIRTH # --------------------------------------------------------
if dob is None:
result = "READ ERROR"
show_result( "READ ERROR", "SCAN ID AGAIN", "#8B0000" )
log_scan( fields, result, "", data )
play_sound( "ERROR" )
schedule_reset()
return
# -------------------------------------------------------- # CALCULATE AGE # --------------------------------------------------------
age = calculate_age( dob )
today = date.today()
# -------------------------------------------------------- # EXPIRED ID # # Expiration takes priority over the age result. # --------------------------------------------------------
if ( expiration is not None and expiration < today ):
result = "ID EXPIRED"
show_result( "ID EXPIRED", f"AGE {age}", "#B36B00" )
play_sound( "EXPIRED" )
# -------------------------------------------------------- # UNDER 21 # --------------------------------------------------------
elif age < 21:
result = "UNDER 21"
show_result( "UNDER 21", f"AGE {age}", "#8B0000" )
play_sound( "UNDER_21" )
# -------------------------------------------------------- # AGE 21 OR OLDER # --------------------------------------------------------
else:
result = "21+ VERIFIED"
show_result( "21+ VERIFIED", f"AGE {age}", "#176B32" )
play_sound( "VERIFIED" )
# -------------------------------------------------------- # RECORD RESULT # --------------------------------------------------------
log_scan( fields, result, age, data )
# -------------------------------------------------------- # RETURN TO READY # --------------------------------------------------------
schedule_reset()
# ============================================================# USB BARCODE SCANNER INPUT# ============================================================
def finish_scan():
global scan_buffer global scan_timer
scan_timer = None
completed_scan = scan_buffer
scan_buffer = ""
process_scan( completed_scan )
def scanner_key(event):
global scan_buffer global scan_timer
if admin_active: return
# Ignore keys that should never become barcode data.
if event.keysym in ( "Escape", "Shift_L", "Shift_R", "Control_L", "Control_R", "Alt_L", "Alt_R", "Caps_Lock" ):
return
# A new character arrived, so the scan is still running.
if scan_timer is not None:
try:
root.after_cancel( scan_timer )
except Exception:
pass
# PDF417 data may contain Return characters. # Preserve them instead of ending the scan.
if event.keysym in ( "Return", "KP_Enter" ):
scan_buffer += "\n"
elif event.keysym == "Tab":
scan_buffer += "\t"
elif event.char:
scan_buffer += event.char
# When no more characters arrive, process the complete scan.
scan_timer = root.after( SCAN_IDLE_TIME, finish_scan )
# ============================================================# ADMIN HOLD BUTTON# ============================================================
def admin_press(event=None):
global admin_hold_timer
admin_hold_timer = root.after( ADMIN_HOLD_TIME, open_admin_menu )
def admin_release(event=None):
global admin_hold_timer
if admin_hold_timer is not None:
try:
root.after_cancel( admin_hold_timer )
except Exception:
pass
admin_hold_timer = None
# ============================================================# OPEN ADMIN MENU# ============================================================
def open_admin_menu():
global admin_active global admin_hold_timer global scan_buffer
admin_hold_timer = None
admin_active = True
scan_buffer = ""
cancel_reset()
scanner_frame.pack_forget()
admin_frame.pack( fill="both", expand=True )
# ============================================================# RETURN TO SCANNER# ============================================================
def return_to_scanner():
global admin_active global scan_buffer
admin_active = False
scan_buffer = ""
admin_frame.pack_forget()
scanner_frame.pack( fill="both", expand=True )
reset_display()
root.focus_force()
# ============================================================# ADMIN STATUS MESSAGE# ============================================================
def show_admin_message( message, duration=5000):
admin_status.config( text=message )
root.after( duration, lambda: admin_status.config( text="" ) )
# ============================================================# VIEW SCAN LOG# ============================================================
def view_scan_log():
try:
subprocess.Popen( [ "xdg-open", LOG_FILE ] )
except Exception:
show_admin_message( "COULD NOT OPEN LOG" )
# ============================================================# FIND A MOUNTED USB DRIVE# ============================================================
def find_usb_drive():
username = os.environ.get( "USER", "" )
# Desktop Linux normally mounts removable drives # beneath one of these directories.
search_locations = [
os.path.join( "/media", username ),
os.path.join( "/run/media", username ) ]
mounted_devices = []
try:
result = subprocess.run( [ "lsblk", "-J", "-o", "NAME,TRAN,TYPE,MOUNTPOINT" ], capture_output=True, text=True, check=False )
import json
data = json.loads( result.stdout )
def inspect_device(device, usb_parent=False):
transport = device.get( "tran" )
is_usb = ( usb_parent or transport == "usb" )
mountpoint = device.get( "mountpoint" )
if ( is_usb and mountpoint and os.path.isdir(mountpoint) and os.access( mountpoint, os.W_OK ) ):
mounted_devices.append( mountpoint )
for child in device.get( "children", [] ):
inspect_device( child, is_usb )
for device in data.get( "blockdevices", [] ):
inspect_device( device )
except Exception:
pass
# Prefer a device positively identified as USB.
if mounted_devices:
return mounted_devices[0]
# Fallback for removable media mounted by the desktop.
for location in search_locations:
if not os.path.isdir( location ):
continue
try:
drives = os.listdir( location )
except OSError:
continue
for drive in drives:
drive_path = os.path.join( location, drive )
if ( os.path.ismount( drive_path ) and os.access( drive_path, os.W_OK ) ):
return drive_path
return None
# ============================================================# EXPORT SCAN LOG TO USB# ============================================================
def export_scan_log():
if not os.path.exists( LOG_FILE ):
show_admin_message( "SCAN LOG NOT FOUND" )
return
usb_drive = find_usb_drive()
if usb_drive is None:
show_admin_message( "USB DRIVE NOT FOUND" )
return
timestamp = datetime.now().strftime( "%Y-%m-%d_%H%M%S" )
filename = ( "ID_Scan_Log_" + timestamp + ".csv" )
destination = os.path.join( usb_drive, filename )
try:
# Copy the spreadsheet.
shutil.copy2( LOG_FILE, destination )
# Force buffered data to physical storage.
with open( destination, "rb" ) as exported_file:
os.fsync( exported_file.fileno() )
subprocess.run( [ "sync" ], check=False )
# Try to safely unmount the USB drive.
unmounted = False
try:
result = subprocess.run( [ "udisksctl", "unmount", "-b", get_device_for_mount( usb_drive ) ], capture_output=True, text=True, check=False )
if result.returncode == 0:
unmounted = True
except Exception:
pass
if unmounted:
show_admin_message( "EXPORT COMPLETE\n" + filename + "\nSAFE TO REMOVE USB", 8000 )
else:
show_admin_message( "EXPORT COMPLETE\n" + filename + "\nUSE DESKTOP EJECT BEFORE REMOVING", 8000 )
except Exception as error:
print( "EXPORT ERROR:", error )
show_admin_message( "EXPORT FAILED" )
# ============================================================# FIND DEVICE ASSOCIATED WITH USB MOUNT# ============================================================
def get_device_for_mount( mountpoint):
try:
result = subprocess.run( [ "findmnt", "-n", "-o", "SOURCE", "--target", mountpoint ], capture_output=True, text=True, check=False )
device = result.stdout.strip()
if device.startswith( "/dev/" ):
return device
except Exception:
pass
return ""
# ============================================================# RESTART SCANNER APPLICATION# ============================================================
def restart_scanner():
python = sys.executable
os.execv( python, [ python ] + sys.argv )
# ============================================================# CONFIRM REBOOT OR SHUTDOWN# ============================================================
def confirm_action(action):
confirmation_frame.place( relx=0, rely=0, relwidth=1, relheight=1 )
confirmation_frame.lift()
if action == "shutdown":
confirmation_title.config( text="SHUT DOWN THE SCANNER?" )
confirmation_yes.config( text="YES, SHUT DOWN", command=shutdown_pi )
elif action == "reboot":
confirmation_title.config( text="REBOOT THE SCANNER?" )
confirmation_yes.config( text="YES, REBOOT", command=reboot_pi )
def cancel_confirmation():
confirmation_frame.place_forget()
# ============================================================# REBOOT RASPBERRY PI# ============================================================
def reboot_pi():
try:
subprocess.Popen( [ "systemctl", "reboot" ] )
except Exception:
cancel_confirmation()
show_admin_message( "REBOOT FAILED" )
# ============================================================# SHUT DOWN RASPBERRY PI# ============================================================
def shutdown_pi():
try:
subprocess.Popen( [ "systemctl", "poweroff" ] )
except Exception:
cancel_confirmation()
show_admin_message( "SHUTDOWN FAILED" )
# ============================================================# CREATE LOG BEFORE GUI STARTS# ============================================================
create_log()
# ============================================================# MAIN WINDOW# ============================================================
root = tk.Tk()
root.title( "ID Age Verification")
root.attributes( "-fullscreen", True)
root.config( bg="#111111")
root.focus_force()
# ============================================================# NORMAL SCANNER SCREEN# ============================================================
scanner_frame = tk.Frame( root, bg="#111111")
scanner_frame.pack( fill="both", expand=True)
# ------------------------------------------------------------# ADMIN BUTTON# ------------------------------------------------------------
admin_button = tk.Label(
scanner_frame,
text="ADMIN",
font=( "Arial", 12, "bold" ),
fg="#BBBBBB",
bg="#333333",
padx=15,
pady=10)
admin_button.place( relx=0.98, rely=0.03, anchor="ne")
admin_button.bind( "<ButtonPress-1>", admin_press)
admin_button.bind( "<ButtonRelease-1>", admin_release)
# ------------------------------------------------------------# TITLE# ------------------------------------------------------------
title_label = tk.Label(
scanner_frame,
text="ID AGE VERIFICATION",
font=( "Arial", 24, "bold" ),
fg="white",
bg="#111111")
title_label.pack( pady=(35, 20))
# ------------------------------------------------------------# LARGE RESULT# ------------------------------------------------------------
result_label = tk.Label(
scanner_frame,
text="READY",
font=( "Arial", 58, "bold" ),
fg="white",
bg="#111111")
result_label.pack( expand=True)
# ------------------------------------------------------------# RESULT DETAIL# ------------------------------------------------------------
detail_label = tk.Label(
scanner_frame,
text="SCAN DRIVER LICENSE",
font=( "Arial", 28, "bold" ),
fg="white",
bg="#111111")
detail_label.pack( pady=(10, 60))
# ============================================================# ADMIN MENU# ============================================================
admin_frame = tk.Frame( root, bg="#111111")
admin_title = tk.Label(
admin_frame,
text="ADMIN MENU",
font=( "Arial", 30, "bold" ),
fg="white",
bg="#111111")
admin_title.pack( pady=(25, 15))
button_settings = {
"font": ( "Arial", 17, "bold" ),
"width": 24,
"height": 1,
"bd": 0,
"fg": "white",
"bg": "#333333",
"activeforeground": "white",
"activebackground": "#555555"}
# ------------------------------------------------------------# VIEW LOG# ------------------------------------------------------------
view_log_button = tk.Button(
admin_frame,
text="VIEW SCAN LOG",
command=view_scan_log,
**button_settings)
view_log_button.pack( pady=4)
# ------------------------------------------------------------# EXPORT LOG# ------------------------------------------------------------
export_log_button = tk.Button(
admin_frame,
text="EXPORT SCAN LOG",
command=export_scan_log,
**button_settings)
export_log_button.pack( pady=4)
# ------------------------------------------------------------# RESTART SCANNER# ------------------------------------------------------------
restart_button = tk.Button(
admin_frame,
text="RESTART SCANNER",
command=restart_scanner,
**button_settings)
restart_button.pack( pady=4)
# ------------------------------------------------------------# REBOOT PI# ------------------------------------------------------------
reboot_button = tk.Button(
admin_frame,
text="REBOOT PI",
command=lambda: confirm_action( "reboot" ),
**button_settings)
reboot_button.pack( pady=4)
# ------------------------------------------------------------# SHUT DOWN PI# ------------------------------------------------------------
shutdown_button = tk.Button(
admin_frame,
text="SHUT DOWN PI",
command=lambda: confirm_action( "shutdown" ),
**button_settings)
shutdown_button.pack( pady=4)
# ------------------------------------------------------------# RETURN TO SCANNER# ------------------------------------------------------------
return_button = tk.Button(
admin_frame,
text="RETURN TO SCANNER",
command=return_to_scanner,
**button_settings)
return_button.pack( pady=4)
# ------------------------------------------------------------# ADMIN STATUS# ------------------------------------------------------------
admin_status = tk.Label(
admin_frame,
text="",
font=( "Arial", 14, "bold" ),
fg="white",
bg="#111111")
admin_status.pack( pady=8)
# ============================================================# CONFIRMATION SCREEN# ============================================================
confirmation_frame = tk.Frame( root, bg="#111111")
confirmation_title = tk.Label(
confirmation_frame,
text="",
font=( "Arial", 30, "bold" ),
fg="white",
bg="#111111")
confirmation_title.pack( pady=(150, 50))
confirmation_yes = tk.Button(
confirmation_frame,
text="YES",
font=( "Arial", 22, "bold" ),
width=18,
height=2,
fg="white",
bg="#8B0000",
activeforeground="white",
activebackground="#AA0000",
bd=0)
confirmation_yes.pack( pady=10)
confirmation_cancel = tk.Button(
confirmation_frame,
text="CANCEL",
command=cancel_confirmation,
font=( "Arial", 22, "bold" ),
width=18,
height=2,
fg="white",
bg="#444444",
activeforeground="white",
activebackground="#666666",
bd=0)
confirmation_cancel.pack( pady=10)
# ============================================================# SCANNER INPUT## bind_all captures scanner keystrokes even if another widget# inside this application receives focus.# ============================================================
root.bind_all( "<Key>", scanner_key)
# ------------------------------------------------------------# ESCAPE DURING DEVELOPMENT## Allows a keyboard to exit the full-screen application# while the scanner is being built and tested.# ------------------------------------------------------------
root.bind( "<Escape>", lambda event: root.destroy())
# ============================================================# START APPLICATION# ============================================================
root.mainloop()
# ============================================================# RASPBERRY PI DRIVER LICENSE AGE VERIFICATION SCANNER## Standalone touchscreen ID age-verification system## FEATURES# ------------------------------------------------------------# PDF417 / AAMVA driver's license scanning# Date-of-birth parsing# Automatic age calculation# Expiration checking# Full-screen touchscreen display# CSV spreadsheet logging# Raw AAMVA logging for troubleshooting# Automatic 3-second result reset# PDF417 multi-line scan buffering# Touchscreen Admin menu# View scan log# Export scan log to USB# Safe USB unmount after export# Restart scanner# Reboot Raspberry Pi# Safe Raspberry Pi shutdown# Future sound support# ============================================================
# ============================================================# SETTINGS# ============================================================
PROJECT_DIR = os.path.expanduser("~/id-scanner")
LOG_FILE = os.path.join( PROJECT_DIR, "vinland_id_scans.csv")
# How long a result remains on screen.RESULT_DISPLAY_TIME = 3000
# Scanner is considered finished when no new characters# arrive for this amount of time.## This is important because PDF417 / AAMVA data can contain# line breaks inside the barcode.SCAN_IDLE_TIME = 350
# Hold ADMIN this long to open the Admin menu.ADMIN_HOLD_TIME = 3000
# Future speaker support.SOUND_ENABLED = False
# ============================================================# GLOBAL VARIABLES# ============================================================
scan_buffer = ""
scan_timer = None
reset_timer = None
admin_hold_timer = None
admin_active = False
# ============================================================# AGE CALCULATION# ============================================================
def calculate_age(birth_date):
today = date.today()
age = ( today.year - birth_date.year - ( (today.month, today.day) < (birth_date.month, birth_date.day) ) )
return age
# ============================================================# AAMVA DATE PARSING# ============================================================
def parse_aamva_date(value):
if not value: return None
value = re.sub( r"[^0-9]", "", value )
if len(value) != 8: return None
# Common AAMVA format: MMDDYYYY
try:
return datetime.strptime( value, "%m%d%Y" ).date()
except ValueError: pass
# Fallback for YYYYMMDD.
try:
return datetime.strptime( value, "%Y%m%d" ).date()
except ValueError:
return None
# ============================================================# READ AAMVA FIELD# ============================================================
def get_field(data, code):
# Preferred method: # Look for the field at the beginning of an AAMVA line.
pattern = rf"(?:^|[\r\n]){code}([^\r\n]+)"
match = re.search( pattern, data )
if match:
return match.group(1).strip()
# Fallback for scanners that alter line separators.
pattern = rf"{code}([^\r\n]+)"
match = re.search( pattern, data )
if match:
return match.group(1).strip()
return ""
# ============================================================# PARSE DRIVER LICENSE# ============================================================
def parse_license(data):
return {
"license_number": get_field(data, "DAQ"),
"last_name": get_field(data, "DCS"),
"first_name": get_field(data, "DAC"),
"middle_name": get_field(data, "DAD"),
"expiration": get_field(data, "DBA"),
"dob": get_field(data, "DBB"),
"issue_date": get_field(data, "DBD"),
"sex": get_field(data, "DBC"),
"eye_color": get_field(data, "DAY"),
"height": get_field(data, "DAU"),
"address": get_field(data, "DAG"),
"city": get_field(data, "DAI"),
"state": get_field(data, "DAJ"),
"zip": get_field(data, "DAK"), }
# ============================================================# FUTURE AUDIO SUPPORT# ============================================================
def play_sound(result):
if not SOUND_ENABLED: return
# Future sound hooks: # # VERIFIED # UNDER_21 # EXPIRED # ERROR # # Sound hardware can be added later without changing # the rest of the verification system.
# ============================================================# CREATE SCAN LOG# ============================================================
def create_log():
os.makedirs( PROJECT_DIR, exist_ok=True )
if os.path.exists(LOG_FILE): return
headers = [
"Scan Date", "Scan Time", "Result", "Age",
"License Number",
"First Name", "Middle Name", "Last Name",
"Date of Birth", "Expiration Date", "Issue Date",
"Sex", "Eye Color", "Height",
"Address", "City", "State", "ZIP",
"Raw AAMVA Data" ]
with open( LOG_FILE, "w", newline="", encoding="utf-8" ) as file:
writer = csv.writer(file)
writer.writerow(headers)
# ============================================================# LOG SCAN# ============================================================
def log_scan( fields, result, age, raw_data):
now = datetime.now()
row = [
now.strftime("%Y-%m-%d"), now.strftime("%H:%M:%S"),
result, age,
fields["license_number"],
fields["first_name"], fields["middle_name"], fields["last_name"],
fields["dob"], fields["expiration"], fields["issue_date"],
fields["sex"], fields["eye_color"], fields["height"],
fields["address"], fields["city"], fields["state"], fields["zip"],
raw_data.replace( "\r", "\\r" ).replace( "\n", "\\n" ) ]
try:
with open( LOG_FILE, "a", newline="", encoding="utf-8" ) as file:
writer = csv.writer(file)
writer.writerow(row)
except Exception as error:
print( "LOG ERROR:", error )
# ============================================================# RESULT DISPLAY# ============================================================
def cancel_reset():
global reset_timer
if reset_timer is not None:
try:
root.after_cancel( reset_timer )
except Exception:
pass
reset_timer = None
def reset_display():
global reset_timer
reset_timer = None
if admin_active: return
scanner_frame.config( bg="#111111" )
title_label.config( bg="#111111" )
result_label.config( text="READY", bg="#111111" )
detail_label.config( text="SCAN DRIVER LICENSE", bg="#111111" )
admin_button.config( bg="#333333" )
root.focus_force()
def schedule_reset():
global reset_timer
cancel_reset()
reset_timer = root.after( RESULT_DISPLAY_TIME, reset_display )
def show_result( title, detail, background):
cancel_reset()
scanner_frame.config( bg=background )
title_label.config( bg=background )
result_label.config( text=title, bg=background )
detail_label.config( text=detail, bg=background )
admin_button.config( bg=background )
# ============================================================# PROCESS COMPLETE DRIVER LICENSE SCAN# ============================================================
def process_scan(data):
if admin_active: return
data = data.strip()
if not data: return
cancel_reset()
fields = parse_license(data)
dob = parse_aamva_date( fields["dob"] )
expiration = parse_aamva_date( fields["expiration"] )
# -------------------------------------------------------- # COULD NOT READ DATE OF BIRTH # --------------------------------------------------------
if dob is None:
result = "READ ERROR"
show_result( "READ ERROR", "SCAN ID AGAIN", "#8B0000" )
log_scan( fields, result, "", data )
play_sound( "ERROR" )
schedule_reset()
return
# -------------------------------------------------------- # CALCULATE AGE # --------------------------------------------------------
age = calculate_age( dob )
today = date.today()
# -------------------------------------------------------- # EXPIRED ID # # Expiration takes priority over the age result. # --------------------------------------------------------
if ( expiration is not None and expiration < today ):
result = "ID EXPIRED"
show_result( "ID EXPIRED", f"AGE {age}", "#B36B00" )
play_sound( "EXPIRED" )
# -------------------------------------------------------- # UNDER 21 # --------------------------------------------------------
elif age < 21:
result = "UNDER 21"
show_result( "UNDER 21", f"AGE {age}", "#8B0000" )
play_sound( "UNDER_21" )
# -------------------------------------------------------- # AGE 21 OR OLDER # --------------------------------------------------------
else:
result = "21+ VERIFIED"
show_result( "21+ VERIFIED", f"AGE {age}", "#176B32" )
play_sound( "VERIFIED" )
# -------------------------------------------------------- # RECORD RESULT # --------------------------------------------------------
log_scan( fields, result, age, data )
# -------------------------------------------------------- # RETURN TO READY # --------------------------------------------------------
schedule_reset()
# ============================================================# USB BARCODE SCANNER INPUT# ============================================================
def finish_scan():
global scan_buffer global scan_timer
scan_timer = None
completed_scan = scan_buffer
scan_buffer = ""
process_scan( completed_scan )
def scanner_key(event):
global scan_buffer global scan_timer
if admin_active: return
# Ignore keys that should never become barcode data.
if event.keysym in ( "Escape", "Shift_L", "Shift_R", "Control_L", "Control_R", "Alt_L", "Alt_R", "Caps_Lock" ):
return
# A new character arrived, so the scan is still running.
if scan_timer is not None:
try:
root.after_cancel( scan_timer )
except Exception:
pass
# PDF417 data may contain Return characters. # Preserve them instead of ending the scan.
if event.keysym in ( "Return", "KP_Enter" ):
scan_buffer += "\n"
elif event.keysym == "Tab":
scan_buffer += "\t"
elif event.char:
scan_buffer += event.char
# When no more characters arrive, process the complete scan.
scan_timer = root.after( SCAN_IDLE_TIME, finish_scan )
# ============================================================# ADMIN HOLD BUTTON# ============================================================
def admin_press(event=None):
global admin_hold_timer
admin_hold_timer = root.after( ADMIN_HOLD_TIME, open_admin_menu )
def admin_release(event=None):
global admin_hold_timer
if admin_hold_timer is not None:
try:
root.after_cancel( admin_hold_timer )
except Exception:
pass
admin_hold_timer = None
# ============================================================# OPEN ADMIN MENU# ============================================================
def open_admin_menu():
global admin_active global admin_hold_timer global scan_buffer
admin_hold_timer = None
admin_active = True
scan_buffer = ""
cancel_reset()
scanner_frame.pack_forget()
admin_frame.pack( fill="both", expand=True )
# ============================================================# RETURN TO SCANNER# ============================================================
def return_to_scanner():
global admin_active global scan_buffer
admin_active = False
scan_buffer = ""
admin_frame.pack_forget()
scanner_frame.pack( fill="both", expand=True )
reset_display()
root.focus_force()
# ============================================================# ADMIN STATUS MESSAGE# ============================================================
def show_admin_message( message, duration=5000):
admin_status.config( text=message )
root.after( duration, lambda: admin_status.config( text="" ) )
# ============================================================# VIEW SCAN LOG# ============================================================
def view_scan_log():
try:
subprocess.Popen( [ "xdg-open", LOG_FILE ] )
except Exception:
show_admin_message( "COULD NOT OPEN LOG" )
# ============================================================# FIND A MOUNTED USB DRIVE# ============================================================
def find_usb_drive():
username = os.environ.get( "USER", "" )
# Desktop Linux normally mounts removable drives # beneath one of these directories.
search_locations = [
os.path.join( "/media", username ),
os.path.join( "/run/media", username ) ]
mounted_devices = []
try:
result = subprocess.run( [ "lsblk", "-J", "-o", "NAME,TRAN,TYPE,MOUNTPOINT" ], capture_output=True, text=True, check=False )
import json
data = json.loads( result.stdout )
def inspect_device(device, usb_parent=False):
transport = device.get( "tran" )
is_usb = ( usb_parent or transport == "usb" )
mountpoint = device.get( "mountpoint" )
if ( is_usb and mountpoint and os.path.isdir(mountpoint) and os.access( mountpoint, os.W_OK ) ):
mounted_devices.append( mountpoint )
for child in device.get( "children", [] ):
inspect_device( child, is_usb )
for device in data.get( "blockdevices", [] ):
inspect_device( device )
except Exception:
pass
# Prefer a device positively identified as USB.
if mounted_devices:
return mounted_devices[0]
# Fallback for removable media mounted by the desktop.
for location in search_locations:
if not os.path.isdir( location ):
continue
try:
drives = os.listdir( location )
except OSError:
continue
for drive in drives:
drive_path = os.path.join( location, drive )
if ( os.path.ismount( drive_path ) and os.access( drive_path, os.W_OK ) ):
return drive_path
return None
# ============================================================# EXPORT SCAN LOG TO USB# ============================================================
def export_scan_log():
if not os.path.exists( LOG_FILE ):
show_admin_message( "SCAN LOG NOT FOUND" )
return
usb_drive = find_usb_drive()
if usb_drive is None:
show_admin_message( "USB DRIVE NOT FOUND" )
return
timestamp = datetime.now().strftime( "%Y-%m-%d_%H%M%S" )
filename = ( "ID_Scan_Log_" + timestamp + ".csv" )
destination = os.path.join( usb_drive, filename )
try:
# Copy the spreadsheet.
shutil.copy2( LOG_FILE, destination )
# Force buffered data to physical storage.
with open( destination, "rb" ) as exported_file:
os.fsync( exported_file.fileno() )
subprocess.run( [ "sync" ], check=False )
# Try to safely unmount the USB drive.
unmounted = False
try:
result = subprocess.run( [ "udisksctl", "unmount", "-b", get_device_for_mount( usb_drive ) ], capture_output=True, text=True, check=False )
if result.returncode == 0:
unmounted = True
except Exception:
pass
if unmounted:
show_admin_message( "EXPORT COMPLETE\n" + filename + "\nSAFE TO REMOVE USB", 8000 )
else:
show_admin_message( "EXPORT COMPLETE\n" + filename + "\nUSE DESKTOP EJECT BEFORE REMOVING", 8000 )
except Exception as error:
print( "EXPORT ERROR:", error )
show_admin_message( "EXPORT FAILED" )
# ============================================================# FIND DEVICE ASSOCIATED WITH USB MOUNT# ============================================================
def get_device_for_mount( mountpoint):
try:
result = subprocess.run( [ "findmnt", "-n", "-o", "SOURCE", "--target", mountpoint ], capture_output=True, text=True, check=False )
device = result.stdout.strip()
if device.startswith( "/dev/" ):
return device
except Exception:
pass
return ""
# ============================================================# RESTART SCANNER APPLICATION# ============================================================
def restart_scanner():
python = sys.executable
os.execv( python, [ python ] + sys.argv )
# ============================================================# CONFIRM REBOOT OR SHUTDOWN# ============================================================
def confirm_action(action):
confirmation_frame.place( relx=0, rely=0, relwidth=1, relheight=1 )
confirmation_frame.lift()
if action == "shutdown":
confirmation_title.config( text="SHUT DOWN THE SCANNER?" )
confirmation_yes.config( text="YES, SHUT DOWN", command=shutdown_pi )
elif action == "reboot":
confirmation_title.config( text="REBOOT THE SCANNER?" )
confirmation_yes.config( text="YES, REBOOT", command=reboot_pi )
def cancel_confirmation():
confirmation_frame.place_forget()
# ============================================================# REBOOT RASPBERRY PI# ============================================================
def reboot_pi():
try:
subprocess.Popen( [ "systemctl", "reboot" ] )
except Exception:
cancel_confirmation()
show_admin_message( "REBOOT FAILED" )
# ============================================================# SHUT DOWN RASPBERRY PI# ============================================================
def shutdown_pi():
try:
subprocess.Popen( [ "systemctl", "poweroff" ] )
except Exception:
cancel_confirmation()
show_admin_message( "SHUTDOWN FAILED" )
# ============================================================# CREATE LOG BEFORE GUI STARTS# ============================================================
create_log()
# ============================================================# MAIN WINDOW# ============================================================
root = tk.Tk()
root.title( "ID Age Verification")
root.attributes( "-fullscreen", True)
root.config( bg="#111111")
root.focus_force()
# ============================================================# NORMAL SCANNER SCREEN# ============================================================
scanner_frame = tk.Frame( root, bg="#111111")
scanner_frame.pack( fill="both", expand=True)
# ------------------------------------------------------------# ADMIN BUTTON# ------------------------------------------------------------
admin_button = tk.Label(
scanner_frame,
text="ADMIN",
font=( "Arial", 12, "bold" ),
fg="#BBBBBB",
bg="#333333",
padx=15,
pady=10)
admin_button.place( relx=0.98, rely=0.03, anchor="ne")
admin_button.bind( "<ButtonPress-1>", admin_press)
admin_button.bind( "<ButtonRelease-1>", admin_release)
# ------------------------------------------------------------# TITLE# ------------------------------------------------------------
title_label = tk.Label(
scanner_frame,
text="ID AGE VERIFICATION",
font=( "Arial", 24, "bold" ),
fg="white",
bg="#111111")
title_label.pack( pady=(35, 20))
# ------------------------------------------------------------# LARGE RESULT# ------------------------------------------------------------
result_label = tk.Label(
scanner_frame,
text="READY",
font=( "Arial", 58, "bold" ),
fg="white",
bg="#111111")
result_label.pack( expand=True)
# ------------------------------------------------------------# RESULT DETAIL# ------------------------------------------------------------
detail_label = tk.Label(
scanner_frame,
text="SCAN DRIVER LICENSE",
font=( "Arial", 28, "bold" ),
fg="white",
bg="#111111")
detail_label.pack( pady=(10, 60))
# ============================================================# ADMIN MENU# ============================================================
admin_frame = tk.Frame( root, bg="#111111")
admin_title = tk.Label(
admin_frame,
text="ADMIN MENU",
font=( "Arial", 30, "bold" ),
fg="white",
bg="#111111")
admin_title.pack( pady=(25, 15))
button_settings = {
"font": ( "Arial", 17, "bold" ),
"width": 24,
"height": 1,
"bd": 0,
"fg": "white",
"bg": "#333333",
"activeforeground": "white",
"activebackground": "#555555"}
# ------------------------------------------------------------# VIEW LOG# ------------------------------------------------------------
view_log_button = tk.Button(
admin_frame,
text="VIEW SCAN LOG",
command=view_scan_log,
**button_settings)
view_log_button.pack( pady=4)
# ------------------------------------------------------------# EXPORT LOG# ------------------------------------------------------------
export_log_button = tk.Button(
admin_frame,
text="EXPORT SCAN LOG",
command=export_scan_log,
**button_settings)
export_log_button.pack( pady=4)
# ------------------------------------------------------------# RESTART SCANNER# ------------------------------------------------------------
restart_button = tk.Button(
admin_frame,
text="RESTART SCANNER",
command=restart_scanner,
**button_settings)
restart_button.pack( pady=4)
# ------------------------------------------------------------# REBOOT PI# ------------------------------------------------------------
reboot_button = tk.Button(
admin_frame,
text="REBOOT PI",
command=lambda: confirm_action( "reboot" ),
**button_settings)
reboot_button.pack( pady=4)
# ------------------------------------------------------------# SHUT DOWN PI# ------------------------------------------------------------
shutdown_button = tk.Button(
admin_frame,
text="SHUT DOWN PI",
command=lambda: confirm_action( "shutdown" ),
**button_settings)
shutdown_button.pack( pady=4)
# ------------------------------------------------------------# RETURN TO SCANNER# ------------------------------------------------------------
return_button = tk.Button(
admin_frame,
text="RETURN TO SCANNER",
command=return_to_scanner,
**button_settings)
return_button.pack( pady=4)
# ------------------------------------------------------------# ADMIN STATUS# ------------------------------------------------------------
admin_status = tk.Label(
admin_frame,
text="",
font=( "Arial", 14, "bold" ),
fg="white",
bg="#111111")
admin_status.pack( pady=8)
# ============================================================# CONFIRMATION SCREEN# ============================================================
confirmation_frame = tk.Frame( root, bg="#111111")
confirmation_title = tk.Label(
confirmation_frame,
text="",
font=( "Arial", 30, "bold" ),
fg="white",
bg="#111111")
confirmation_title.pack( pady=(150, 50))
confirmation_yes = tk.Button(
confirmation_frame,
text="YES",
font=( "Arial", 22, "bold" ),
width=18,
height=2,
fg="white",
bg="#8B0000",
activeforeground="white",
activebackground="#AA0000",
bd=0)
confirmation_yes.pack( pady=10)
confirmation_cancel = tk.Button(
confirmation_frame,
text="CANCEL",
command=cancel_confirmation,
font=( "Arial", 22, "bold" ),
width=18,
height=2,
fg="white",
bg="#444444",
activeforeground="white",
activebackground="#666666",
bd=0)
confirmation_cancel.pack( pady=10)
# ============================================================# SCANNER INPUT## bind_all captures scanner keystrokes even if another widget# inside this application receives focus.# ============================================================
root.bind_all( "<Key>", scanner_key)
# ------------------------------------------------------------# ESCAPE DURING DEVELOPMENT## Allows a keyboard to exit the full-screen application# while the scanner is being built and tested.# ------------------------------------------------------------
root.bind( "<Escape>", lambda event: root.destroy())
# ============================================================# START APPLICATION# ============================================================
root.mainloop()
3. Save the Program
3. Save the Program
Press:
CTRL + O
Press:
ENTER
Then press:
CTRL + X
That saves the file and returns you to Terminal.
SECTION 13: FIRST SOFTWARE TEST
SECTION 13: FIRST SOFTWARE TEST
Before making the scanner start automatically, run it manually.
Enter:
cd ~/id-scanner
python3 id_scanner.py
The touchscreen should switch to a full-screen display showing:
ID AGE VERIFICATION
READY
SCAN DRIVER LICENSE
Now scan the large PDF417 barcode on the back of a driver's license.
If everything is working, the screen should change immediately to one of the following:
21+ VERIFIED
UNDER 21
ID EXPIRED
or
READ ERROR
The calculated age should appear underneath the result.
During testing, press the ESC key to close the application.
Important
Important
Don't set up automatic startup yet.
First we want to test this with several real licenses. Different states and different generations of driver's licenses can format their AAMVA records somewhat differently.
Once we've confirmed the program correctly reads your Texas licenses, we'll inspect the spreadsheet it creates and make any parser adjustments before we turn the Pi into a dedicated kiosk.
The spreadsheet will be located at:
/home/YOUR-USERNAME/id-scanner/vinland_id_scans.csv
SECTION 14: CHECK THE SCAN LOG
SECTION 14: CHECK THE SCAN LOG
After successfully scanning several driver's licenses, verify that the Raspberry Pi is recording the information correctly.
The scanner automatically creates this file:
~/id-scanner/vinland_id_scans.csv
1. Open the Scan Log
1. Open the Scan Log
From Terminal, enter:
libreoffice --calc ~/id-scanner/vinland_id_scans.csv
The file should open as a spreadsheet.
2. Check the Information
2. Check the Information
Each scan should create one new row.
Verify that the columns contain the correct information:
Scan Date | Scan Time | Result | Age | License Number | First Name | Middle Name | Last Name | Date of Birth | Expiration Date | Issue Date | Sex | Eye Color | Height | Address | City | State | ZIP | Raw AAMVA Data
Compare several rows against the actual licenses used for testing.
Pay particular attention to:
Date of Birth
Make sure the date was decoded correctly.
Age
Make sure the calculated age is correct, especially for someone whose birthday has not occurred yet this year.
Expiration Date
Make sure an expired license produces ID EXPIRED.
Result
Make sure someone 21 or older produces 21+ VERIFIED, while someone under 21 produces UNDER 21.
3. Why We Keep the Raw Data
3. Why We Keep the Raw Data
The final column contains the original AAMVA information received from the scanner.
This is useful during development because if a license from another state does not parse correctly, the raw data allows the program to be updated to recognize that format.
Once testing is complete, whether the system should continue retaining raw ID data can be reconsidered based on the project's actual recordkeeping requirements and privacy policy.
DO NOT CONTINUE UNTIL THIS TEST PASSES
DO NOT CONTINUE UNTIL THIS TEST PASSES
Before configuring automatic startup, test several licenses.
The Pi should consistently:
Scan → Decode → Calculate → Display → Log → Reset → READY
Once that works reliably, the software itself is doing its job.
SECTION 15: START THE ID SCANNER AUTOMATICALLY
SECTION 15: START THE ID SCANNER AUTOMATICALLY
Once the scanner has been tested and is reliably reading and logging IDs, the next step is turning the Raspberry Pi into a dedicated appliance.
After this setup, the normal operation will be:
Power On → Raspberry Pi Boots → ID Scanner Opens Full Screen → READY
No Terminal window and no manually starting Python.
1. Create an Autostart Folder
1. Create an Autostart Folder
Open Terminal and enter:
mkdir -p ~/.config/autostart
2. Create the Autostart File
2. Create the Autostart File
Enter:
nano ~/.config/autostart/id-scanner.desktop
Paste this entire block into the file:
[Desktop Entry]
Type=Application
Name=ID Scanner
Comment=Driver License Age Verification Scanner
Exec=python3 /home/YOUR-USERNAME/id-scanner/id_scanner.py
Terminal=false
X-GNOME-Autostart-enabled=true
3. Replace YOUR-USERNAME
3. Replace YOUR-USERNAME
The line containing:
/home/YOUR-USERNAME/id-scanner/id_scanner.py
needs the actual Raspberry Pi username.
If you don't remember the username, open another Terminal and enter:
whoami
For example, if it returns:
clyde
then the Exec line should be:
Exec=python3 /home/clyde/id-scanner/id_scanner.py
4. Save the Autostart File
4. Save the Autostart File
Press:
CTRL + O
Then:
ENTER
Then:
CTRL + X
5. Test Automatic Startup
5. Test Automatic Startup
Reboot the Raspberry Pi:
sudo reboot
Don't touch anything after it restarts.
Raspberry Pi OS should load, and then the ID scanner should automatically open full screen.
The display should show:
ID AGE VERIFICATION
READY
READY
SCAN DRIVER LICENSE
Scan an ID and verify the entire sequence:
Scan → Result → Spreadsheet Log → 3-Second Reset → READY
6. Test a Full Power Cycle
6. Test a Full Power Cycle
A reboot isn't quite enough for the final test.
Shut the Raspberry Pi down properly:
sudo poweroff
Wait until the Pi has completely shut down.
Disconnect power for several seconds, reconnect it, and allow the system to boot normally.
The scanner application should launch without any intervention.
NORMAL DAILY OPERATION
NORMAL DAILY OPERATION
Once automatic startup is working, using the device should be extremely simple.
Starting
Starting
1. Power on the Raspberry Pi
2. Wait for READY
3. Scan IDs
That's it.
Scanning
Scanning
When an ID is scanned, the screen displays the result for approximately three seconds.
🟢 21+ VERIFIED
🔴 UNDER 21
🟠 ID EXPIRED
🔴 READ ERROR
The system then automatically returns to:
READY
and waits for the next ID.
Shutting Down
Shutting Down
Because the Raspberry Pi is a computer, do not routinely unplug it while it is running. Doing so can eventually corrupt the microSD card.
For now, shut it down through Raspberry Pi OS or Terminal:
sudo poweroff
Wait for shutdown to complete before disconnecting power.
SECTION 16: SAVING AND EXPORTING SCAN RECORDS
SECTION 16: SAVING AND EXPORTING SCAN RECORDS
Local Spreadsheet Storage
Local Spreadsheet Storage
Every completed scan is automatically recorded by the Raspberry Pi.
The scanner maintains a local CSV spreadsheet at:
~/id-scanner/vinland_id_scans.csv
CSV was chosen because it is simple, reliable, and can be opened by most spreadsheet programs, including:
Microsoft Excel • Google Sheets • LibreOffice Calc
The scanner does not need an internet connection to maintain this log.
INFORMATION RECORDED
INFORMATION RECORDED
Each scan creates a new row in the spreadsheet.
The log contains:
Scan Date
Scan Time
Result
Calculated Age
License Number
First Name
Middle Name
Last Name
Date of Birth
Expiration Date
Issue Date
Sex
Eye Color
Height
Address
City
State
ZIP
Raw AAMVA Data
Keeping the raw AAMVA record during development is especially useful because driver's licenses from different states and different generations of licenses may format their PDF417 data differently.
If the scanner encounters a license that does not parse correctly, the original barcode data can be examined without having to reproduce the problem immediately.
EXPORTING THE SCAN LOG
EXPORTING THE SCAN LOG
The Raspberry Pi's microSD card contains both the operating system and the scanner records.
Although the SD card could technically be removed to retrieve information, this is not the normal method of getting the spreadsheet.
Instead, the scanner includes a built-in:
EXPORT SCAN LOG
EXPORT SCAN LOG
function in the touchscreen Admin menu.
This allows scan records to be copied to a standard USB flash drive without removing the Raspberry Pi's microSD card.
HOW TO EXPORT THE SPREADSHEET
HOW TO EXPORT THE SPREADSHEET
1. Insert a USB Flash Drive
1. Insert a USB Flash Drive
Insert a standard USB flash drive into an available USB port on the Raspberry Pi.
The drive should use a commonly supported filesystem such as:
FAT32 or exFAT
This allows the same flash drive to be read easily by Windows, macOS, and Linux computers.
2. Open the Admin Menu
2. Open the Admin Menu
Press and hold:
ADMIN
for approximately three seconds.
3. Select
3. Select
EXPORT SCAN LOG
EXPORT SCAN LOG
The scanner searches for an attached USB storage device.
If a USB drive is found, the current scan log is copied to it.
The original spreadsheet remains on the Raspberry Pi.
Exporting does not erase or reset the scanner's records.
DATED EXPORT FILES
DATED EXPORT FILES
Rather than repeatedly overwriting the same file, the scanner creates a dated and time-stamped copy.
For example:
ID_Scan_Log_2026-09-13_2035.csv
A later export might create:
ID_Scan_Log_2026-09-20_1812.csv
This provides a simple archive of when records were retrieved.
EXPORT CONFIRMATION
EXPORT CONFIRMATION
After a successful export, the touchscreen displays:
EXPORT COMPLETE
EXPORT COMPLETE
followed by the name of the file that was created.
For example:
ID_Scan_Log_2026-09-13_2035.csv
The USB drive can then be safely removed and connected to another computer.
The exported CSV can be opened directly in Excel or imported into Google Sheets.
IF NO USB DRIVE IS FOUND
IF NO USB DRIVE IS FOUND
If EXPORT SCAN LOG is selected without a usable USB drive connected, the scanner displays:
USB DRIVE NOT FOUND
USB DRIVE NOT FOUND
No changes are made to the original scan log.
Insert a USB flash drive and try the export again.
THE ORIGINAL LOG STAYS ON THE PI
THE ORIGINAL LOG STAYS ON THE PI
Exporting the spreadsheet creates a copy.
The master log remains:
~/id-scanner/vinland_id_scans.csv
New scans continue to be added to that file.
This means an exported USB copy is a snapshot of the scanner records at the time the export was performed.
REMOVING THE MICROSD CARD
REMOVING THE MICROSD CARD
The microSD card should not normally need to be removed to retrieve scan records.
If it ever does need to be removed for maintenance, the Raspberry Pi must first be shut down using:
ADMIN → SHUT DOWN PI
Wait for the Raspberry Pi to completely shut down before removing the card.
If the card is inserted into a Windows computer and Windows asks to format an unfamiliar partition:
DO NOT FORMAT IT
DO NOT FORMAT IT
Raspberry Pi OS uses a Linux filesystem that Windows does not normally recognize.
Formatting the card could erase the scanner software, operating system, configuration, and stored scan records.
DATA PRIVACY
DATA PRIVACY
Driver's-license barcode information contains personally identifiable information.
Exported spreadsheets should therefore be treated as private records.
USB drives containing scan records should be kept secure, and exported files should only be stored where authorized users have access.
The USB export system is intentionally manual. Simply plugging in a flash drive does not copy anything. An operator must enter the Admin menu and select EXPORT SCAN LOG.
SCAN RECORD WORKFLOW
SCAN RECORD WORKFLOW
The complete record system now works like this:
SCAN ID → DECODE → VERIFY → DISPLAY RESULT → SAVE TO LOCAL LOG
When records are needed:
INSERT USB → HOLD ADMIN → EXPORT SCAN LOG → REMOVE USB → OPEN CSV ON COMPUTER
The Raspberry Pi's operating-system SD card stays safely inside the scanner.
SECTION 17: TOUCHSCREEN ADMIN CONTROLS
SECTION 17: TOUCHSCREEN ADMIN CONTROLS
Operating the Scanner Without a Keyboard
Operating the Scanner Without a Keyboard
The finished scanner is designed to operate as a standalone touchscreen appliance.
During normal use, staff should not need a keyboard, mouse, or Terminal window.
The normal screen remains intentionally simple:
ID AGE VERIFICATION
READY
READY
SCAN DRIVER LICENSE
A small ADMIN button is located in the upper-right corner.
OPENING THE ADMIN MENU
OPENING THE ADMIN MENU
The Admin menu contains functions that should not be activated accidentally during normal scanning.
For that reason, tapping the ADMIN button does nothing.
Instead:
Press and hold ADMIN for approximately three seconds.
The Admin menu will then open.
This helps prevent a customer or accidental touchscreen press from accessing system controls.
ADMIN MENU
ADMIN MENU
The touchscreen Admin menu contains six controls:
VIEW SCAN LOG
VIEW SCAN LOG
Opens the current local scan log:
~/id-scanner/vinland_id_scans.csv
This allows the records to be reviewed directly on the Raspberry Pi.
EXPORT SCAN LOG
EXPORT SCAN LOG
Copies the current scan spreadsheet to an attached USB flash drive.
The scanner automatically creates a dated and time-stamped filename such as:
ID_Scan_Log_2026-09-13_2035.csv
The original log remains on the Raspberry Pi and continues collecting new scans.
If no writable USB drive can be found, the screen displays:
USB DRIVE NOT FOUND
If the export succeeds, it displays:
EXPORT COMPLETE
along with the exported filename.
RESTART SCANNER
RESTART SCANNER
Restarts only the Python scanner application.
The Raspberry Pi itself remains running.
This provides a quick way to reload the scanner software without rebooting the entire computer.
After restarting, the application returns to:
READY
READY
REBOOT PI
REBOOT PI
Restarts the entire Raspberry Pi operating system.
Because rebooting interrupts scanner operation, the software asks for confirmation before proceeding:
REBOOT THE SCANNER?
YES, REBOOT
or
CANCEL
After Raspberry Pi OS restarts, the scanner application automatically launches again because of the autostart configuration created earlier.
SHUT DOWN PI
SHUT DOWN PI
Safely shuts down Raspberry Pi OS.
A confirmation screen prevents accidental shutdown:
SHUT DOWN THE SCANNER?
YES, SHUT DOWN
or
CANCEL
Once the Raspberry Pi has completely shut down, power can safely be disconnected.
This is the normal way the scanner should be powered off.
RETURN TO SCANNER
RETURN TO SCANNER
Closes the Admin menu without restarting anything.
The scanner immediately returns to:
READY
READY
SCAN DRIVER LICENSE
NORMAL DAILY USE
NORMAL DAILY USE
Once everything is configured, staff operation is intentionally simple:
POWER ON → WAIT FOR READY → SCAN ID → READ RESULT
The result remains on the screen for approximately three seconds before automatically returning to READY.
Administrative functions require:
HOLD ADMIN FOR 3 SECONDS → SELECT FUNCTION
And retrieving records becomes:
INSERT USB DRIVE → HOLD ADMIN → EXPORT SCAN LOG → CONFIRM EXPORT COMPLETE → REMOVE USB DRIVE
No command line should be required during normal day-to-day operation.
SECTION 19: TESTING AND FINAL VALIDATION
SECTION 19: TESTING AND FINAL VALIDATION
Commissioning the Finished Scanner
Commissioning the Finished Scanner
Before the scanner is placed into normal use, every major function should be tested.
The goal is to verify the complete system rather than simply confirming that the Python program starts.
The final test covers:
Barcode Reading → AAMVA Decoding → Age Calculation → Expiration Check → Display → Logging → Reset → USB Export → Administration → Startup and Shutdown
TEST 1: STARTUP
TEST 1: STARTUP
Power on the Raspberry Pi.
Do not open Terminal or manually start the scanner.
After Raspberry Pi OS finishes booting, the scanner should automatically appear full screen.
The display should show:
READY
READY
SCAN DRIVER LICENSE
PASS: Scanner launches automatically and reaches READY.
TEST 2: VALID 21+ LICENSE
TEST 2: VALID 21+ LICENSE
Scan a valid, unexpired driver's license belonging to someone age 21 or older.
Expected result:
21+ VERIFIED
21+ VERIFIED
The screen should display the person's calculated age.
The background should turn green.
After approximately three seconds, the scanner should automatically return to:
READY
READY
PASS: Correct age, correct result and automatic reset.
TEST 3: UNDER-21 LICENSE
TEST 3: UNDER-21 LICENSE
When an appropriate test ID is available, scan a valid driver's license belonging to someone under age 21.
Expected result:
UNDER 21
UNDER 21
The person's calculated age should appear underneath.
The background should turn red.
After approximately three seconds:
READY
READY
should return automatically.
PASS: Correct age and UNDER 21 result.
TEST 4: EXPIRED LICENSE
TEST 4: EXPIRED LICENSE
Scan an expired driver's license.
Expected result:
ID EXPIRED
ID EXPIRED
The calculated age should still appear.
The expiration warning takes priority over displaying 21+ VERIFIED.
The background should appear as the expiration-warning color.
After approximately three seconds, the scanner returns to READY.
PASS: Expired license is identified correctly.
TEST 5: BAD OR INCOMPLETE READ
TEST 5: BAD OR INCOMPLETE READ
Attempt a deliberately poor barcode read or test an unreadable barcode.
Expected result:
READ ERROR
READ ERROR
SCAN ID AGAIN
The scanner should not display a successful age verification when it cannot reliably retrieve the date of birth.
After approximately three seconds, it should return to READY.
PASS: Bad data fails safely instead of producing a false verification.
TEST 6: RAPID CONSECUTIVE SCANS
TEST 6: RAPID CONSECUTIVE SCANS
Scan several licenses one after another.
Verify that each complete barcode is processed separately.
The previous result should not contaminate the next scan.
PASS: Each ID produces one independent result.
TEST 7: VERIFY THE SPREADSHEET
TEST 7: VERIFY THE SPREADSHEET
Open the scan log through:
HOLD ADMIN → VIEW SCAN LOG
Verify that each test scan created its own row.
Check several records manually.
Compare the physical license against the recorded:
Name
Date of Birth
Expiration Date
License Number
Address
Issuing State
and other decoded fields.
Also verify:
Calculated Age
Verification Result
Scan Date
Scan Time
The raw AAMVA data should also be present for troubleshooting during development.
PASS: The information displayed and logged matches the test licenses.
TEST 8: TEST DIFFERENT LICENSES
TEST 8: TEST DIFFERENT LICENSES
Do not test only one driver's license.
Different states and different generations of licenses may encode or structure AAMVA data differently.
Whenever possible, test:
Several Texas licenses
and then licenses from:
Other states
The scanner should be considered fully tested only after it has successfully processed a reasonable variety of real licenses.
If a particular license produces READ ERROR, preserve its logged raw AAMVA data so the parser can be improved.
TEST 9: ADMIN BUTTON
TEST 9: ADMIN BUTTON
Quickly tap ADMIN.
Nothing should happen.
Now press and hold ADMIN for approximately three seconds.
The Admin menu should appear.
PASS: A normal accidental tap does not open Admin, while a deliberate hold does.
TEST 10: USB EXPORT WITHOUT A DRIVE
TEST 10: USB EXPORT WITHOUT A DRIVE
Do not connect a USB flash drive.
Select:
EXPORT SCAN LOG
Expected result:
USB DRIVE NOT FOUND
USB DRIVE NOT FOUND
The original spreadsheet should remain unchanged.
PASS: Scanner recognizes that no export device is available.
TEST 11: USB EXPORT
TEST 11: USB EXPORT
Insert a USB flash drive.
Wait several seconds for Raspberry Pi OS to recognize and mount it.
Select:
EXPORT SCAN LOG
A successful export should create a file similar to:
ID_Scan_Log_2026-09-13_203500.csv
If the scanner successfully unmounts the drive, the screen should display:
EXPORT COMPLETE
EXPORT COMPLETE
followed by:
SAFE TO REMOVE USB
SAFE TO REMOVE USB
Only remove the USB drive after receiving the safe-removal message.
Connect the USB drive to another computer and open the exported CSV.
Verify that the records match the original log.
PASS: Spreadsheet is copied intact and can be opened on another computer.
TEST 12: RESTART SCANNER
TEST 12: RESTART SCANNER
From the Admin menu select:
RESTART SCANNER
The Python application should close and immediately restart.
The screen should return to:
READY
READY
The Raspberry Pi itself should not reboot.
PASS: Application restarts independently.
TEST 13: REBOOT
TEST 13: REBOOT
Open Admin and select:
REBOOT PI
The confirmation screen should appear.
Select:
CANCEL
Nothing should happen.
Repeat the test and select:
YES, REBOOT
The Raspberry Pi should reboot.
After Raspberry Pi OS starts again, the scanner should automatically launch and return to READY.
PASS: Confirmation works, Pi reboots, and autostart restores the scanner.
TEST 14: SAFE SHUTDOWN
TEST 14: SAFE SHUTDOWN
Open Admin and select:
SHUT DOWN PI
Verify that the confirmation screen appears.
Select:
YES, SHUT DOWN
The Raspberry Pi should safely shut down.
Wait until shutdown is complete before disconnecting power.
PASS: Scanner can be safely powered down without a keyboard or Terminal.
FINAL OPERATING WORKFLOW
FINAL OPERATING WORKFLOW
Once all tests pass, normal operation is:
START
START
POWER ON → WAIT FOR READY
CHECK AN ID
CHECK AN ID
SCAN → READ RESULT → AUTOMATIC RESET → READY
EXPORT RECORDS
EXPORT RECORDS
INSERT USB → HOLD ADMIN → EXPORT SCAN LOG → SAFE TO REMOVE USB
SHUT DOWN
SHUT DOWN
HOLD ADMIN → SHUT DOWN PI → CONFIRM → WAIT → DISCONNECT POWER
PROJECT COMPLETE
PROJECT COMPLETE
The finished device is a standalone Raspberry Pi driver's-license age verification scanner built around a PDF417 barcode reader and touchscreen interface.
It can:
Read driver's-license PDF417 barcodes
Decode common AAMVA information
Calculate age automatically
Identify under-21 customers
Detect expired IDs
Display a clear result
Maintain a local scan spreadsheet
Export records to USB
Operate from a touchscreen
Start automatically
Restart itself
Reboot the Raspberry Pi
Safely shut itself down
The system is intentionally designed so that normal operation requires no keyboard, mouse, Terminal commands, or internet connection.
Important Limitation
Important Limitation
This device is an age-verification and barcode-reading aid, not an ID authentication system.
It reads information encoded in the PDF417 barcode and performs calculations using that information. It does not contact a state licensing agency, confirm that an ID is currently valid in a government database, detect every counterfeit or alteration, or replace the judgment and legal responsibilities of the person checking identification.
Build started: 2026
Status: Ready for hardware installation and field testing.
Page updated
Google Sites
Report abuse