Table of Contents
DICE&ROLL
Introducere
- Acest proiect are ca scop crearea unui sistem automatizat numit “DICE AND ROLL” pentru “dat cu zarul” și jucarea unui joc interactiv de tip Barbut pentru doi jucători. Sistemul îmbină componentele mecanice cu procesarea de imagine pentru a citi și afișa automat rezultatele, oferind o experiență de joc inedită și complet independentă de intervenția umană în citirea scorului.
Descriere generală
- Proiectul constă într-un sistem automatizat de “dat cu zarul” și un joc interactiv de tip Barbut pentru doi jucători. Sistemul folosește un pahar acționat de un servomotor pentru a amesteca zarurile fizice. O cameră montată deasupra paharului preia o imagine, iar microcontroller-ul procesează imaginea pentru a număra punctele de pe zaruri (Computer Vision). Rezultatul fiecărui jucător este afișat pe un ecran LCD, iar la final sistemul compară scorurile și declară câștigătorul.
Schema Bloc
- Input: 2x Butoane (Jucător 1, Jucător 2)
- Procesare: ESP32-CAM (analiză imagine, logică joc)
- Output: Servomotor (amestecare), Ecran LCD I2C (afișare scor)
Hardware Design
Lista de piese (Bill of Materials):
* Placă ESP32-CAM (cu cameră OV2640): Microcontroller-ul central care gestionează logica jocului, face pozele și comunică prin Wi-Fi cu scriptul Python pentru procesarea imaginilor. * Servomotor SG90: Acționează mecanic paharul pentru a amesteca zarurile fizice prin mișcări scurte și agresive la comanda microcontroller-ului. * Ecran LCD 2004 (sau 1602) cu modul I2C: Afișează meniurile, rândul jucătorilor, instrucțiunile defilante, punctajul și mesajul cu câștigătorul jocului.
* 2 x Module Programator FTDI (CP2102/CH340):
- Programatorul 1: Folosit pentru a încărca codul, pentru comunicația serială și pentru a alimenta partea logică (ESP32-CAM și LCD).
- Programatorul 2: Transformat exclusiv în sursă de curent (conectat la un alt port USB) pentru a susține consumul ridicat al servomotorului.
* Butoane tactile: 2 bucăți ce permit Jucătorului 1 și Jucătorului 2 să aleagă modul de joc și să declanșeze “aruncarea” cu zarul. * Rezistoare 10kΩ: 2 bucăți folosite ca rezistențe de pull-down pentru butoane, prevenind declanșările false cauzate de zgomotul electromagnetic. * Breadboard: Placa de bază utilizată pentru rutarea separată a celor două surse de alimentare și conectarea tuturor firelor. * Set fire Dupont: Mamă-Mamă, Tată-Tată, Tată-Mamă, utilizate pentru realizarea tuturor conexiunilor electrice. * Pahar de plastic mic + 2 zaruri: Ansamblul mecanic fizic în care se desfășoară jocul.
Conexiunile hardware ale proiectului sunt următoarele:
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Programator FTDI 1 (Logică) | 5V / VCC | Bara 5V #1 (roșie - circuit logic) breadboard |
| Programator FTDI 1 (Logică) | GND | Bara GND (albastră - comună) breadboard |
| Programator FTDI 1 (Logică) | TX | U0R (RX) microcontroller |
| Programator FTDI 1 (Logică) | RX | U0T (TX) microcontroller |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Programator FTDI 2 (Putere Motor) | 5V / VCC | Bara 5V #2 (separată!) breadboard |
| Programator FTDI 2 (Putere Motor) | GND | Bara GND (albastră - comună) breadboard |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| ESP32-CAM | 5V | Bara 5V #1 (circuit logic) breadboard |
| ESP32-CAM | GND | Bara GND (albastră - comună) breadboard |
| ESP32-CAM | 3.3V | Bara 3.3V breadboard (pentru alimentarea butoanelor) |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Buton Jucator 1 | Pin alimentare | 3.3V breadboard |
| Buton Jucator 1 | Pin semnal (diagonala) | IO2 microcontroller |
| Buton Jucator 2 | Pin alimentare | 3.3V breadboard |
| Buton Jucator 2 | Pin semnal (diagonala) | IO12 microcontroller |
| Rezistoare 10kΩ | Capat 1 | Pin semnal buton (IO2, respectiv IO12) |
| Rezistoare 10kΩ | Capat 2 | Bara GND (albastră - comună) breadboard |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Ecran LCD I2C | GND | Bara GND (albastră - comună) breadboard |
| Ecran LCD I2C | VCC | Bara 5V #1 (circuit logic) breadboard |
| Ecran LCD I2C | SDA | IO15 microcontroller (Pin remapat) |
| Ecran LCD I2C | SCL | IO14 microcontroller (Pin remapat) |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Servomotor SG90 | GND (Fir Maro/Negru) | Bara GND (albastră - comună) breadboard |
| Servomotor SG90 | VCC (Fir Roșu/Mijlociu) | Bara 5V #2 (circuit putere - Programator 2) |
| Servomotor SG90 | Semnal (Fir Portocaliu) | IO13 microcontroller |
| Componenta | Pin componenta | Conectare |
|---|---|---|
| Camera OV2640 | Panglica FPC (24 pini) | Conector FPC dedicat pe placa ESP32-CAM |
Deoarece placa ESP32-CAM nu dispune de o mufă USB integrată pentru alimentare și programare, s-a optat inițial pentru utilizarea unui modul FTDI. Totuși, dinamica proiectului a impus o regândire a distribuției de curent. Servomotorul SG90, configurat să execute mișcări violente și bruște de 120 de grade pentru a amesteca eficient zarurile în paharul de plastic, generează vârfuri masive de consum de curent (aprox. 1 Amper la fiecare inversare de sens).
Pentru a preveni fenomenul de “brownout” (resetarea plăcii din cauza lipsei de curent), arhitectura breadboard-ului a fost împărțită într-un sistem hibrid cu două circuite de 5V izolate, susținute de două porturi USB distincte, dar având masa (GND) comună: - Circuitul Logic (Programatorul 1): Alimentează microcontroller-ul ESP32-CAM, senzorul camerei și lumina de fundal a ecranului LCD. - Circuitul de Forță (Programatorul 2): Este dedicat exclusiv alimentării servomotorului SG90. - Șina de 3.3V: Este alimentată de la ieșirea stabilizată a plăcii ESP32-CAM și este folosită exclusiv pentru logica butoanelor.
Butoanele tactile sunt configurate hardware în modul Pull-down, folosind rezistoare externe de 10kΩ conectate între pinii de semnal și masă (GND). Astfel, în stare de repaus, microcontroller-ul citește un semnal stabil de LOW (0V), iar la apăsarea butonului circuitul se închide pe diagonală, trimițând un semnal de HIGH (3.3V) către pinii IO2 și IO12.
Pentru afișajul interfeței utilizatorului și a meniurilor, a fost integrat un Ecran LCD cu modul I2C (PCF8574). Deoarece pinii I2C standard ai ESP32 (21 și 22) sunt rezervați intern de modulul camerei, comunicarea I2C a fost remapată software către pinii liberi IO14 (SCL) și IO15 (SDA).
Mecanismul de amestecare a zarurilor este acționat de servomotorul SG90, controlat prin semnal PWM pe pinul IO13. Paharul de plastic este atașat mecanic de brațul motorului. Modulul camerei OV2640 este conectat direct pe placa de dezvoltare prin interfața sa dedicată (FPC) și este orientat către interiorul bazei mecanismului, fiind responsabil de capturarea imaginilor cu zarurile stabilizate după încheierea cursei servomotorului. Imaginile sunt ulterior transmise prin Wi-Fi către un script extern Python care folosește algoritmi de Computer Vision pentru calcularea punctajului obținut de fiecare jucător.
Software Design
Proiectul este structurat într-o arhitectură de tip Client-Server și folosește două medii de dezvoltare distincte: PlatformIO (C++) pentru logica hardware și controlul microcontroller-ului ESP32-CAM, și Python pentru procesarea de imagine (Computer Vision) rulată pe PC.
1. Componenta Microcontroller (PlatformIO / C++)
Codul pentru placa ESP32-CAM a fost dezvoltat în PlatformIO, folosind framework-ul Arduino. Acesta rulează un server web HTTP care acceptă comenzi, controlează interfața fizică (butoanele tactile și ecranul LCD 20×4 via I2C) și generează semnale PWM pentru servomotor. De asemenea, implementează o mașină de stări pentru gestionarea celor două moduri de joc (Free Roll și Barbut).
Functii principale implementate:
| Functie | Rol |
|---|---|
| setup() | Inițializează pinii pentru butoane, pornește comunicația I2C pentru ecranul LCD, configurează semnalul PWM pentru servomotor, inițializează camera OV2640, se conectează la rețeaua Wi-Fi și pornește serverul web. |
| loop() | Reprezintă bucla principală a sistemului. Citește non-stop starea butoanelor (incluzând logica de debouncing și detectarea dublu-click-ului pentru funcția de “Back”), gestionează stările jocului și ascultă cererile HTTP venite de la scriptul Python. |
| afiseazaMeniuPrincipal() | Curăță ecranul LCD și desenează interfața inițială de selecție a modului de joc (1. Free Roll / 2. Barbut). |
| ruleazaScroll(String text) | Implementează o funcție non-blocking (fără delay) care preia un string lung și îl defilează continuu de la dreapta la stânga pe ultimul rând al ecranului LCD (stil marquee). |
| scuturaPahar(int jucator) | Blochează input-urile noi, afișează pe ecran jucătorul curent și trimite o secvență de comenzi rapide și agresive către servomotor pentru a amesteca zarurile fizice. La final, trece sistemul în starea de așteptare procesare AI. |
Biblioteci folosite:
| Biblioteca | Rol |
|---|---|
| Arduino.h | Funcții de bază ale framework-ului Arduino (GPIO, millis, delay, manipulare string-uri). |
| esp_camera.h | Driver-ul oficial Espressif pentru configurarea și capturarea de cadre (framebuffer) folosind senzorul camerei OV2640. |
| WiFi.h | Gestionarea conexiunii wireless și crearea serverului web local (clasa WiFiServer). |
| Wire.h | Implementarea protocolului de comunicare I2C necesar pentru ecranul LCD. |
| LiquidCrystal_I2C.h | Controlul ecranului LCD 2004 (afișare text, gestionare cursoare, iluminare de fundal). |
| ESP32Servo.h | Generarea de semnale PWM hardware compatibile cu arhitectura ESP32 pentru controlul precis al servomotorului SG90. |
2. Componenta Inteligență Artificială (Python)
Partea de recunoaștere vizuală este scrisă în Python și rulează pe un PC conectat la aceeași rețea Wi-Fi. Scriptul acționează ca un “creier extern”: interoghează constant ESP32-ul pentru a afla când s-au aruncat zarurile, descarcă fotografia, numără punctele negre și trimite scorul (sau verdictul meciului) înapoi către plăcuță.
Functii principale implementate:
| Functie | Rol |
|---|---|
| numara_puncte_zaruri() | Reprezintă inima algoritmului AI. Execută un request în gol pentru a goli memoria buffer a camerei (Stale Frame Flush), descarcă o imagine nouă, aplică filtre de preprocesare (Grayscale, Median Blur, Normalize) și folosește Blob Detection pentru a număra punctele zarurilor de pe masă. |
| Bucla Principala (while True) | Logica principală de arbitraj. Interoghează la fiecare 0.5 secunde ruta ”/status” a ESP32-ului. În funcție de modul de joc detectat (Free Roll sau Barbut), alocă punctele jucătorilor, decide câștigătorul în meciurile de tip 1vs1 și formulează request-uri HTTP pe ruta ”/update” pentru a debloca ecranul plăcuței cu noile date. |
Biblioteci folosite:
| Biblioteca | Rol |
|---|---|
| cv2 (OpenCV) | Bibliotecă avansată de Computer Vision. Folosită pentru transformări de imagine, eliminarea zgomotului, îmbunătățirea contrastului și detectarea formelor circulare (SimpleBlobDetector). |
| numpy | Manipularea rapidă a array-urilor de date necesară pentru a converti fluxul de biți descărcat prin HTTP într-o matrice de pixeli procesabilă de OpenCV. |
| requests | Realizarea de cereri HTTP (GET) către serverul ESP32 pentru obținerea statusului, descărcarea fotografiilor JPEG și trimiterea scorurilor. |
| time | Gestionarea pauzelor (sleep) pentru a permite zarurilor fizice să se stabilizeze înainte de capturarea imaginii și pentru a preveni supraîncărcarea serverului Wi-Fi cu cereri. |
Rezultate Obținute
Sistemul propus îndeplinește obiectivul principal de a automatiza complet aruncarea și arbitrarea unui joc cu zaruri, integrând cu succes acționarea mecanică, comunicarea IoT și viziunea artificială (Computer Vision).
Rezultatele principale:
- problema resetărilor bruște (brownouts) ale plăcuței ESP32-CAM a fost eliminată complet prin proiectarea unei arhitecturi hardware cu alimentare duală (izolarea circuitului de forță al motorului de cel logic).
- algoritmul de Blob Detection din Python recunoaște zarurile cu o precizie ridicată, fiind imun la zgomot vizual (umbre, praf) datorită filtrelor de preprocesare (Blur, Normalizare) și calibrării stricte a parametrilor de formă și arie.
- problema memoriei tampon hardware a camerei OV2640 (livrarea unui “stale frame” din trecut) a fost rezolvată elegant printr-o tehnică software de golire a buffer-ului înainte de captura finală.
- interfața LCD 20×4 este interactivă și curată, oferind navigare prin dublu-click, animații de text defilant (marquee) și actualizări în timp real ale scorului.
- logica de arbitraj funcționează perfect în ambele moduri de joc (Free Roll și Barbut), gestionând automat rândul jucătorilor și decizia finală fără intervenție umană.
Limitări așteptate:
- sensibilitate la iluminarea ambientală extremă; deși algoritmul normalizează contrastul, o schimbare drastică a luminii din cameră poate necesita recalibrarea camerei sau a scriptului Python.
- latență inerentă a fluxului de joc (aprox. 4-5 secunde pe aruncare) cauzată de timpii necesari pentru scuturarea mecanică completă, stabilizarea fizică a zarurilor și transferul imaginii prin protocol HTTP.
Concluzii
Acest proiect demonstrează o soluție practică și creativă de îmbinare a sistemelor integrate (embedded) cu algoritmii de analiză a imaginilor rulați pe o arhitectură externă. Delegarea sarcinii complexe de procesare video către un PC (Python/OpenCV) permite sistemului ESP32-CAM să ruleze rapid și fără blocaje, ocupându-se exclusiv de sarcinile de timp real: achiziția datelor, controlul motorului, citirea butoanelor și actualizarea display-ului.
Dezvoltarea interfeței duale hardware-software a transformat un simplu cititor de puncte într-o consolă interactivă de barbut, rezultând un sistem robust care poate constitui oricând baza pentru automatizarea altor board games sau proiecte de robotică vizuală.
Bibliografie/Resurse
Resurse Hardware
- ESP32-CAM & AI-Thinker: Documentația oficială și pinout-ul modulului ESP32-CAM pentru maparea corectă a conexiunilor și a alimentării duale. (https://docs.ai-thinker.com/en/esp32-cam)
- Modul I2C PCF8574 (LCD): Datasheet-ul expander-ului I/O pentru a înțelege adresarea (ex. 0x27) și remaparea pinilor SDA/SCL pe microcontroller.
Resurse Software
Cod Arduino
- Arduino Core for ESP32: Referința oficială Espressif pentru funcțiile de bază (WiFi, WebServer, GPIO, Timers). (https://docs.espressif.com/projects/arduino-esp32/)
- Biblioteca LiquidCrystal_I2C: Documentația bibliotecii folosite pentru afișarea textului static și implementarea funcției custom de defilare (marquee) pe LCD-ul 2004. (https://github.com/johnrickman/LiquidCrystal_I2C)
Cod Python
- OpenCV (Python): Documentația modulului cv2, în mod specific secțiunea despre preprocesarea imaginilor (cv2.medianBlur, cv2.normalize) și configurarea algoritmului cv2.SimpleBlobDetector_Params pentru recunoașterea punctelor zarurilor. (https://docs.opencv.org/)
- Python Requests: Documentația pentru manipularea cererilor HTTP (GET) și gestionarea timeout-urilor în comunicarea Client-Server. (https://requests.readthedocs.io/)