Project Files of EM18 RFID Library for Proteus V1.1 (125 kHz Reader + Arduino)

EM-18 RFID READER (125 kHz) LIBRARY FOR PROTEUS - V1.1
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/09/em18-rfid-proteus-library.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/em18-proteus-library
The demo uses our TEP Serial Monitor Advance (included) instead of Proteus's
Virtual Terminal - its own article:
  https://www.theengineeringprojects.com/2026/10/serial-monitor-advance-proteus-library.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
EM18-TEP-v1.1/
|-- Proteus Library Files/
|   |-- ArduinoV3TEP.IDX                              0.8 KB   its index -> LIBRARY folder
|   |-- ArduinoV3TEP.LIB                             95.6 KB   TEP Arduino UNO (demo) -> LIBRARY folder
|   |-- TEPEM18.LIB                                  82.8 KB   EM18 Simple + Advance (2 devices) -> LIBRARY folder
|   |-- TEPSERIALMON.LIB                             11.1 KB   TEP Serial Monitor Advance -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPEM18.DLL                                 334.0 KB   EM-18 model -> MODELS folder
|   |-- TEPSERIALMON.DLL                            978.0 KB   Serial Monitor model -> MODELS folder
|-- Proteus Simulation/
|   |-- EM18_Demo.hex                                22.1 KB   both UNOs (access control v1.1)
|   |-- EM18-ArduinoUnoV3.pdsprj                     25.5 KB   demo: UNO 1 + EM18 Simple, UNO 2 + Advance
|   |-- TEPEM18.DLL                                 334.0 KB   copy of the model so the demo runs as is
|   |-- TEPSERIALMON.DLL                            978.0 KB   copy of the monitor model
|-- Arduino Code/
|   |-- EM18_Demo/EM18_Demo.ino                       9.2 KB   sketch (source of the .hex)
|   |-- libraries/AltSoftSerial/                     30.1 KB   AltSoftSerial 1.4 (MIT, LICENSE.txt), 11 files
|-- README.txt                                      ~32.0 KB   this file
Total: 2.86 MB (unzipped). The C++ source code of the model is not included.

WHAT IS IT?
A simulation model of the EM-18 125 kHz RFID reader module for Proteus 8. Your
Arduino reads it exactly like the real one: the reader sends the tag's number on
TX as 12 ASCII characters at 9600 baud (8N1) - the 10 hex digits of the tag's ID
and 2 hex digits of their XOR checksum - or, with SEL LOW, as a Wiegand-26 frame
on D0 / D1; its BEEP pin goes LOW on every read. EM4100 cards and EM4102 keyfobs
are read like real ones: they need a few EM4100 frames in the 125 kHz field
before the reader has their ID (about 70 - 100 ms close to the reader), they are
read only inside the read range (a card up to 10 cm, a keyfob up to 5 cm), and a
tag is sent ONCE each time it is presented - it has to leave the field before it
is read again. The RDM6300 format of v1.0 (0x02 ... 0x03, sent again every 65 ms
while the tag stays) is still there. You put tags on the reader with a click, at
a distance you choose.
The part looks like the real module - the black 32 x 32 mm EM-18 block with
"EM-18 READER MODULE" in white - with its integrated 125 kHz coil drawn as an
x-ray ring that glows while the simulation runs: cyan = the field is on, amber =
the reader is reading a tag, green = the tag was sent; waves above the module
follow, and the tag on the reader is drawn on the module (a card or a keyfob,
its ID, its distance, its state). On the board's edge: a red PWR LED, a green
BEEP LED and a buzzer whose sound arcs light up on every read (TEP additions:
the real EM-18 has no LEDs - its data sheet's application circuit drives a
buzzer and an LED from the BEEP pin, which is what these show).

TWO DEVICES IN ONE LIBRARY (search "EM18" or "RFID" in Pick Devices):
  EM18 Simple    device EM18TEP     "EM-18 RFID Reader Module - Simple"
                 On-Sheet Panel: a tag panel on the schematic next to the
                 reader - the reader's state, TAG 1 .. TAG 4 (click one to tap
                 it on the reader for 0.5 s at the DISTANCE property's distance;
                 click it again to tap it again), REMOVE TAG and the last frames
                 the reader sent. The red X in the panel's header closes it, the
                 PANEL button on the board opens it again. Your v1.0 designs keep
                 working with this device.
  EM18 Advance   device EM18ADVTEP  "EM-18 RFID Reader Module - Advance"
                 Pop-Up Panel: only the reader on the schematic; at Run a TEP
                 pop-up window opens - the same look as the TEP Serial Monitor
                 (move it by its header, resize it, minimise it). The tabs Tags
                 and Test sit in the header; the gear and ? icons open Settings
                 and Help; the palette icon switches the theme:
                   Tags      the tag wallet: the READER card (field, output, the
                             tag in the field and its state, reads and the last
                             ID), the distance (1 - 12 cm) for Tap / Hold, the four
                             tags with Tap (0.5 s) and Hold (until removed), Remove
                             the tag (a held tag moves with the distance - take it
                             out of range and back in to read it again), and an
                             editor: the tag's kind (card / keyfob), its 10-digit
                             ID typed with a hex keypad (or Random), its checksum
                             (OK, or Bad - a damaged checksum for testing your
                             sketch), Apply; "what the reader sends for it" (the
                             12 characters, the checksum worked out, the bytes, the
                             Wiegand-26 bits with facility code and card number);
                             the last frames with their read times
                   Test      four tools measured on the model while your sketch
                             runs: Read test, Range, Frame check, Output check (see
                             THE TEST TOOLS below)
                   Settings  theme (TEP Dark / Light), text size, open at Run,
                             window size - remembered for your Windows user
                   Help      Help & Support like the TEP Serial Monitor: report a
                             bug, suggest a feature, article, user guide, updates,
                             donate, website, forum; Copy diagnostics (reader,
                             tags, counters, test results) for a bug report
                 The OPEN PANEL button on the board opens the window again after
                 you close it.
Both devices use the same model (TEPEM18.DLL) and the same properties.

NEW IN V1.1
* Two devices: EM18 Simple (tag panel on the sheet, close / open) and EM18
  Advance (pop-up window with the tag wallet and editor, four test tools,
  settings and help) - see above.
* Board: the real EM-18's look (the black potted square module) with the coil
  glow (cyan / amber / green), waves above the module, the tag drawn on the
  module, a PANEL / OPEN PANEL button and a SIMPLE / ADVANCE badge.
* Board - PWR LED, BEEP LED and buzzer (TEP additions; the real EM-18 module has
  no LEDs): the red PWR LED is lit while VCC / GND are powered; the green BEEP
  LED is lit while the BEEP pin is LOW (at least 0.35 s, so every read is a
  visible blink) and the buzzer's sound arcs light up with it.
* New pins SEL, D0, D1 (the real module's pins 6, 9, 8) after VCC GND BEEP TX,
  which keep their v1.0 order and places: SEL HIGH = UART on TX, SEL LOW =
  Wiegand-26 on D0 / D1, SEL open = the OUTPUT property (default UART).
* Model - read time: a tag in the field needs 2 ms to power up, then the reader
  waits for the next EM4100 frame header (0 - 32.8 ms) and reads two identical
  64-bit frames (32.8 ms each, at 125 kHz / 64); then READ_DELAY (20 ms) and the
  12 bytes (12.5 ms at 9600). A tag at 2 cm: the first byte 88 - 120 ms after the
  tap. v1.0 sent the frame 20 ms after the click. A tap shorter than the read
  time is not read (about 70 ms - the Read test shows it).
* Model - range: a card is read up to RANGE cm (default 10 - the data sheet's
  "up to 100 mm, depending on tag"), a keyfob up to half of that; near the edge
  of the range the signal is weak and the reader needs 3 or 4 frames (read time
  up to about 165 ms). Out of range = no read.
* Model - one read per presentation: the EM-18 sends a tag once and then waits
  until it leaves the field (v1.0 sent once per click, which is the same for
  taps; a held tag now stays read). RDM6300 format: the frame again every 65 ms
  while the tag stays (the real RDM6300).
* Model - Wiegand-26: even parity, facility code (ID byte 3), card number (ID
  bytes 4 - 5), odd parity; each bit a LOW pulse of 100 us on D0 (0) or D1 (1),
  1 ms apart - 26 ms for the frame.
* Model - tags: EM4100 cards and EM4102 keyfobs (property TYPEn); a tag ID with
  12 hex digits carries the checksum to send (a wrong one = a damaged-checksum
  tag, for testing); BEEP LOW for BEEP_MS at the first byte of every read.
* The demo uses AltSoftSerial on D8 (v1.0: a polled receiver on A4) and the TEP
  Serial Monitor Advance instead of the Virtual Terminal - one monitor per
  Arduino (U3 = UNO 1, U4 = UNO 2) with quick buttons; each monitor's RXD2 shows
  the reader's raw frames (RX2) - and it shows both styles: UNO 1 with EM18
  Simple, UNO 2 with EM18 Advance, an access LED on A0 of each UNO.
* The demo sketch (v1.1) keeps every v1.0 line and adds: the access LED (3 s on
  ACCESS GRANTED), an allowed list you change from the Serial Monitor (ADD /
  DEL, with or without an ID), STATUS (reads, checksum errors, beeps counted on
  D12, the D8 line check, the list), HELP, and a 0.3 s repeat filter for the
  RDM6300 format. The v1.0 "[status]" line every 10 s is gone (it filled the
  monitor): its D8 check is now part of STATUS, plus ONE warning if D8 idles
  LOW (a wiring fault).
* Version 1.1 everywhere; the C++ source code is no longer included (and
  neither is the Arduino AVR core archive - its GitHub link is below).

TEST STATUS
v1.1 was tested in Proteus 8.5 (7 Oct 2026) with this package's demo: both
Serial Monitors and the Advance pop-up open at Run (no system caption row), the
start lines; U1 (Simple): TAG 1 - the coil amber then green, the BEEP LED and
buzzer arcs, 5400A1B2C384 on RX2, ACCESS GRANTED; TAG 3 (keyfob) DENIED -> ADD
-> GRANTED -> DEL, STATUS; the red X and PANEL. U2 (Advance): Hold TAG 2 read
once, at 12 cm no read, at 2 cm read; TAG 4 with Sum = Bad -> CHECKSUM ERROR;
Read test 5 / 5 (decoded 84.6 ms, the ID in the Arduino 117.1 ms on average),
Range (a card up to 10 cm, 3 - 4 frames near the edge), Frame check (84 / 84,
104.17 us), Output check (Wiegand D0 15 / D1 11, facility 161, card 45763, both
parities OK, BEEP 100 ms); Settings, Help (8 live cards), close and OPEN PANEL.
After that test the demo sketch's "[status]" line every 10 s was removed (the
D8 check is now in STATUS, plus a one-time wiring warning) - PC-tested; the
model and the board are unchanged.
PC tests:
  1244 automatic checks on a PC, 0 failed: 91 on the reader model
  (the 16 of the v1.0 test, unchanged, run through the Proteus model on a design
  with the v1.0 symbol - the printed v1.0 results turned into checks - plus the
  v1.1 read time, one read per presentation, RDM6300 repeats, range, missed
  taps, Wiegand-26 bits / parity / timing, SEL, the damaged checksum, BEEP, baud
  and the four tools); 33 with the real v1.1 demo sketch on two simulated UNOs
  (AltSoftSerial decoding the TX pin bit by bit: the v1.0 output lines, the
  LED, every Serial Monitor command, the beep counter, the D8 check and its
  one-time warning, no periodic lines, CHECKSUM ERROR, a held
  tag read once, RDM6300 repeats filtered, SEL LOW, the Read test); 90 on the
  complete Proteus model (a v1.0 symbol, both devices, the red X / PANEL, the
  pop-up and its Tags page, the board's LEDs / coil / tag, the properties, SEL /
  D0 / D1 / BEEP pins, power, the tools through the pop-up, all 8 Help links);
  1030 on the rendered boards and pop-up windows (every page fits in TEP Dark and
  Light, at Large text and 150 % DPI; every tool's hint lines fit the window).
v1.0: the v1.0 demo was opened and run in Proteus 8.5 on 29 Sep 2026 (Proteus
  wrote its workspace file with the Virtual Terminal window); no other record of
  a v1.0 Proteus test exists.

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPEM18.LIB with both devices,
   TEPSERIALMON.LIB and the TEP Arduino UNO V3 library ArduinoV3TEP.LIB / .IDX
   used by the demo) to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\
   LIBRARY - use the folder that already holds Proteus's own .LIB files).
3. Copy TEPEM18.DLL and TEPSERIALMON.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
4. Updating from v1.0: replace TEPEM18.LIB and TEPEM18.DLL, and delete
   TEPEM18.IDX if there is one in the LIBRARY folder. A v1.0 design keeps its
   v1.0 symbol: it runs with the new model (with the v1.1 read time) and shows
   the v1.0 panel (without the v1.1 board parts and the red X) - re-pick the part
   to get the v1.1 symbol.
5. Start Proteus. In Pick Devices (P) search "EM18": you get the Simple and the
   Advance device (category Sensors > RFID).

RUN THE DEMO
"Proteus Simulation\EM18-ArduinoUnoV3.pdsprj" - keep the .hex file and the two
DLLs beside the project. Both UNOs run EM18_Demo.hex.
  UNO 1 (ARD1): EM18 Simple (U1) and Serial Monitor U3.
  UNO 2 (ARD2): EM18 Advance (U2) and Serial Monitor U4.
  An LED (D1 / D2) with 220 ohm on A0 of each UNO: the access LED.
  1. Press Run. Both monitor windows open (9600 baud) and so does U2's pop-up.
     The monitors show "TEP EM-18 RFID Reader Demo v1.1", "Authorised:
     5400A1B2C3, 5400D4E5F6", "Click a card on the reader panel..." and the
     command list. Both coils turn cyan: the 125 kHz field is on.
  2. U1: click TAG 1 on the panel beside the reader - the coil turns amber while
     the reader reads the card, then green; the BEEP LED blinks; U3 prints
     "Read #1  Tag: 5400A1B2C3  -> ACCESS GRANTED" and LED D1 lights for 3 s.
     U3 also shows the raw frame on RX2 (amber): 5400A1B2C384. The raw frames on
     RX2 have no line ending - the EM-18 sends none - so the monitor shows the
     first one with the RX2 tag and the next ones as continuation rows.
     TAG 3 and TAG 4 (keyfobs) are denied. REMOVE TAG takes the tag away.
     Close the panel with its red X and open it with PANEL on the board.
  3. U3 / U4 quick buttons: STATUS, ADD (allow the last tag read - read TAG 3,
     ADD, read it again: granted), DEL (remove it again), HELP. Type ADD
     1A00ABCDEF to allow a tag by its ID.
  4. U2 (Advance): Tags page - Tap / Hold the tags and watch the READER card;
     choose 12 cm and Hold a tag: OUT OF RANGE (drawn dimmed); choose 2 cm: it
     is read. Click TAG 4 to edit it: type a new ID with the keypad, set Sum to
     Bad, Apply, Tap it - U4 prints "-> CHECKSUM ERROR". Test page:
       Read test: tag 1, 0.5 s, 5 runs - each tap is read 90 - 120 ms after the
         tap; try 0.08 s taps: some are missed (the reader needs about 70 ms).
       Range: a card is read up to 10 cm (amber bars = 3 - 4 frames near the
         edge), a keyfob up to 5 cm.
       Frame check: the 12 characters decoded from the TX pin, the checksum
         worked out (try "Bad": CHECKSUM ERROR), the bit time 104.17 us.
       Output check: Wiegand-26 - 26 pulses of 100 us on D0 / D1, facility 161
         and card 45763 for tag 1, both parity bits; the BEEP pulse (100 ms).
  5. Close U2's window and open it again with OPEN PANEL on the board.
Closed a monitor window? Click OPEN MONITOR on the monitor part.

WIRING (the same on both UNOs)
  EM-18 VCC -> supply (+5 V), GND -> GND.
  EM-18 TX -> D8 (AltSoftSerial RX, 9600 8N1).
  EM-18 BEEP -> D12 (the sketch counts the beeps; INPUT_PULLUP).
  EM-18 SEL, D0, D1: not connected (SEL open = UART, the OUTPUT property).
  LED + 220 ohm from A0 to GND (the access LED).
  Serial Monitor RXD <- Arduino D1 (TX), Serial Monitor TXD -> Arduino D0 (RX),
  Serial Monitor GND -> ground, Serial Monitor RXD2 <- the EM-18 TX line (a
  junction on the TX -> D8 wire): the monitor shows the reader's raw frames as
  RX2 next to what the sketch prints (BAUD2 9600).
Why D8 and AltSoftSerial: Proteus 8.5 never runs pin-change interrupts, so the
Arduino SoftwareSerial library cannot receive in the simulation (it can send).
AltSoftSerial uses Timer1's input capture on D8, which works in Proteus and on a
real UNO; it also uses D9 (its TX, unused here) and stops PWM on D10 - don't use
analogWrite(10) / digitalRead(10) with it. Hardware Serial (D0) works too, but
the demo keeps it for the Serial Monitor.
In the sketch: #include <AltSoftSerial.h>  AltSoftSerial rfid;  rfid.begin(9600);
Pin order in Proteus: VCC GND BEEP TX SEL D0 D1. The real module's pins: 1 VCC,
2 GND, 3 BEEP (BUZZ), 4-5 no connection (antenna), 6 SEL, 7 TX, 8 D1, 9 D0 -
wire by the names.
Wiegand instead of UART: SEL -> GND, D0 -> D2 (INT0), D1 -> D3 (INT1) and a
Wiegand reader sketch (each LOW pulse is one bit: on D0 a 0, on D1 a 1).
REAL HARDWARE:
 * The EM-18 is a 5 V module (4.6 - 5.5 V, about 50 mA): feed it from the
   Arduino's 5 V.
 * TX is a TTL (5 V) serial output, 9600 8N1 - wire it straight to D8 / RX of a
   5 V Arduino; for a 3.3 V board use an input that is 5 V tolerant or a divider.
 * SEL must be tied: to 5 V for the UART (TTL) output on TX, to GND for Wiegand
   on D0 / D1 (the simulation also accepts it open - then the OUTPUT property
   decides).
 * BEEP is active LOW and drives a buzzer + LED through a PNP transistor (BC557
   + 2.2 k in the data sheet) - don't hang a buzzer directly on it.
 * Read range: up to about 10 cm with an ISO card, less with keyfobs and small
   tags; metal near the module and an unsteady supply shorten it.
 * Tags: 125 kHz EM4100 / EM4102 / EM4001 / TK4100 (64-bit, read-only) cards and
   keyfobs. 13.56 MHz MIFARE / NFC cards are NOT read (use the MFRC522).
 * The reader sends a tag once per presentation: take it away before it is read
   again. Many cheap modules sold as EM-18 behave the same.

THE TAGS
Default tags (properties TAG1..TAG4 and TYPE1..TYPE4):
  TAG 1  5400A1B2C3  EM4100 card    checksum 84  allowed in the demo
  TAG 2  5400D4E5F6  EM4100 card    checksum 93  allowed in the demo
  TAG 3  1A0077B8C9  EM4102 keyfob  checksum 1C  denied (ADD allows it)
  TAG 4  1A00ABCDEF  EM4102 keyfob  checksum 93  denied (ADD allows it)
Checksum = XOR of the five ID bytes, sent as two hex characters. Example:
5400A1B2C3 -> 54 ^ 00 ^ A1 ^ B2 ^ C3 = 84, so the reader sends 5400A1B2C384.
Wiegand-26 of 5400A1B2C3: facility A1 = 161, card B2C3 = 45763.
Tag edits in the Advance editor last while the simulation runs; every new run
starts from the properties.

THE TEST TOOLS (EM18 Advance, Test tab) - what they really measure
Every tool runs on the live model while your sketch runs. A tool only places
tags in the field and reads the reader's own records - the frames it sent, the
reads it missed, and every level it drove on TX, D0, D1 and BEEP - so every
number is measured with the simulation clock. Each tool shows one "Good for:"
line and one line on how it measures.
  Read test     Good for: seeing how long a tag must stay on the reader and
                when your sketch gets its ID.
                Taps tag 1-4 at 2 cm 3, 5 or 10 times (0.08, 0.1, 0.2 or 0.5 s
                in the field, 0.7 s apart) and times each read from the tap: the
                tag decoded (EM4100 frames), the first byte on TX, the last byte
                (the ID is in your Arduino), the frames sent during the tap (1;
                RDM6300 every 65 ms) and the BEEP pulse. Example, 0.5 s taps: the
                tag decoded 70 - 100 ms after the tap, the last byte 103 - 133
                ms; with 0.08 s taps some taps are missed.
  Range         Good for: finding how far from the reader a card or a keyfob is
                still read.
                One 0.5 s tap at 1, 2 ... 12 cm: read or not, the decode time,
                the frames needed (amber = 3 - 4 near the edge). A card: read up
                to 10 cm; a keyfob: up to 5 cm (RANGE property).
  Frame check   Good for: checking the 12 characters your sketch must parse -
                10 ID digits + the XOR checksum.
                One tap with the UART output; the bytes decoded from the TX pin
                like a UART receiver (start / stop bits checked at mid-bit), the
                checksum worked out again and compared with the 2 characters
                received, the bit time measured from the edges (104.17 us at
                9600), the byte and frame times, the waveform of the whole frame.
                "Bad" = a test tag sent with a damaged checksum.
  Output check  Good for: seeing what a Wiegand-26 controller would get from a
                tag, and the BEEP pin's pulse.
                One tap with UART or Wiegand-26 (while SEL is open; a wired SEL
                decides): the D0 / D1 pulses measured (26 pulses of 100 us, 1 ms
                apart), the 26 bits with both parity checks, facility code and
                card number; the UART frame and that D0 / D1 stay idle; when the
                BEEP pin fell and how long it stayed LOW (BEEP_MS).
  The tools refuse to start, with the reason, when the reader has no power or
  another test runs (the Frame check also when SEL is wired LOW). While a tool
  runs the reader's field belongs to it (the panel's tags wait).

THE DEMO SKETCH ON THE SERIAL MONITOR (EM18_Demo v1.1)
  HELP          the command list
  STATUS        reads (and checksum errors), allowed tags, beeps, the LED, the
                last tag, and the D8 line check: "D8 (AltSoftSerial RX): idle
                HIGH ok, 24 bytes, 2 frames" (v1.0 printed this check every 10 s
                as "[status] A4 idle=..."; v1.1 keeps the monitor quiet)
  ADD [id]      allow the last tag read, or a 10-digit hex ID (spaces allowed):
                "Added 1A0077B8C9 (3 allowed)"; up to 8 tags
  DEL [id]      remove it: "Removed 1A0077B8C9 (2 allowed)"
Monitor quick buttons in the demo: STATUS, ADD, DEL, HELP.
If D8 stays LOW for 50 ms (it idles HIGH; a byte pulls it LOW for under 1 ms) the
sketch prints ONE warning "Warning: D8 (EM-18 TX) idles LOW - check the TX wire
and the reader's VCC / GND", and one line "D8 (EM-18 TX) idles HIGH again -
wiring ok" when it is fixed - nothing periodic.

EXPECTED MONITOR OUTPUT (U3 and U4 alike)
  TEP EM-18 RFID Reader Demo v1.1
  Authorised: 5400A1B2C3, 5400D4E5F6
  Click a card on the reader panel...
  Serial Monitor: HELP, STATUS, ADD [id], DEL [id]
  Read #1  Tag: 5400A1B2C3  -> ACCESS GRANTED       (TAG 1)
  Read #2  Tag: 1A0077B8C9  -> ACCESS DENIED        (TAG 3)
  Status: 2 reads (0 checksum errors), 2 allowed, 2 beeps, LED off, last 1A0077B8C9
    D8 (AltSoftSerial RX): idle HIGH ok, 24 bytes, 2 frames
    allowed: 5400A1B2C3
    allowed: 5400D4E5F6
  Added 1A0077B8C9 (3 allowed)                      (ADD)
  Read #3  Tag: 1A0077B8C9  -> ACCESS GRANTED       (TAG 3 again)
  Read #4  Tag: 1A0077B8C9  -> CHECKSUM ERROR       (TAG 3 with Sum = Bad)
RX2 (amber, the reader's TX line): 5400A1B2C384, 1A0077B8C91C ... - the raw
frames on RX2 have no line ending - the EM-18 sends none - so after the first
one the monitor shows them as continuation rows.

PROPERTIES (double-click the reader > Edit Properties; the same on Simple and
Advance)
  TAG1..TAG4    tag IDs: 10 hex characters (v1.0); 12 = the ID + the checksum to
                send (a wrong one makes a damaged-checksum tag). Invalid values
                fall back to the def
…