轨道磁卡读写程序含源码：从读卡到写卡与避坑指南-育师

简介：这份资源是面向.NET、VB、VC开发者的23轨道磁卡读写程序及完整源码，适合金融、交通、门禁等领域的初学者与进阶人员学习磁卡数据读取、解析与写入的底层实现。压缩包为rar格式，共113个文件、约10.28MB，包含exe可执行程序、dll动态库、h头文件、cpp与cs源码、doc说明文档、sln解决方案及vbp、bas等工程文件，覆盖VB、VC与.NET多语言示例，便于对照学习与二次开发。目前已有311人学习下载。资源以“学习专用案例”形式提供，源码开放，读者可深入每个功能模块，理解磁卡硬件交互、数据编码与错误处理机制，并借助动态库实现代码复用，为实际项目开发与技能提升提供可参考的实践素材。

1. 轨道磁卡读写程序含源码：从一张旧门禁卡说起

手里有一张老式门禁卡，磁条上只有三个轨道，其中第 2 轨被写入了卡号、有效期和校验位。想把它读出来、改掉、再写回去，靠的不是什么高深设备，而是一段几十行的轨道磁卡读写程序。这类程序的核心就三件事：解析 F2F 编码、按 ISO/IEC 7811 的字符集还原数据、再按 LRC 校验决定要不要信任这一串比特。标题里的“含源码”意味着它不是黑盒工具，你能看到每一位是怎么被解出来的，也能改参数去适配不同厂家的读卡器。适合谁？做门禁考勤二次开发的人、维护老旧会员系统的工程师、以及想搞懂磁条卡底层格式的嵌入式新手。下面我按“先跑通读卡、再改写入、最后避坑”的顺序，把能抄作业的代码和参数都摊开。

2. 轨道磁卡的数据格式与最小读卡链路

2.1 三条轨道各存什么，为什么第 2 轨最常被折腾

磁条卡按 ISO/IEC 7811 分成三条物理轨道。第 1 轨用 210 bpi 的密度，字符集是 6 位编码，能存字母和数字，常见于航空里程卡；第 2 轨密度 75 bpi，字符集是 5 位编码，只支持数字和少数控制符，门禁、考勤、会员卡几乎都写在这条；第 3 轨密度也是 210 bpi，但很多读卡器干脆不接。第 2 轨之所以被折腾得最多，是因为它的 5 位编码简单、校验规则清晰，而且大多数 USB 磁条读卡器默认只输出第 2 轨。

第 2 轨的字符集里，数字 0-9 对应 5 位值 00000 到 01001，控制符像起始符、结束符、分隔符各有固定编码。整条数据以起始符开头、结束符收尾，中间用分隔符隔开主账号、有效期、服务码等字段。读卡器解出来的原始比特流，必须按这个字符集反查，才能变成人能看懂的字符串。很多新手拿到一串十六进制就懵，其实只是没做这层映射。

2.2 用 Python 把读卡器原始输出还原成第 2 轨字符串

假设读卡器通过串口吐出一串十六进制，代表已经做过 F2F 解码后的比特流。下面这段代码做三件事：把十六进制转成比特串、按 5 位一组切分、查表还原字符并校验 LRC。

# track2_decode.py # 输入：读卡器输出的十六进制字符串，例如 "3B363738393A3B3C3D3E3F" # 输出：第 2 轨可读字符串，或抛出校验失败 TRACK2_TABLE = { 0b00000: '0', 0b00001: '1', 0b00010: '2', 0b00011: '3', 0b00100: '4', 0b00101: '5', 0b00110: '6', 0b00111: '7', 0b01000: '8', 0b01001: '9', 0b01010: ':', 0b01011: ';', 0b01100: '<', 0b01101: '=', 0b01110: '>', 0b01111: '?', 0b10000: ' ', # 部分读卡器用 0x10 表示填充 } def hex_to_bits(hex_str): """把十六进制字符串转成 '0'/'1' 比特串""" bits = '' for ch in hex_str.strip(): bits += format(int(ch, 16), '04b') return bits def decode_track2(hex_str): bits = hex_to_bits(hex_str) # 第 2 轨每 5 位一个字符，末尾可能补零，先按 5 位切 chars = [] for i in range(0, len(bits) - 4, 5): chunk = bits[i:i+5] val = int(chunk, 2) if val not in TRACK2_TABLE: raise ValueError(f"非法 5 位编码: {chunk}") chars.append(TRACK2_TABLE[val]) raw = ''.join(chars) # 起始符 ';' 和结束符 '?' 之间才是有效数据 start = raw.find(';') end = raw.find('?') if start == -1 or end == -1 or end <= start: raise ValueError("未找到起始符或结束符") payload = raw[start+1:end] # LRC 校验：把起始符到结束符之间所有字符的 5 位值异或 lrc = 0 for ch in raw[start:end]: lrc ^= ord(ch) & 0x1F # 取低 5 位 if lrc != 0: raise ValueError(f"LRC 校验失败，异或结果={lrc}") return payload if __name__ == '__main__': sample = "3B363738393A3B3C3D3E3F" print(decode_track2(sample))

逻辑说明：hex_to_bits把每个十六进制字符展开成 4 位，拼成完整比特流；decode_track2按 5 位一组查表，遇到非法编码直接报错，避免把噪声当数据。LRC 校验用异或，正确时结果应为 0，这是第 2 轨最常用的校验方式。参数上，TRACK2_TABLE里的0b10000映射到空格是经验做法，有些读卡器用0b11111做填充，遇到校验失败可以先打印原始比特串确认填充位。

2.3 读卡器选型与串口参数：别在波特率上翻车

常见做法是选 USB HID 键盘口读卡器，插上就能当键盘输入，但这种方式拿不到原始比特，只能拿到已经解码的字符串，做二次开发很受限。要拿原始数据，得选串口输出或 USB 虚拟串口的型号，驱动装好后在设备管理器里能看到 COM 口。串口参数一般是 9600 波特率、8 数据位、无校验、1 停止位，但不同厂家会改，我一般先用 9600 试，读出来是乱码就换 19200 或 38400。

读卡器上电后通常需要先发一条使能命令才会吐数据，有的型号是发0x1B加0x73，有的直接上电就持续输出。判断方法很简单：打开串口助手，不发送任何东西，看有没有数据进来；没有就翻手册找使能指令。这一步卡住的人不少，以为是程序问题，其实是读卡器在等命令。

3. 写入第 2 轨：编码、LRC 与写卡器时序

3.1 把字符串编回 5 位比特流并算 LRC

写入是读取的逆过程：先把字符串按字符集映射成 5 位值，拼成比特流，再算 LRC 追加在结束符之前，最后交给写卡器做 F2F 编码。下面这段代码把第 2 轨字符串编成十六进制，方便直接发给写卡器。

# track2_encode.py # 输入：第 2 轨数据字符串，例如 "1234567890123456=2512101000000000" # 输出：带起始符、结束符和 LRC 的十六进制字符串 TRACK2_REVERSE = {v: k for k, v in { 0b00000: '0', 0b00001: '1', 0b00010: '2', 0b00011: '3', 0b00100: '4', 0b00101: '5', 0b00110: '6', 0b00111: '7', 0b01000: '8', 0b01001: '9', 0b01010: ':', 0b01011: ';', 0b01100: '<', 0b01101: '=', 0b01110: '>', 0b01111: '?', }.items()} def encode_track2(payload): """payload 不含起始符和结束符，例如 '1234=2512'""" raw = ';' + payload + '?' bits = '' lrc = 0 for ch in raw: if ch not in TRACK2_REVERSE: raise ValueError(f"字符 {ch} 不在第 2 轨字符集内") val = TRACK2_REVERSE[ch] bits += format(val, '05b') lrc ^= val # LRC 本身也要写入，占 5 位 bits += format(lrc, '05b') # 补齐到 4 的倍数，方便转十六进制 while len(bits) % 4 != 0: bits += '0' hex_out = '' for i in range(0, len(bits), 4): hex_out += format(int(bits[i:i+4], 2), 'x') return hex_out.upper() if __name__ == '__main__': print(encode_track2("1234567890123456=2512101000000000"))

逻辑说明：TRACK2_REVERSE是字符到 5 位值的反查表，encode_track2先拼出带起始符和结束符的完整串，逐字符累加异或得到 LRC，再把 LRC 追加到比特流末尾。补齐到 4 的倍数是为了转十六进制时不丢位。参数上，payload里的=是分隔符，前面是主账号，后面是有效期和服务码，具体字段长度由你的业务定，但总长度别超过第 2 轨的容量上限，一般 40 个字符左右。

3.2 写卡器的命令格式与超时重试

写卡器一般用串口命令控制，常见格式是“命令字 + 数据长度 + 数据 + 校验”。不同厂家命令字不同，但套路相似：先发写命令，再发数据，最后等一个字节的应答。应答是0x30表示成功，0x31表示失败。写卡比读卡慢，因为要驱动磁头做 F2F 编码，一次写入通常 200 到 500 毫秒，超时设 1 秒比较稳。

我一般会封装一个带重试的写函数：失败就重发，最多三次。重试之间加 100 毫秒延时，让磁头复位。如果三次都失败，先别怀疑程序，拿一张已知能写的卡试，排除卡本身磁条损坏。写卡器对卡的位置很敏感，手动刷卡的速度和力度都会影响成功率，这也是为什么很多产线用自动刷卡机。

3.3 写入前后的校验闭环

写完必须读回来校验，不能写完就完事。校验分两层：第一层是读回来的字符串和写入的是否一致；第二层是 LRC 是否通过。两层都过才算成功。有些写卡器写完会自己回读并返回结果，但别全信，自己再读一遍最踏实。下面是一个校验闭环的伪代码结构：

def write_and_verify(port, payload, retries=3): for attempt in range(retries): hex_data = encode_track2(payload) resp = send_write_command(port, hex_data, timeout=1.0) if resp != 0x30: continue readback = read_track2(port) if readback == payload: return True return False

逻辑说明：send_write_command负责拼命令和发数据，read_track2复用第 2 章的读卡逻辑。参数上，retries设 3 是经验值，再多会拖慢产线节拍；timeout设 1 秒是因为写卡器偶尔会卡在机械动作上，太短会误判失败。

4. 避坑与排查：轨道磁卡读写最常见的 5 个翻车点

4.1 读出来全是乱码，先查波特率和字符集

现象：串口助手能看到数据，但解出来是乱码或非法编码。原因通常是波特率不匹配，或者读卡器输出的是第 1 轨数据而你按第 2 轨解。解决：先用示波器或逻辑分析仪看波形，确认波特率；再确认读卡器型号默认输出哪条轨道，有的型号可以通过命令切换轨道。如果读卡器输出的是已经解码的 ASCII，那就别做 5 位查表，直接当字符串处理。

4.2 LRC 校验总失败，检查起始符和结束符是否被截断

现象：数据看着对，但 LRC 异或结果不是 0。原因多半是比特流开头或结尾多了填充位，或者起始符被读卡器吃掉了。解决：打印原始比特串，手动找;和?对应的 5 位编码，确认边界。如果读卡器输出时把起始符去掉了，那 LRC 计算范围要相应调整，以实际读到的第一个字符为起点。

4.3 写卡成功但刷卡没反应，可能是 coercivity 不匹配

现象：写卡器返回成功，但拿到门禁上刷不开。原因是磁条卡的矫顽力分高抗和低抗两种，写卡器的写电流要匹配。低抗卡用高抗写电流会写坏，高抗卡用低抗写电流写不进去。解决：确认卡的类型，换对应写卡器，或者调整写卡器的写电流参数。这个坑很隐蔽，因为写卡器自己回读是能读出来的，但门禁读卡器的读头参数不同。

4.4 第 2 轨长度超限导致写入截断

现象：写入长字符串时，末尾几位丢失。原因是第 2 轨物理容量有限，按 75 bpi 密度，标准卡最多约 40 个字符。解决：精简字段，把不必要的信息去掉；或者改用第 1 轨和第 3 轨分担数据。如果业务必须写长数据，考虑换芯片卡，磁条卡不适合。

4.5 多张卡连续写入时串口缓冲区溢出

现象：连续写卡时，第二张开始失败率升高。原因是串口缓冲区没清空，上一张的应答还留在里面。解决：每次写卡前先读空缓冲区，或者用带流控的串口模式。我一般会在写命令前加一个flush_input操作，把残留数据丢掉再发新命令。

5. 进阶：用校验和反推字段与批量写卡的节拍控制

5.1 从 LRC 反推被改动的字段

有时候拿到一张卡，不知道哪个字段被改过，但知道原始数据。这时可以逐字符替换，重新算 LRC，看哪个替换能让校验通过。更快的办法是：把原始数据和当前数据都解成 5 位值数组，逐位异或，异或结果非零的位置就是被改动的位。这个方法在排查“卡被复制过”时很好用，因为复制卡往往只改了主账号，LRC 没重算，一读就露馅。

5.2 批量写卡的节拍控制与失败隔离

产线上批量写卡，最怕一张失败卡住整条线。我的做法是：每张卡独立一个事务，失败就记录卡号并跳过，不阻塞后续。节拍上，写一张卡约 300 毫秒，读回校验约 200 毫秒，加上重试余量，单张控制在 800 毫秒以内比较稳。如果节拍要求更高，可以并行开两个写卡器，但要注意串口资源冲突。

下面是一个批量写卡的节拍控制示例，用队列和超时隔离失败：

import time from collections import deque def batch_write(port, payloads, per_card_timeout=0.8): results = {} for idx, payload in enumerate(payloads): start = time.time() ok = write_and_verify(port, payload, retries=2) elapsed = time.time() - start results[idx] = ok if elapsed > per_card_timeout: # 超时说明写卡器可能卡住，发复位命令 send_reset(port) time.sleep(0.05) # 卡间最小间隔 return results

逻辑说明：per_card_timeout设 0.8 秒，超过就发复位命令，避免写卡器机械卡死。time.sleep(0.05)是卡间最小间隔，给磁头复位留时间。参数上，retries在批量场景降到 2，因为产线更看重节拍，单张失败可以后面补写。