Benvenuto nella guida utente del Lettore/Scrittore di Carte MSR605! Questo documento ti aiuterà a iniziare a utilizzare l’applicazione per leggere e scrivere su carte a striscia magnetica.
pip install -r requirements.txt
python main.py
L’applicazione supporta due standard principali per le carte magnetiche: ISO 7811 e ISO 7813. Comprendere questi formati è fondamentale per eseguire correttamente le operazioni di lettura e scrittura.
ISO 7811 è lo standard internazionale per le carte di identificazione con strisce magnetiche. Definisce:
%[codice formato][numero conto primario]^[nome]^[data scadenza][codice servizio][dati discrezionali]?%B1234567890123456^INTESTATARIO/NOME^24011234567890123456789?;[numero conto primario]=[data scadenza][codice servizio][dati discrezionali]?;1234567890123456=24011234567890123456?ISO 7813 è un sottoinsieme di ISO 7811 specifico per le carte di transazione finanziaria. Differenze chiave:
%B1234567890123456^INTESTATARIO/NOME^24011234567890123456789?;1234567890123456=24011234567890123456?Questo documento fornisce informazioni dettagliate sull’API del Lettore/Scrittore di Carte MSR605 per gli sviluppatori che desiderano estendere o integrare l’applicazione.
L’API MSR605 fornisce un’interfaccia Python per interagire con i lettori/scrittori di carte a striscia magnetica. L’API è progettata per essere facile da usare fornendo al contempo accesso a tutte le funzionalità del dispositivo.
msr605Il modulo principale che contiene le funzionalità di base.
MSR605class MSR605:
def __init__(self, port=None, baudrate=9600, timeout=1):
"""Inizializza la connessione al dispositivo MSR605.
Args:
port (str, opzionale): Nome della porta seriale. Se None, tenta il rilevamento automatico.
baudrate (int, opzionale): Velocità di trasmissione. Predefinita a 9600.
timeout (int, opzionale): Timeout di lettura in secondi. Predefinito a 1.
"""
pass
def connect(self):
"""Stabilisce la connessione al dispositivo."""
pass
def disconnect(self):
"""Chiude la connessione al dispositivo."""
pass
def is_connected(self):
"""Verifica se il dispositivo è connesso.
Returns:
bool: True se connesso, False altrimenti.
"""
pass
def read_card(self, tracks=[1, 2, 3]):
"""Legge i dati da una carta a striscia magnetica.
Args:
tracks (list, opzionale): Lista delle tracce da leggere (1, 2, 3). Predefinito: tutte le tracce.
Returns:
dict: Dizionario contenente i dati delle tracce con i numeri di traccia come chiavi.
"""
pass
def write_card(self, track_data, verify=True):
"""Scrive i dati su una carta a striscia magnetica.
Args:
track_data (dict): Dizionario con i numeri di traccia come chiavi e i dati come valori.
verify (bool, opzionale): Se verificare i dati scritti. Predefinito a True.
Returns:
bool: True se la scrittura è andata a buon fine, False altrimenti.
"""
pass
| Comando | Descrizione | Formato |
|———|————-|———|
| ESC e | Reimposta il dispositivo | \x1be |
| ESC s | Leggi carta | \x1bs |
| ESC w | Scrivi carta | \x1bw |
| ESC x | Imposta livello di sicurezza | \x1bx |
| Risposta | Descrizione |
|———-|————-|
| \x1b1 | Comando eseguito con successo |
| \x1b2 | Comando fallito |
| \x1b3 | Nessuna carta presente |
| \x1b4 | Errore protezione scrittura |
from msr605 import MSR605
# Inizializza e connetti al dispositivo
device = MSR605()
device.connect()
# Leggi tutte le tracce
data = device.read_card()
print(f"Traccia 1: {data.get(1, 'Nessun dato')}")
print(f"Traccia 2: {data.get(2, 'Nessun dato')}")
print(f"Traccia 3: {data.get(3, 'Nessun dato')}")
# Leggi tracce specifiche
data = device.read_card(tracks=[1, 2])
# Disconnetti
device.disconnect()
from msr605 import MSR605
# Inizializza e connetti al dispositivo
device = MSR605()
device.connect()
# Prepara i dati delle tracce
track_data = {
1: "%B1234567890123456^INTESTATARIO/NOME^25121010000000000000000000000000000?",
2: ";1234567890123456=25121010000000000000?",
3: "" # Traccia 3 vuota
}
# Scrivi sulla carta
success = device.write_card(track_data)
print(f"Scrittura {'riuscita' if success else 'fallita'}")
# Disconnetti
device.disconnect()
| Carattere | Descrizione |
|———–|————-|
| % | Carattere di inizio (Traccia 1) |
| ; | Carattere di inizio (Tracce 2 e 3) |
| ? | Carattere di fine |
| ^ | Separatore (Traccia 1) |
| = | Separatore (Traccia 2) |
| \\ | Carattere di escape |
| Eccezione | Descrizione |
|———–|————-|
| MSR605Error | Eccezione di base per tutti gli errori MSR605 |
| MSR605ConnectionError | Errori relativi alla connessione |
| MSR605CommandError | Errori di esecuzione comandi |
| MSR605CardError | Errori nelle operazioni sulla carta |
from msr605 import MSR605, MSR605Error
try:
device = MSR605()
device.connect()
data = device.read_card()
print(data)
except MSR605Error as e:
print(f"Errore: {e}")
finally:
if 'device' in locals():
device.disconnect()
from msr605 import MSR605
def main():
try:
# Inizializza e connetti
device = MSR605()
print("Connessione al dispositivo in corso...")
device.connect()
if not device.is_connected():
print("Impossibile connettersi al dispositivo")
return
print("Connesso. Passa una carta...")
# Leggi la carta
data = device.read_card()
print("\nDati Carta:")
for track, value in data.items():
print(f"Traccia {track}: {value}")
except Exception as e:
print(f"Si è verificato un errore: {e}")
finally:
if 'device' in locals():
device.disconnect()
print("\nDisconnesso dal dispositivo")
if __name__ == "__main__":
main()
from msr605 import MSR605
import json
import time
class GestoreCarte:
def __init__(self):
self.device = MSR605()
self.config = self._carica_configurazione()
def _carica_configurazione(self):
# Carica la configurazione da file
try:
with open('config.json', 'r') as f:
return json.load(f)
except FileNotFoundError:
return {'baudrate': 9600, 'timeout': 1}
def avvia(self):
try:
# Connetti con configurazione
self.device = MSR605(
baudrate=self.config.get('baudrate', 9600),
timeout=self.config.get('timeout', 1)
)
self.device.connect()
while True:
# Aspetta che venga inserita una carta
print("Inserisci una carta (premi Ctrl+C per uscire)...")
data = self.device.read_card()
if data:
print("\nDati letti:")
for track, value in data.items():
print(f"Traccia {track}: {value}")
# Elabora i dati della carta qui
self._elabora_dati_carta(data)
time.sleep(1)
except KeyboardInterrupt:
print("\nInterruzione da tastiera ricevuta.")
except Exception as e:
print(f"Errore: {e}")
finally:
self.device.disconnect()
print("Disconnesso dal dispositivo")
def _elabora_dati_carta(self, dati):
"""Elabora i dati della carta letta."""
# Implementa qui la logica di elaborazione
pass
if __name__ == "__main__":
gestore = GestoreCarte()
gestore.avvia()