Topic: Sarcina lucru individual | AI.PIP21.1 Programare independentă de platformă | ELSE

    • Announcements Forum
    • Curicula Fișier
      Cursanții trebuie
      Setează ca activitate completată
    • Fișa Fișier
      Cursanții trebuie
      Setează ca activitate completată
    • Materiale teoretice Dosar
      Cursanții trebuie
      Setează ca activitate completată
    • Teorie 1 2 Lucrari practice 1 2 3 4 5 Lucru individual ... Evaluări ...
    • Cursanții trebuie
      Setează ca activitate completată

      Proiect web cu date în timp real dintr-o bază de date locală

      Studentul poate alege traseul Java sau traseul Python pentru implementare.
      Obiective
      • realizarea unui flux end-to-end: achiziție date de pe STM32 → port serial → DB locală → interfață web;
      • afișarea datelor în timp real (grafic + tabel), cu latență percepută ≤ 2 secunde;
      • documentarea arhitecturii și a pașilor de rulare pentru traseul ales (Java sau Python).
      Alegeți unul dintre trasee
      1. Traseul A — Java: citire serial + API web + acces DB implementate în Java (ex.: Spring Boot, JPA). Frontend HTML/CSS/JS.
      2. Traseul B — Python: citire serial + API web + acces DB implementate în Python (ex.: FastAPI/Flask, SQLAlchemy). Frontend HTML/CSS/JS.
      Cerințe minime (comune ambelor trasee)
      • DB locală cu tabel minim measurements(id, value, unit, source, created_at);
      • API care oferă datele: GET /api/data?limit=N și endpoint „live” (WebSocket sau SSE / polling 1s);
      • UI HTML/CSS/JS cu un chart și un tabel ce se actualizează automat;
      • Loguri & eroare: mesaje clare la port indisponibil, DB căzut, date invalide;
      • README cu pașii de rulare, configurări (port serial, DSN) și diagrama arhitecturii.
      Traseul A — Java
      Stack propus: Spring Boot (REST/WebSocket), JPA/Hibernate (JDBC), driver DB (SQLite/PostgreSQL/MySQL), librărie serial (ex.: com.fazecast:jSerialComm), Chart în front-end (Chart.js).
      1. Serial: citește din port (baud/paritate/stop) și inseră în DB (batch sau per eșantion).
      2. Persistență: entitate Measurement + Repository (JPA), migrare inițială.
      3. API: GET /api/data (ultimele N valori) + /ws (push live) sau /sse.
      4. UI: pagina web statică servită de Spring; JS pentru chart și actualizări.
      5. Test: mod „simulator” dacă portul nu e conectat (generează valori).
      Notă: dacă preferați, citiți serial-ul într-un thread dedicat sau cu programare reactivă.
      Traseul B — Python
      Stack propus: FastAPI (REST/WebSocket) sau Flask (+ Flask-SocketIO), SQLAlchemy, pyserial, driver DB (SQLite/PostgreSQL/MySQL), Chart în front-end (Chart.js).
      1. Serial: pyserial citește cadrele STM32 și le persistă în DB.
      2. Persistență: model ORM Measurement, migrare inițială.
      3. API: GET /api/data + /ws (SocketIO/WebSocket) sau /sse.
      4. UI: pagină statică servită de framework sau Nginx; JS pentru chart și actualizări.
      5. Test: „simulator” de date dacă STM32 nu e prezent.
      Notă: FastAPI oferă nativ tipare asincrone utile pentru conexiuni live.
      Arhitectură (schematică textuală)
      Traseul A (Java): STM32 → Serial → Java (jSerialComm) → DB → Java REST/WS → HTML/CSS/JS (Chart)
      Traseul B (Python): STM32 → Serial → Python (pyserial) → DB → Python REST/WS → HTML/CSS/JS (Chart)
      Etape recomandate
      1. Schema DB: creați measurements(id PK, value REAL, unit TEXT, source TEXT, created_at TIMESTAMP).
      2. Achiziție serial: configurați baud/paritate/stop; validați și normalizați unitățile.
      3. Persistență: inserați cu tranzacții; index pe created_at.
      4. API: implementați GET /api/data?limit=N + WebSocket/SSE pentru live.
      5. UI: tabel + grafic (ultimele N puncte) cu auto-actualizare.
      6. Testare: date reale + mod simulator; test la căderi (port/DB).
      7. Documentare: README cu diagrame, setări și comenzi de rulare.
      Livrabile
      • cod sursă pentru traseul ales (Java sau Python) + front-end HTML/CSS/JS;
      • fișiere SQL/migrări; configurări (.env / application.properties / settings.py);
      • README cu pași, diagrame, explicații arhitecturale, mod simulator;
      • screenshoturi/clip scurt care evidențiază actualizarea în timp real.
      Criterii de evaluare (100p)
      • Funcționalitate end-to-end (serial→DB→API→UI): 40p
      • Real-time (push/poll ≤ 1s, reactivitate UI): 20p
      • Calitatea codului (structură, erori, loguri, validare): 20p
      • UI/UX (claritate, responsive minim, chart lizibil): 10p
      • Documentare (README, diagrame, reproducibilitate): 10p
      Cuvinte-cheie: STM32 Serial / UART DB locală Java Spring Boot JPA / JDBC Python FastAPI / Flask WebSocket / SSE Chart ORM Validation
      WebSocket/SSE: canale pentru actualizări live; alternativ, polling la 1s.
      ORM: mapare obiect–relațională (JPA/Hibernate în Java; SQLAlchemy în Python).
      Validation: verificarea câmpurilor/intervalelor la ingestie și expunere.
      Checklist de acceptanță
      • aplicația pe traseul ales pornește și creează schema DB la nevoie;
      • datele sosesc din serial și apar în DB (loguri vizibile);
      • UI afișează tabel + grafic, care se actualizează continuu;
      • fall-back „simulator” funcționează fără STM32;
      • README permite rularea proiectului pe un alt calculator, pas cu pas.
    • Proiect individual Sarcină de lucru
      Cursanții trebuie
      Setează ca activitate completată

       

◄Lucrarea practică 5
►Evaluări