Show page

Differences

This shows you the differences between two versions of the page.

--- pm:prj2025:avaduva:alex.dobritan [2025/05/26 00:01]
alex.dobritan [Software Design]
+++ pm:prj2025:avaduva:alex.dobritan [2025/05/27 21:53] (current)
alex.dobritan [Hardware Design]
@@ Line 73: / Line 73: @@
 | **Placă compatibilă Arduino Uno R3**  | https://ardushop.ro/ro/plci-de-dezvoltare/2282-placa-de-dezvoltare-uno-r3-compatibil-arduino-6427854027122.html  |
 | **Display OLED 128x64**  | https://ardushop.ro/ro/display-uri-si-led-uri/1577-display-oled-096-i2c-albastru-jmd096d-1-6427854023469.html     |
-| **Senzor lumină TEMT6000**     | https://ardushop.ro/ro/senzori/452-senzor-lumina-ambientala-temt6000-6427854005120.html          |
 | **Buzzer pasiv** | https://ardushop.ro/ro/componente-discrete/1724-1283-buzzer.html#/333-tip-pasiv  |
 | **4x butoane**   | https://ardushop.ro/ro/butoane--switch-uri/713-buton-mic-push-button-trough-hole-6427854009050.html    |
@@ Line 109: / Line 108: @@
 **I2C** – pentru comunicarea cu ecranul OLED (pinii A4 și A5)
-**ADC (convertor analog-digital)** – pentru citirea valorii de la senzorul de lumină (pinul A0)
 **PWM (modulare a lățimii impulsului)** – pentru redarea de sunete prin buzzer (pinul D6)
@@ Line 130: / Line 127: @@
-<note tip>
+==== Mediu de Dezvoltare ====
-Descrierea codului aplicaţiei (firmware):
-  * mediu de dezvoltare (if any) (e.g. AVR Studio, CodeVisionAVR)
+Proiectul este dezvoltat în Arduino IDE, utilizând limbajul C++. Arduino IDE oferă un mediu prietenos pentru programare, testare și încărcare rapidă a codului pe placă. Am folosit bibliotecile standard Arduino, precum și unele biblioteci externe pentru controlul componentelor I2C și OLED.
-  * librării şi surse 3rd-party (e.g. Procyon AVRlib)
-  * algoritmi şi structuri pe care plănuiţi să le implementaţi
+Testarea și depanarea au fost realizate prin monitorul serial și feedback vizual/audio.
-  * (etapa 3) surse şi funcţii implementate
-</note>
 ==== Motivarea alegerii bibliotecilor ====
@@ Line 166: / Line 161: @@
 - **GPIO** – pentru citirea butonului.
-- **ADC** (Analog-to-Digital Conversion) – pentru senzorul de lumină TEMT6000, prin analogRead().
+- **PWM** – buzzer: redarea de tonuri diferite prin tone().
@@ Line 178: / Line 173: @@
 - Comportamentul în timp real a fost verificat în sesiuni complete de testare.
+==== Scheletul Proiectului și Interacțiunea Funcționalităților: Joc Tetris pe Arduino ====
+=== Arhitectura Principală ===
+Proiectul implementează un joc clasic Tetris pe un microcontroller Arduino, utilizând un display OLED SSD1306 și butoane fizice. Logica principală este centralizată în **loop()**, gestionând stările jocului și interacțiunile.
+== Inițializare și Intro ==
+**setup()**: Configurează pinii hardware (butoane, speaker) → Inițializează comunicarea serială și display-ul OLED (**display.begin()**) → Afișează ecrane introductive: "**Loading...**" → "**TETRIS**" → logo-ul **mantex_logo** (din `PROGMEM`) → Inițializează generatorul de numere aleatoare (**randomSeed()**) → Generează prima piesă (**nextType** = **random(TYPES)**; **generate()**) → Setează timer-ul principal și variabilele de debounce → starea principală a jocului.
+== Starea Principală (gestionată prin flag-ul boolean `isGameOver` și timer-ul `timer`): ==
+  * **isGameOver**: monitorizează dacă jocul s-a încheiat.
+    *   Dacă `true`: afișează "**GAME OVER**" și scorul (**display.println(F("GAME OVER"))**; … **display.print(score)**;).
+  * **timer** și **interval**: Controlează căderea automată a pieselor.
+    *   Dacă jocul nu este terminat (`!isGameOver`):
+        *   **checkLines()**: Verifică și elimină liniile complete.
+        *   **refresh()**: Redesenează starea curentă a jocului (grilă, piesa curentă, scor, piesa următoare).
+        *   **nextCollision()**: Verifică dacă piesa curentă a atins obstacol.
+            *   Dacă da: fixează piesa pe grilă (`grid[…]=1;`), generează o nouă piesă (**generate()**).
+            *   Verifică imediat dacă noua piesă cauzează Game Over (**nextHorizontalCollision(piece, 0) && pieceY == 0**).
+            *   Dacă nu: piesa coboară (`pieceY++`).
+== Sistem de Evenimente: ==
+  * **digitalRead(left)**: Deplasează piesa la stânga (**pieceX--**) + verificare coliziune (**!nextHorizontalCollision(piece, -1)**) + feedback sonor (**tone(SPEAKER_PIN, click...)**).
+  * **digitalRead(right)**: Deplasează piesa la dreapta (**pieceX++**) + verificare coliziune (**!nextHorizontalCollision(piece, 1)**) + feedback sonor.
+  * **digitalRead(change)**: Rotește piesa (**rotation++** sau `rotation = 0`) + verificare validitate rotație (**canRotate()**) + actualizează forma (**copyPiece()**) + feedback sonor.
+  * **digitalRead(restart)**: Resetează grila, scorul, generează o nouă piesă, resetează **isGameOver**.
+  * **Cădere Automată Piesă** (bazată pe **timer > interval**): Declanșează logica de avansare a piesei (**pieceY++** sau fixare și generare nouă piesă).
+=== Fluxul Principal de Execuție ===
+**setup()** → Afișare ecrane introductive ("**Loading...**", "**TETRIS**", **mantex_logo**) →
+  * **Buclă principală loop()**:
+    *   Dacă **isGameOver** este `true`:
+        *   Afișează ecranul "**GAME OVER**" cu scorul final.
+    *   Dacă **isGameOver** este `false` (Joc Activ):
+        *   Verificare Timer Cădere Piesă (**millis() - timer > interval**):
+            *   **checkLines()** → **refresh()** → Verificare coliziune pentru piesa nou generată (potențial Game Over).
+            *   Dacă **nextCollision()** este `true`: Fixează piesa, **generate()**.
+            *   Altfel: **pieceY++**.
+            *   Resetează **timer**.
+        *   Verificare Butoane:
+            *   **digitalRead(left)** → Acțiune mișcare stânga + **refresh()**.
+            *   **digitalRead(right)** → Acțiune mișcare dreapta + **refresh()**.
+            *   **digitalRead(change)** → Acțiune rotație + **refresh()**.
+            *   **digitalRead(restart)** → Acțiune restart joc + **refresh()**.
+=== Modul de Validare a Funcționalităților ===
+== Testare unitară pe componente: ==
+  * Fiecare funcție de desenare (**drawGrid()**, **drawPiece()**, **drawLayout()**, **drawNextPiece()**) testată vizual pe display-ul OLED.
+  * Butoanele (**left**, **right**, **change**, **restart**) testate individual, observând răspunsul piesei și feedback-ul sonor. **Serial Monitor** utilizat pentru debug.
+  * Logica de detecție a coliziunilor (**nextCollision()**, **nextHorizontalCollision()**) și rotație (**canRotate()**, **getMaxRotation()**) verificate prin interacțiune directă.
+== Testare integrată: ==
+  * Sesiuni complete de joc pentru verificarea evoluției scorului, eliminării liniilor (**breakLine()**) și tranziției la "**Game Over**".
+  * Test de rezistență cu apăsări rapide ale butoanelor pentru debounce.
+  * Validarea funcției de restart și reluarea corectă a jocului.
+=== Calibrarea Elementelor de Senzoristică (Adaptat pentru Parametrii de Joc) ===
+Parametrii de joc, nu senzori fizici, definesc experiența.
+== Proces de calibrare experimentală (pentru parametrii de joc): ==
+  * Măsurători (teste de joc) cu diferite valori pentru **interval** (viteza de cădere).
+  * Valoarea **interval = 250** (ms) aleasă pentru un echilibru inițial.
+  * Debounce-ul butoanelor și **delay(100)** pentru sunete ajustate empiric.
+== Justificarea pragului (pentru parametrii aleși): ==
+  * **interval = 250**: Oferă un ritm de joc antrenant, dar jucabil.
+  * Dimensiunile **SIZE**, **MARGIN_TOP**, **MARGIN_LEFT**: Optimizate pentru lizibilitatea pe display-ul 128x64.
+  * Debounce-ul (flag-uri `b1, b2, b3` și `delayer`): Reduce acțiunile multiple la o singură apăsare.
+=== Optimizări Realizate ===
+== Optimizări de Performanță ==
+Cea mai importantă abordare este utilizarea **millis()** pentru timer-ul jocului (**timer**), permițând procesarea input-ului între căderile pieselor. Bitmap-ul **mantex_logo** este stocat în `PROGMEM`. Display-ul este reîmprospătat prin **refresh()** (incluzând **display.clearDisplay()**).
+== Optimizări de Cod și Arhitectură ==
+Structura codului este modulară (ex: **drawGrid()**, **checkLines()**, **generate()**, **copyPiece()**). Utilizarea constantelor (`#define`, `const`) îmbunătățește lizibilitatea. Funcția **copyPiece()** centralizează logica formei pieselor.
+== Optimizări de UX ==
+Feedback audio (**tone()**) pentru acțiuni și evenimente (**breakLine()**). Afișarea piesei următoare (**drawNextPiece()**) și a scorului. Sistem de debounce pentru butoane. Funcția de restart include protecție la apăsare lungă.
 ===== Rezultate Obţinute =====
-<note tip>
+Proiectul a fost finalizat cu succes, rezultând într-o versiune funcțională a jocului Tetris pe Arduino. Am implementat mecanismele de bază: generarea și controlul pieselor, detecția coliziunilor, eliminarea liniilor, scorul și "**Game Over**". Sistemul rulează pe hardware, butoanele răspund, iar display-ul afișează corespunzător.
-Care au fost rezultatele obţinute în urma realizării proiectului vostru.
-</note>
 ===== Concluzii =====
+Realizarea acestui Tetris a fost o experiență valoroasă în programarea embedded și designul de jocuri simple. Am experimentat cu gestionarea stărilor, interacțiunea hardware și afișarea grafică. Procesul de debugging, în special pentru logica de coliziune și rotație, a fost o lecție importantă.
 ===== Download =====
@@ Line 204: / Line 287: @@
 ===== Bibliografie/Resurse =====
-<note>
+  * https://github.com/lukecyca/TetrisThemeArduino/tree/master - muzica fundal
-Listă cu documente, datasheet-uri, resurse Internet folosite, eventual grupate pe **Resurse Software** şi **Resurse Hardware**.
-</note>
+  * https://circuitdigest.com/microcontroller-projects/creating-tetris-game-with-arduino-and-oled-display - inspiratie structura cod
-<html><a class="media mediafile mf_pdf" href="?do=export_pdf">Export to PDF</a></html>