In this project, we will build a small NFC-style banking terminal using the Kypruino board, an RC522 RFID reader, a 128×32 OLED screen, onboard buttons, onboard NeoPixels, and the onboard buzzer. The terminal lets users scan a card to open a simulated account, then deposit, withdraw, or transfer virtual money between cards.
This guide is written so that beginners can follow along. You do not need advanced electronics experience, but you should be comfortable connecting simple modules to a microcontroller, uploading an Arduino sketch, and following a menu on a small screen.
Important: This is an educational simulation. It does not connect to real banks, real payment networks, or real bank cards. The RFID card is only used as an account identifier inside the project.
What the project does
The Mini NFC Banking Terminal creates a simple card-based account system. Each compatible RFID/NFC card can be assigned to one account. Once the card is scanned, the user can access the account menu and perform simple simulated banking actions.
- Card login: scan a card to open a stored account
- Automatic registration: new cards are assigned to the next available account name
- Persistent storage: account data is saved in EEPROM, so it remains after power loss
- Deposit: add virtual money to the current account
- Withdraw: remove virtual money from the current account
- Transfer: send virtual money from one scanned card account to another
- OLED interface: shows account names, balances, menus, and instructions
- Feedback: NeoPixels and buzzer sounds indicate card scans, success, and declined actions
The result is a fun STEM project that introduces RFID, digital interfaces, memory storage, and transaction logic in a hands-on way.
Components needed
For this build, you will need:
- 1 × Kypruino board
- 1 × RC522 RFID reader module
- 1 × 128×32 I2C OLED screen, usually SSD1306
- RFID/NFC cards or key tags compatible with the RC522 reader
- Jumper wires
- USB-C cable for programming and power
- Optional 3D-printed enclosure or payment terminal body
The Kypruino’s onboard buttons, NeoPixels, and buzzer are used directly in this project, so no external buttons, LEDs, or buzzer modules are needed.
Card note: The RC522 reader works with many common 13.56 MHz RFID/NFC cards and tags, such as MIFARE-style cards or key tags. It should not be treated as a universal reader for all NFC devices. Real bank cards, phones, and some NFC tags may not work reliably and should not be used for this educational project.
How the system works
RFID card reader
The project uses an RC522 RFID reader. When a compatible card or tag is placed near the reader, the reader detects the card and reads its UID. The UID is a unique identifier that the program uses to recognise the card.
The project does not store money on the card itself. Instead, the Kypruino stores the card UID and account balance in its own EEPROM memory.
EEPROM account storage
EEPROM is a type of memory that can keep information even when the board is turned off. In this project, EEPROM is used to store:
- whether an account slot has been registered
- the RFID card UID linked to that account
- the account balance in cents
This means that after a card is registered, the Kypruino can remember it the next time the project is powered on.
OLED interface
The OLED screen displays the current menu, account name, balance, and instructions. The interface is designed for a compact 128×32 display, so the information is kept short and clear.
Buttons, LEDs, and buzzer
The onboard buttons are used to navigate the banking actions. The onboard NeoPixels and buzzer provide feedback when a card is scanned, when an operation succeeds, or when an operation is declined.
Wiring the project
Connect the modules to the Kypruino as shown below.
RC522 RFID reader
| RC522 Pin | Connects to Kypruino |
|---|---|
| SDA | D10 |
| SCK | D13 |
| MOSI | D11 |
| MISO | D12 |
| GND | GND |
| RST | D5 |
| 3.3V | 3.3V |
Important: The RC522 module should be powered from 3.3V, not 5V.
OLED screen
| OLED Pin | Connects to Kypruino |
|---|---|
| VCC | VCC (dedicated I2C port) |
| GND | GND |
| SDA | SDA |
| SCL | SCL |
Built-in Kypruino features
| Feature | Pin used in code |
|---|---|
| Button A | D7 |
| Button B | D6 |
| Button C | D4 |
| Button D | D2 |
| NeoPixels | D8 |
| Onboard buzzer | D9 |
Installing the Arduino libraries
Before uploading the code, install the required libraries in the Arduino IDE.
- Open the Arduino IDE
- Go to Sketch → Include Library → Manage Libraries...
- Search for and install MFRC522
- Install Adafruit SSD1306
- Install Adafruit GFX Library
- Install Adafruit NeoPixel
- Install Adafruit BusIO if it is not installed automatically
The sketch also uses standard Arduino libraries such as SPI, Wire, and EEPROM.
Uploading the code
Connect the Kypruino to your computer using a USB-C cable. Open the Arduino IDE, select the correct board and port, then upload the Mini NFC Banking Terminal sketch.
When the project starts, the OLED displays:
ATM
TAP CARDPlace a compatible RFID card or key tag near the RC522 reader. If the card is new, the project assigns it to the next available account name. If the card is already known, the project opens the matching account.
Using the account menu
After a card is scanned, the OLED shows the account name, balance, and available actions.
A:OUT B:IN
C:SEND D:EXITThe buttons control the account menu as follows:
| Button | Action |
|---|---|
| A | Withdraw virtual money |
| B | Deposit virtual money |
| C | Transfer virtual money to another card |
| D | Exit back to the tap card screen |
The project checks each operation before accepting it. For example, it will decline a withdrawal if there is not enough balance, and it will decline a deposit or transfer if the receiving account would go above the maximum balance.
Entering an amount
When depositing, withdrawing, or transferring money, the user enters an amount using the four onboard buttons.
The amount editor uses this control layout:
| Button | Amount editor action |
|---|---|
| D | Move left between digits |
| B | Move right between digits |
| A | Increase the selected digit |
| C | Confirm the amount |
| Hold C | Cancel and return |
The display shows a compact instruction line:
<D B> A^The maximum supported balance in the current code is:
EUR 9999999999.99Making a transfer
To transfer virtual money, the user first scans the sender card and opens the sender account. Then they press C to select transfer.
The screen asks for a second card:
TAP SECOND CARD
C HOLD: CANCELThe second card becomes the receiver. The project checks that the receiver card is already registered and that it is not the same as the sender card. After the amount is entered, the balance is subtracted from the sender and added to the receiver.
After a successful transfer, the OLED briefly shows both account balances so the user can see the result.
Customising the account names
The project includes a list of account names inside the code. These are the names that new cards will be assigned to.
const char* accountNames[] = {
"ANDREAS",
"MARIA",
"GEORGE",
"KOSTAS"
};You can replace these names with your own names. For example:
const char* accountNames[] = {
"ALICE",
"BOB",
"TEAM 1",
"TEAM 2"
};New cards are assigned in order. The first new card gets the first name, the second new card gets the second name, and so on.
You can also add more names if you want more account slots, as long as the EEPROM memory of the board is sufficient for the number of accounts.
Changing the starting balance
The starting balance is set in cents. For example, EUR 10.00 is stored as 1000 cents.
const Money STARTING_BALANCE_CENTS = 0;To start every new account with EUR 20.00, you could change it to:
const Money STARTING_BALANCE_CENTS = 2000;This starting value is only applied when a new card is registered. Cards that have already been registered will keep their stored EEPROM balance unless the accounts are reset.
Resetting all accounts
If you want to erase all registered cards and balances, the sketch includes a reset option.
Find this line:
const bool RESET_ALL_ACCOUNTS = false;Change it to:
const bool RESET_ALL_ACCOUNTS = true;Upload the sketch once. This clears the stored account data from EEPROM.
Then change it back to:
const bool RESET_ALL_ACCOUNTS = false;Upload the sketch again.
Important: Do not leave the reset option set to true during normal use, or the accounts may be erased every time the board starts.
Understanding the stored money values
The project stores money as cents instead of using decimal numbers. This is a common programming approach for money-style values because it avoids decimal rounding problems.
For example:
- EUR 0.00 is stored as 0
- EUR 10.00 is stored as 1000
- EUR 25.50 is stored as 2550
The OLED display then converts the stored cent value back into a readable format such as:
EUR 25.50Why use EEPROM?
If account balances were stored only in normal variables, they would disappear when the board lost power or reset. EEPROM allows the Kypruino to remember registered cards and balances between sessions.
This makes the project feel much more realistic. A card can be registered, used, powered off, and then scanned again later with the same stored account information.
Assembling the terminal
Once the circuit is working on your desk, you can place the electronics into a small enclosure or terminal-style body.
- Mount the OLED screen on the dedicated I2C port
- Place the RC522 reader near the card-tapping area
- Keep the Kypruino buttons accessible for menu control
- Make sure the NeoPixels are visible if you want the feedback animations to show
- Keep the USB-C port accessible for reprogramming
- Secure the wiring so it does not pull on the RFID reader or display
What students can learn
This project introduces several important STEM concepts:
- RFID/NFC card detection
- SPI communication
- I2C OLED display control
- EEPROM memory storage
- Menu-based user interface design
- Button input and long-press detection
- Digital feedback using LEDs and sound
- Data structures for storing account records
- Basic transaction logic
- Input validation and declined operations
- Representing money values safely using cents
It also teaches an important engineering idea: a system is not just made of hardware. It also needs rules, memory, feedback, and safety checks to behave in a reliable way.
Possible extensions
- Add a PIN code before allowing access to an account
- Add an admin card for resetting or editing accounts
- Add a receipt screen after each transaction
- Add a transaction history stored in memory
- Add different account types or spending limits
- Add a larger screen for a more detailed interface
- Add a 3D-printed payment terminal enclosure
- Use the project in a classroom economy or token system
Final thoughts
The Mini NFC Banking Terminal is a creative STEM project that combines RFID cards, memory storage, screen menus, buttons, LEDs, and sound into one interactive system. By scanning a card and performing simulated transactions, students can explore how digital systems identify users, store data, and respond to different actions.
Although it looks like a small banking or payment device, the project is fully educational and self-contained. It does not use real money or real banking systems. Instead, it gives learners a safe and practical way to understand the logic behind card-based interfaces, stored accounts, and digital transactions.
