NFCGameBoard - OpenSource Smart Board for All Grid Based Games

HI! I am Luka, and this is an introduction to one of the technologies created by a Dutch inventor Ben Bulsink—an open-source project called nfcgameboard.com—and how you can get your hands on creating a smart board for multigrid board games.

I came across this technology while researching how to build my own smart chess board—specifically for four-player chess on a 14×14 grid. That research led me through a range of open-source projects, each solving the problem in their own ways:

1. Concept Bytes: https://www.youtube.com/shorts/sfefWWQjYDA, https://www.patreon.com/cw/ConceptBytes — they use a custom PCB with Hall effect magnetic sensors under each square to detect whether a piece is sitting on top of it. I’d say they are some of the more forward-thinking builders in this space who are still active. They are also creating their own exploding and melting chess pieces alongside the board. They currently have an ongoing Kickstarter campaign: https://www.kickstarter.com/projects/conceptbytes/open-chess-a-3d-printable-smart-chess-board
2. DIY Machines: https://www.youtube.com/watch?v=Z92TdhsAWD4, https://www.diymachines.co.uk/smart-chess-board-with-remote-and-local-play — instead of using a PCB with sensors, this build relies on WS2812B LEDs under the board and a separate button interface. When a player makes a move, they manually input it (e.g., e4) using the buttons, and the system sends that move to the connected app, while opponent moves are shown back on the board through the LEDs. It’s a truly very low-cost and accessible approach, probably one of the easiest entry points for beginners. Also published on Instructables: https://www.instructables.com/DIY-Super-Smart-Chessboard-Play-Online-or-Against-/
3. Luka De Bakker: https://www.instructables.com/Digital-Chess-Track-Your-Chess-Game-Online/ — Luka uses light sensors placed under each square to detect whether a piece is present or not. The wooden board is drilled to align sensors with each position, and changes in light are used to track movement across the board. It’s another quite clever, and low-cost approach that avoids more complex electronics, relying instead on simple sensing and a central controller (like a Raspberry Pi) to process the board state and sync it online.
4. OpenChessBoard: https://openchessboard.com/index.php/blog/, https://www.hackster.io/timokko/openchessboard-an-open-source-smart-chess-board-for-lichess-8d3761 — Similar in spirit to Concept Bytes - PCB with the sensors under each square, though the project now appears discontinued or no longer actively developed.
5. And many less-documented builds on YouTube from enthusiasts or students.

On all of these boards, players can move pieces on a physical board and have the moves appear in a connected app or another board. However, all these boards don’t know what piece you place on a square. They rely on the assumed starting position and then track moves, letting the computer calculate what piece must have moved where.

In Ben’s technology, the approach is different. He uses RFID/NFC technology, which consists of two components: a reader and a tag. The tags, attached to the bottom of pieces or tiles, have unique IDs and are powered by the magnetic field generated by the reader’s antenna when they come within a range of about 1–10 cm. During this interaction, the tag transmits its UID to the reader, allowing the system to identify exactly which object is present.

However, theoretically, to build a 15×15 grid NFC reader board, one would need 225 readers under the board, which is not practical. What Ben did instead was create a custom module using the CLRC632 NFC reader IC with a custom antenna matrix PCB—15 antenna columns and 15 antenna rows—that identifies which column and which row has the magnetic field active.

Since each tag is unique, the board can recognize whether the object is a Scrabble tile, a chess piece, or even a D&D miniature (whatever you want the tags to be), even if all tags from different games placed on the board simultaneously. This in return, gives an opportunity to create a sandbox for building the smart board games.

See the demo of the Scrabble board: https://www.youtube.com/watch?v=4qKndjF60Js

The original version of the project by Ben uses the CLRC632, which is a quite low-cost but relatively old RFID IC. In conversation with Ben, we discussed that to move the project forward and explore new possibilities, it would make more sense to switch to a more modern IC, such as the CLRC663 Plus, or PN5180.

From there, the next step is to order a PN5180 module and test communication through existing libraries. There are essentially two main ones available:

1. https://github.com/ATrappmann/PN5180-Library — an older library that is now archived and no longer maintained, but it has broader protocol coverage and includes support for ISO15693, ISO14443, FeliCa, and iClass.
2. https://github.com/playfultechnology/PN5180 — a newer and more beginner-friendly library, but much more limited in scope.

I managed to get both libraries working, though their existing examples revolve only around reading ISO15693 tag UIDs (older, less trendy tags). I haven’t tested anticollision—reading multiple tags at once—since I only had one ISO15693 tag.

As most newer tags are based on ISO14443, I wanted to test that protocol too. With the ISO14443 example from Tueddy’s library (https://github.com/tueddy/PN5180-Library/tree/master/examples), I managed to read ISO14443 tags. But multiplexing currently fails—the reader picks up the first tag’s UID and repeats it for the rest.

For that reason, the library would need to be updated and further developed to properly support the board. If that doesn’t work, a possible alternative could be the CLRC663 Plus. And if that also fails, then perhaps we can get back to CLRC632, as we know for sure that Ben was able to make that IC run the board successfully.

Once reader communication is working reliably, the next phase is antenna development—starting with a single-coil reference before attempting multiplexing.

The first step is to decouple the module’s built-in antenna and matching network from the reader IC. This can be done by desoldering the matching components or isolating the antenna feed line. With the RF pins exposed, an external matching network should be implemented, followed by connection to a single rectangular loop antenna made from enameled copper wire. This controlled baseline is necessary to validate impedance matching, resonance, and signal strength before moving to a multiplexed antenna array.

To tune the antenna and match it to the reader IC, you need a Vector Network Analyzer (VNA), such as a NanoVNA. With it you can adjust the matching network to achieve proper tuning at 13.56 MHz. This step is critical to ensure efficient power transfer between the reader and the antenna, as well as stable tag detection. For reference, here are some demonstrations I found on YouTube:

1. https://www.youtube.com/watch?v=aSPYP8a3v_I
2. https://www.youtube.com/watch?v=iJ1qKE5O0bY
3. https://www.youtube.com/watch?v=91ZRTFZ40rw

After experimenting with the external antenna and getting it to behave as required, the next step is to move to a multiplexed antenna grid.

In Ben’s schematics, four 74HC164 shift registers are used to control the antenna selection, so the system activates and reads one antenna at a time.

Once all the previous tests are working, we can move on to the hardware design stage and create the schematics for a custom PN5180-based modular PCB in KiCad or another EDA tool. The reference designs above represent two different cases: Ben’s CLRC632 system is designed to work with an external antenna matrix, while the PN5180 module is configured for a single integrated antenna. The target, ideally, is to design a PN5180 board that can be connected to an external antenna-grid PCB.

After the schematic capture is done, the next task is PCB layout—routing the board in KiCad and sending the finished design to a PCB manufacturer. It is important to understand that fabrication does not end the RF work. The PCB layout and material introduce parasitic capacitance and other non-ideal effects, which can shift the tuning of the antenna and matching network. For that reason, post-assembly tuning will still be necessary, and this is often done by adjusting or temporarily soldering variable capacitors until the circuit is properly matched.

So far, those are the steps I can envision. The next stage after that could be developing the software for the board, so it can detect, interpret, and understand the games being played on it.

If you have any questions, please feel free to ask—and if you can share any knowledge or ideas, that would be very welcomed.

Cheers!