Proiectul Flipper One reprezintă o mini-replică educațională, realizată pe Arduino UNO, inspirată conceptual de dispozitivele de tip multi-tool folosite pentru testarea comunicațiilor simple RF, RFID/NFC și WiFi. Scopul proiectului nu este realizarea unui dispozitiv comercial, ci înțelegerea practică a modului în care mai multe periferice embedded pot comunica între ele într-un sistem cu resurse foarte limitate.

Dispozitivul este construit în jurul unei plăci Arduino UNO R3 / ATmega328P și integrează un ecran OLED, butoane prin expander I2C, LED RGB, module RF 433 MHz, modul PN532 pentru RFID/NFC, modul ESP-01 pentru scanare WiFi și modul MicroSD pentru stocare persistentă.

În forma finală, proiectul a fost împărțit în două firmware-uri separate:

• Flipper One Main – firmware-ul principal, care include RFID, WiFi, MicroSD și captură/replay RF în mod raw;
• Flipper One RF – firmware specializat pentru RF, bazat pe decodare cu RCSwitch, retransmitere și salvare pe card MicroSD în fișiere separate.

Această împărțire a fost necesară din cauza limitărilor severe de memorie ale microcontrollerului ATmega328P. Încercarea de a include simultan RFID, WiFi, SD, OLED, raw RF și RCSwitch într-un singur firmware depășea limita de Flash sau producea un sistem instabil. Prin urmare, proiectul a fost modularizat în două coduri care folosesc aceeași platformă hardware, dar sunt încărcate separat în funcție de demonstrația dorită.

Funcționalități principale implementate:

• citirea UID-urilor RFID/NFC folosind modulul PN532;
• salvarea UID-urilor RFID pe card MicroSD;
• scanarea rețelelor WiFi din apropiere folosind ESP-01 / ESP8266;
• salvarea scanărilor WiFi pe card MicroSD;
• analiza rețelelor WiFi detectate: RSSI, securitate, canal, WPS, MAC/BSSID și observații simple;
• capturarea raw a semnalelor RF 433 MHz și retransmiterea lor în firmware-ul principal;
• capturarea/decodarea RF cu RCSwitch în firmware-ul RF dedicat;
• salvarea codurilor RF decodate în fișiere separate pe cardul MicroSD;
• interfață utilizator pe OLED 128×64;
• control prin 4 butoane conectate prin PCF8574;
• feedback vizual prin LED RGB.

Din punct de vedere al rezultatului final, partea de RFID și partea de WiFi funcționează foarte bine. Modulul RFID detectează cardurile și salvează UID-urile pe SD, iar modulul WiFi realizează scanări, salvează rezultatele și afișează analiza rețelelor într-un mod stabil. Partea RF a fost cea mai dificilă: captura raw este foarte sensibilă la zgomotul receptorului, iar varianta cu RCSwitch este mai curată din punct de vedere software, dar depinde puternic de protocolul telecomenzii și de calitatea semnalului primit.

Proiectul este realizat strict în scop educațional și de laborator. Testele RF/RFID/WiFi au fost gândite pentru module proprii, carduri proprii și telecomenzi simple de tip fixed-code. Telecomenzile moderne cu rolling-code, precum cele auto sau multe telecomenzi moderne de garaj, nu pot fi clonate prin această implementare.

Sistemul este organizat în jurul plăcii Arduino UNO R3, bazată pe microcontrollerul ATmega328P. Arduino coordonează toate modulele externe, citește butoanele, actualizează afișajul OLED și execută funcțiile alese din meniu.

Interacțiunea cu utilizatorul se face prin:

• un ecran OLED SH1106 128×64 SPI, folosit în mod text prin biblioteca U8x8;
• 4 butoane conectate la un PCF8574 pe I2C;
• un LED RGB conectat la pini PWM pentru feedback vizual.

Pentru economia de pini, butoanele nu sunt conectate direct la Arduino, ci prin expanderul I2C PCF8574. Astfel, cele 4 butoane folosesc aceeași magistrală I2C ca modulul PN532.

Partea de RF este realizată cu două module de 433 MHz:

• SRX887 – receptor, conectat pe D2, pin care suportă întrerupere externă INT0;
• STX882 – emițător, conectat pe D8.

În firmware-ul principal, semnalul RF este tratat raw: programul memorează duratele dintre tranzițiile de nivel logic detectate pe D2 și încearcă să le retransmită pe D8. Această abordare este apropiată conceptual de un sistem de captură raw, dar pe Arduino UNO este limitată de memorie și este foarte sensibilă la zgomot.

În firmware-ul RF separat, semnalul este tratat cu biblioteca RCSwitch, care încearcă să decodeze protocoale RF simple de tip fixed-code. În loc să salveze sute de tranziții, firmware-ul salvează doar valoarea decodată, numărul de biți, protocolul și lungimea pulsului. Această metodă este mult mai eficientă ca memorie, dar funcționează doar pentru protocoalele suportate de RCSwitch și pentru telecomenzi compatibile.

Modulul PN532 RFID/NFC este conectat pe I2C și este folosit pentru citirea UID-urilor cardurilor ISO14443A. Pentru a reduce consumul de memorie, în firmware-ul principal am folosit o implementare minimală pentru comenzile PN532 necesare: inițializare, configurare SAM și citire UID.

Modulul ESP-01 / ESP8266 este conectat prin SoftwareSerial. Arduino îi trimite comenzi AT, iar ESP-ul răspunde cu lista rețelelor WiFi detectate. Datele sunt salvate pe cardul MicroSD în fișierul `WIFIDB.TXT`, apoi sunt citite și analizate din fișier, nu păstrate integral în RAM.

Modulul MicroSD este conectat pe SPI și este folosit pentru stocarea persistentă a datelor:

• UID-uri RFID în fișiere `.UID`, indexate în `UIDIDX.TXT`;
• scanări WiFi în `WIFIDB.TXT`;
• coduri RF decodate în firmware-ul RF, în fișiere `.RFC`, indexate în `RFIDX.TXT`.

Logica generală a dispozitivului este bazată pe o mașină de stări:

• Main Menu – utilizatorul alege modul de lucru;
• RF Capture / RF Emit – captură și retransmitere RF;
• RFID Scan / Save UID – citire și salvare UID;
• WiFi Scan / View Networks – scanare și afișare rețele WiFi;
• SD Browser – vizualizarea fișierelor salvate;
• Status – afișarea stării sistemului.

Hardware-ul proiectului a rămas în mare parte același între cele două firmware-uri. Ambele variante folosesc aceeași placă Arduino UNO și aceleași conexiuni fizice. Diferența este la nivel software: firmware-ul încărcat pe Arduino decide ce module sunt folosite efectiv.

Montajul este realizat pe breadboard și include următoarele module:

• Arduino UNO R3 / ATmega328P;
• OLED SH1106 128×64 pe SPI;
• receptor RF SRX887 433 MHz;
• emițător RF STX882 433 MHz;
• modul PN532 RFID/NFC pe I2C;
• expander PCF8574 pentru butoane pe I2C;
• 4 butoane tactile;
• LED RGB;
• ESP-01 / ESP8266 pentru scanare WiFi;
• regulator AMS1117 3.3V pentru ESP-01;
• modul MicroSD pe SPI.

Alimentarea este împărțită astfel:

• 5V pentru Arduino, OLED, PN532, PCF8574, module RF și MicroSD;
• 3.3V pentru ESP-01, generat prin AMS1117;
• GND comun pentru toate modulele.

PN532 și PCF8574 sunt pe aceeași magistrală I2C, iar OLED-ul și MicroSD-ul împart magistrala SPI. Pentru a evita conflictele pe SPI, fiecare dispozitiv are pinul său de chip select: OLED pe D10 și SD pe A3.

Proiectul a fost dezvoltat în Visual Studio Code folosind PlatformIO și toolchain-ul AVR-GCC pentru Arduino UNO. Framework-ul folosit este Arduino, deoarece proiectul integrează mai multe biblioteci și periferice externe.

Biblioteci folosite:

• `U8g2 / U8x8` – afișare text pe OLED SH1106 fără framebuffer, pentru economie de RAM;
• `SD` – acces la cardul MicroSD;
• `Wire` – comunicație I2C cu PCF8574 și PN532;
• `SPI` – comunicație cu OLED și MicroSD;
• `SoftwareSerial` – comunicație serială cu ESP-01;
• `RCSwitch` – folosit doar în firmware-ul RF dedicat.

Pentru a evita depășirea memoriei Flash, proiectul este împărțit în două environment-uri PlatformIO:

[env:main_demo]
; Flipper One Main: RFID + WiFi + SD + raw RF
 
[env:rf_demo]
; Flipper One RF: RF RCSwitch + SD

Comenzi de upload:

pio run -e main_demo -t upload

pio run -e rf_demo -t upload

Microcontrollerul ATmega328P are doar 32 KB Flash și 2 KB SRAM. În timpul dezvoltării, încercarea de a include toate funcțiile într-un singur firmware a dus la depășirea limitei de Flash sau la instabilitate runtime, mai ales când erau folosite simultan:

• biblioteca SD;
• biblioteca RCSwitch;
• SoftwareSerial pentru ESP;
• driverul PN532;
• meniurile OLED;
• analiza WiFi;
• captură RF raw.

Soluția finală a fost separarea proiectului în două coduri:

• firmware-ul main_demo, pentru demonstrația completă RFID/WiFi/SD și raw RF;
• firmware-ul rf_demo, pentru demonstrația specializată RF cu RCSwitch și salvare pe SD.

Această abordare este mai robustă decât un meniu de alegere la pornire, deoarece un meniu runtime nu reduce dimensiunea binarului. Dacă toate modulele sunt compilate în același firmware, ele ocupă memorie chiar dacă nu sunt selectate de utilizator.

Firmware-ul principal păstrează majoritatea funcționalităților inițiale ale proiectului:

• captură RF raw;
• retransmitere RF raw;
• scanare RFID;
• salvare UID RFID pe card MicroSD;
• scanare WiFi cu ESP-01;
• salvare scanare WiFi în `WIFIDB.TXT`;
• analiză WiFi pe OLED;
• browser SD pentru fișierele salvate;
• status general.

În modul raw, receptorul RF este conectat la D2, iar codul folosește întreruperea externă INT0 pentru a măsura timpul dintre tranzițiile semnalului. Fiecare durată este salvată într-un buffer de tip `uint16_t`.

Avantajul acestei abordări este că nu presupune cunoașterea protocolului. În teorie, poate captura orice secvență de impulsuri OOK/ASK suficient de simplă.

Dezavantajul major este sensibilitatea la zgomot. Receptorul SRX887 poate genera tranziții chiar și în lipsa unui semnal real, din cauza AGC-ului și a zgomotului RF din mediu. Astfel, bufferul se poate umple cu zgomot înainte ca utilizatorul să apese telecomanda. Din acest motiv, captura RF raw este implementată, dar nu este partea cea mai stabilă a proiectului.

Modulul PN532 este controlat prin I2C. Pentru economie de memorie, nu este folosită biblioteca completă Adafruit PN532, ci un driver minimal care implementează doar comenzile necesare:

• `GetFirmwareVersion` pentru verificarea prezenței modulului;
• `SAMConfiguration` pentru configurarea modului normal;
• `InListPassiveTarget` pentru citirea cardurilor ISO14443A.

După detectarea unui card, UID-ul este afișat pe OLED și poate fi salvat pe SD într-un fișier `.UID`. Numele fișierului este generat automat, iar indexul fișierelor salvate este păstrat în `UIDIDX.TXT`.

Exemplu format fișier RFID:

LEN=4
UID=04A1B2C3

Această parte a proiectului funcționează foarte bine și a fost una dintre cele mai stabile funcționalități obținute.

Pentru scanarea WiFi este folosit un modul ESP-01 / ESP8266 cu firmware AT. Arduino comunică prin SoftwareSerial și trimite comanda:

AT+CWLAP

Răspunsurile de forma `+CWLAP:(…)` sunt salvate pe cardul MicroSD în fișierul `WIFIDB.TXT`. Pentru a economisi RAM, rețelele nu sunt păstrate într-un vector mare, ci sunt scrise direct pe SD și apoi citite la nevoie.

Date analizate pentru fiecare rețea:

• SSID;
• RSSI;
• BSSID / MAC;
• canal;
• tip securitate;
• WPS;
• cipher pairwise/group;
• protocol b/g/n;
• observații simple despre calitatea semnalului și congestie.

Scanarea WiFi și analiza rezultatelor funcționează foarte bine. Aceasta a devenit una dintre cele mai reușite părți ale proiectului.

Firmware-ul principal include un browser simplu de fișiere salvate. Pentru a evita directoarele și operații costisitoare pe SD, sunt folosite fișiere index:

• `UIDIDX.TXT` pentru UID-uri RFID;
• `RFIDX.TXT` pentru capturi RF raw, în varianta inițială;
• `WIFIDB.TXT` pentru scanarea WiFi curentă.

Browserul citește indexul linie cu linie și afișează fișierele pe OLED.

Firmware-ul RF este o variantă specializată pentru testarea RF 433 MHz. Acesta include:

• OLED;
• PCF8574 + butoane;
• LED RGB;
• STX882 / SRX887;
• RCSwitch;
• MicroSD pentru salvarea codurilor RF decodate.

Nu include PN532, ESP-01 sau analiza WiFi, tocmai pentru a păstra suficient spațiu pentru RCSwitch și pentru logica de salvare RF.

Meniul firmware-ului RF:

• Capture RF – așteaptă un cod RF compatibil RCSwitch;
• Emit Last – retransmite ultimul cod capturat sau încărcat;
• Save Last – salvează codul RF curent pe SD;
• Saved RF – listează fișierele RF salvate și permite încărcarea lor;
• Status – afișează valoarea, bit length, protocolul, delay-ul și starea SD.

În acest firmware, în loc să se salveze tranzițiile brute, biblioteca RCSwitch încearcă să decodeze semnalul. Dacă reușește, firmware-ul reține:

• `value` – valoarea numerică decodată;
• `bits` – numărul de biți;
• `protocol` – protocolul detectat de RCSwitch;
• `delayUs` – lungimea pulsului.

Această reprezentare este mult mai compactă decât raw pulse capture. Un cod RF poate fi salvat în câțiva bytes, în timp ce varianta raw are nevoie de un buffer de durate.

În firmware-ul RF, codurile decodate pot fi salvate pe card MicroSD în fișiere separate, similar cu salvarea UID-urilor RFID. Există un fișier index `RFIDX.TXT`, iar fiecare cod RF este salvat într-un fișier `.RFC`.

Exemplu:

RFIDX.TXT
R123456.RFC
R234567.RFC

Format fișier `.RFC`:

VAL=1234567
BITS=24
PROTO=1
DELAY=350

La selectarea unui fișier din meniul Saved RF, codul este încărcat în RAM și poate fi retransmis prin Emit Last.

Deși firmware-ul RF este mai eficient și mai bine structurat decât captura raw, rezultatele practice nu au fost perfecte. Uneori receptorul produce zgomot și RCSwitch nu decodează nimic valid. Alteori semnalul telecomenzii nu este compatibil cu protocoalele suportate. Astfel, partea RF rămâne cea mai instabilă parte a proiectului.

Totuși, salvarea pe SD din firmware-ul RF funcționează, iar structura software este corectă: atunci când un cod este capturat valid, acesta poate fi salvat, încărcat și retransmis.

Proiectul folosește mai multe concepte studiate în laboratoarele de Proiectarea cu Microprocesoare:

• GPIO – configurarea și folosirea pinilor digitali pentru LED RGB, RF TX, chip select-uri SPI și semnale de control.
• Întreruperi – folosirea pinului D2 / INT0 pentru recepția RF raw și pentru recepția RCSwitch.
• PWM / Timere – controlul LED-ului RGB cu `analogWrite()` pe pinii D3, D5 și D6.
• SPI – comunicația cu OLED-ul și cardul MicroSD.
• I2C / TWI – comunicația cu PCF8574 și PN532 pe A4/A5.
• UART / SoftwareSerial – comunicația cu ESP-01 prin comenzi AT.
• Sisteme de fișiere pe SD – salvarea și citirea persistentă a UID-urilor RFID, scanărilor WiFi și codurilor RF.
• Mașină de stări – meniul principal și submeniurile sunt gestionate prin stări software.
• Optimizare de memorie – folosirea PROGMEM, U8x8 fără framebuffer, fișiere index și separarea proiectului în două firmware-uri.

Pentru a rula pe Arduino UNO, au fost necesare mai multe optimizări:

• folosirea U8x8 în loc de un framebuffer complet pentru OLED;
• salvarea scanărilor WiFi direct pe SD, nu în RAM;
• folosirea de stringuri în PROGMEM;
• implementare minimală PN532;
• limitarea bufferelor locale;
• dezactivarea Serial debug în build-ul final;
• modularizarea în două firmware-uri separate.

Această modularizare a fost probabil cea mai importantă decizie software. Fără ea, proiectul era prea mare pentru ATmega328P.

În urma implementării și testării, rezultatele au fost mixte, dar în general peste așteptări pentru un proiect realizat pe Arduino UNO cu atât de multe periferice conectate simultan.

Partea de RFID funcționează foarte bine:

• PN532 este inițializat corect pe I2C;
• cardurile/tag-urile ISO14443A sunt detectate;
• UID-ul este afișat corect pe OLED;
• UID-ul poate fi salvat pe MicroSD;
• fișierele salvate pot fi regăsite prin index.

Această funcționalitate este stabilă și poate fi demonstrată live fără probleme majore.

Partea de WiFi este una dintre cele mai reușite părți ale proiectului:

• ESP-01 răspunde la comenzile AT;
• scanarea rețelelor din jur funcționează;
• rezultatele sunt salvate în `WIFIDB.TXT`;
• lista rețelelor poate fi afișată pe OLED;
• detaliile fiecărei rețele pot fi analizate;
• analiza include RSSI, securitate, canal, MAC/BSSID, WPS și observații simple.

Pentru un Arduino UNO, faptul că analiza WiFi se face fără a păstra toate rețelele în RAM este un rezultat important.

Captura RF raw este implementată, dar este instabilă în practică. Uneori receptorul captează foarte mult zgomot, alteori semnalul util nu poate fi separat clar de zgomot. Această problemă vine atât din natura receptorului RF, cât și din limitările Arduino UNO.

Raw RF rămâne interesant ca experiment, deoarece arată cum pot fi măsurate tranzițiile folosind întreruperi, dar nu este suficient de stabil pentru o demonstrație sigură de tip „capturează telecomanda și retransmite”.

Firmware-ul RF cu RCSwitch este mai curat și mai eficient, dar nu rezolvă complet problema. Dacă telecomanda folosește un protocol suportat și semnalul este curat, codul poate fi decodat și salvat. Dacă semnalul este zgomotos sau protocolul nu este compatibil, nu apare nicio captură validă.

Totuși, modulul RF dedicat are următoarele funcționalități funcționale:

• captură RCSwitch atunci când semnalul este compatibil;
• afișarea codului decodat;
• retransmiterea codului decodat;
• salvarea codului pe SD în fișiere `.RFC`;
• listarea și încărcarea codurilor RF salvate.

Partea de salvare pe SD din firmware-ul RF funcționează, iar structura fișierelor este clară și ușor de verificat manual pe calculator.

Cele mai mari probleme au fost:

• zgomotul RF produs de receptor în lipsa unui semnal util;
• bufferul mic disponibil pentru raw RF;
• incompatibilitatea unor telecomenzi cu RCSwitch;
• memoria Flash foarte limitată;
• memoria RAM limitată, mai ales când SD, SoftwareSerial și OLED sunt folosite simultan;
• conflictele potențiale pe SPI între OLED și MicroSD, rezolvate prin control atent al pinilor CS.

Proiectul a ieșit mai bine decât mă așteptam, mai ales având în vedere numărul mare de module conectate la un Arduino UNO. Cele mai stabile și reușite părți sunt RFID-ul și WiFi-ul: UID-urile sunt citite și salvate corect, iar scanarea WiFi împreună cu analiza rețelelor funcționează foarte bine.

Partea RF a fost cea mai dificilă. Captura raw este foarte expusă la noise, iar varianta cu RCSwitch, deși mult mai eficientă, depinde de protocoalele suportate și de calitatea semnalului. Din acest motiv, RF-ul rămâne o funcționalitate parțială și experimentală în proiect.

Cea mai importantă lecție a fost legată de constrângerile de memorie. ATmega328P are resurse foarte limitate, iar combinația dintre OLED, SD, ESP, PN532, RF și RCSwitch a forțat optimizări serioase. În final, modularizarea în două firmware-uri separate a fost soluția corectă: firmware-ul principal pentru RFID/WiFi/SD și firmware-ul RF pentru captură/decodare/salvare RF.

Chiar dacă RF-ul nu este perfect, proiectul demonstrează integrarea unui număr mare de periferice și concepte embedded într-un singur montaj. Din punct de vedere educațional, proiectul și-a atins scopul: am lucrat cu GPIO, întreruperi, PWM, SPI, I2C, UART software, card SD, management de memorie și proiectare software modulară.

• Documentație Arduino UNO / ATmega328P
• Documentație PlatformIO
• Documentație U8g2 / U8x8
• Documentație RCSwitch
• Documentație ESP8266 AT Commands
• Documentație PN532
• Documentație SD library Arduino
• Laboratoarele de Proiectarea cu Microprocesoare: GPIO, întreruperi, PWM/timere, SPI, I2C, UART