Autorul poate fi contactat la adresa: Login pentru adresa

Proiectul consta in implementarea clasicului joc PONG ce simuleaza un joc de tenis de masa. Acesta este un joc de 2 persoane ce are ca scop realizarea unui numar cat mai mare de puncte obtinut atunci cand oponentul nu reuseste sa loveasca mingea. Astfel, fiecare jucator va avea o paleta ce se va misca pe verticala cu ajutorul careia va trebui sa nu lase mingea sa treaca mai departe.

Jocul va fi afisat pe o matrice de led-uri. Pentru ca jucatorii sa poate misca paletele vor exista 4 butoane(pentru cele 2 directii : sus si jos).
Va mai exista un buton pentru schimbarea nivelului de dificultate si unul pentru pornirea/resetarea jocului. Scorul va fi afisat
cu ajutorul a 2 afisaje cu 7 segmente.

Am ales sa realizez acest joc intrucat de cand eram mic copil eram pasionat de jocuri, iar PONG se enumera printre primele jocuri ce mi-au
captat atentia in acea perioada.

La ce este folosit?
Board-ul este folosit pentru afisarea jocului pe matricea de leduri integrata in acesta.
Cum functioneaza?
Pentru adresarea fiecarui led matricea se foloseste de un shift register.
Pini folositi pentru conectare board cu matricea de leduri

/* Conectori placa - Conectori matrice board */
PIN1 (EXT_CON1) ---- SR-SCK (EXT_CON1)
PIN2 (EXT_CON1) ---- SR-CATCH (EXT_CON1)
PIN3 (EXT_CON1) ---- SERIAL-DATA (EXT_CON1)
PIN5 (EXT_CON1) ---- VCC (EXT_CON1)
PIN6 (EXT_CON1) ---- GND (EXT_CON1)

Pe langa sursa main.c in care se seteaza pinii de intrare/iesire si se asculta evenimentele mai exista 2 surse:
* score.c folosita pentru afisarea scorului
* game.c folosita pentru simularea jocului

Pentru afisarea scorului m-am folosit de 2 structuri:
* digit_led ce contine 2 campuri (unul cu portul ledului si unul cu pin-ul la care este conectat)
* digit ce contine un vector de structuri digit_led si dimensiunea vectorului. Aceasta structura este folosita pentru a retine ledurile ce
trebuiesc aprinse pentru formarea unei cifre

De asemenea am definit urmatoarele functii :

void initialize_score(void);				// folosita pentru initializarea scorului
void initialize_digits(void);				// folosita pentru initializarea cifrelor
void reset_score(void);				        // folosita pentru resetarea scorului
void reset_table(uint16_t);				// folosita pentru resetarea scorului de pe o anumita tabela
void set_digit(uint16_t, uint16_t);			// folosita pentru a seta o cifra pe o anumita tabela
void increase_score(uint16_t);				// folosita pentru a creste valoarea unei cifre dintr-o tabela

Initial se apeleaza functia initialize_score ce seteaza pinii si porturile pentru fiecare led, seteaza vectorul de leduri ce trebuiesc aprinse pentru
fiecare cifra in parte (printr-un apel initialize_digits) si apoi seteaza scorul pe afisaj la 0-0 (cu ajutorul functiei set_digit).

Mai departe, daca se doreste schimbarea scorului de pe o anumita tabela se face apel la functia increase_score ce creste valoarea scorului
si apeleaza set_digit setarea cifrei pe afisaj.

In cazul in care se apasa butonul de RESET se apeleaza functia reset_score ce va stinge initial toate ledurile, apoi le va aprinde pe
cele ce formeaza 0-0.

Pentru simularea jocului m-am folosit de un vector bidimensional de dimensiune egala cu matricea de leduri. Aceasta putea contine doar
2 valori(1 - led aprins, 0 led stins) si initial avea forma :

0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 1
1 0 0 1 0 0 0 1
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

Astfel fiecare paleta era reprezentata prin 3 leduri aprinse, in timp ce mingea era reprezentata printr-un led aprins.

Pentru a retine pozitia paletelor/mingii m-am folosit de o structura numita position

typedef struct{
	uint16_t row;       // linia pe care se afla centrul obiectului
	uint16_t column;    // coloana pe care se afla centrul obiectului
} position;

Functiile implementate pentru realizarea jocului sunt :

void start_game(void);				// initializeaza scorul si matricea de leduri si porneste jocul
void send_data(void);				// trimite date matricei de leduri pe baza vectorului bidimensional
void update_matrix(void); 			// updateaza vectorul bidimensional
void move_paddle_up(uint16_t);		        // muta paleta jucatorului in sus
void move_paddle_down(uint16_t);	        // muta paleta jucatorului in jos
void move_ball(void);				// determina directia in care se va duce mingea si updateaza pozitia acesteia
void reset_game(uint16_t);			// reseteaza jocul

Initial se face apel la functia start_game ce seteaza scorul la 0-0, initializeaza vectorul bidimensional cu pozitiile paletelor si a mingii
si trimite datele la matricea de leduri printr-un apel send_data.

La fiecare interval de ceas (500ms) se verifica daca a fost apasat vreun buton executandu-se comanda specifica lui si
se calculeaza si updateaza noua pozitie a mingii.

Pentru a calcula urmatoarea pozitie a mingii se retine vechea pozitie intr-o variabila si se calculeaza traiectoria mingii pe baza celor 2 valori.
De asemenea se verifica daca mingea loveste limitele terenului de joc, daca a intrat in poarta, sau daca a lovit paleta jucatorului.

In cazul in care mingea a intrat in poarta se updateaza scorul cu ajutorul functiei increase_score si se reseteaza matricea de leduri.

Trebuia sa fiu mai atent cand am lipit firele si sa imi fac un plan bine definit dinainte. Mi-ar fi fost mult mai usor daca fiecare afisaj avea
portul lui si nu era o combinatie din mai multe. De asemenea, initial cand am lipit componentele si am facut circuitul nu am fost atent
si am privit schema in oglinda. Mi-am dat seama abea atunci cand a trebuit sa pun bootloader-ul si am fost nevoit sa dezlipesc toate componentele si sa
o iau de la capat. (lucru destul de frustrant ce mi-a taiat din entuziasmul initial avut pentru proiect)

Cred ca proiectul ar fi fost mult mai interesant daca era pe primul semestru si aveam mai mult timp liber pentru el. Din pacate a fost o perioada
prea aglomerata si nu am reusit sa il duc pana la capat. Probabil daca alegeam placuta cu cablaj foto mi-ar fi fost mult mai usor si as fi putut sa
termin totul cu bine.

Surse proiect
Schema proiect