Proiectul constă într-un joc de tip space shooter destul de clasic, în care utilizatorul controlează o navă spațială și trebuie să distrugă/ocolească asteroizii generați aleatoriu. Un element de noutate notabil este reprezentat de utilizarea unui generator de numere pseudo-aleatoare bazat pe entropie hardware. Datele de la senzorul MPU6050 (temperatură, accelerație, viteză unghiulară) și zgomotul analogic obținut din ADC (de la o antenă) sunt utilizate ca surse de entropie. Acestea sunt combinate pentru a obține niște valori cât mai aleatoare.

În schema de mai sus, se observă destul de ușor componentele principale ale proiectului.

Pentru a stabili ce biți din datele de la senzori/antenă sunt ideale pentru RNG-ul meu, am efectuat niște experimente. Am citit datele de la senzori/antenă de câteva mii de ori și am calculat niște metrici de baza pentru RNG, precum entropie, autocorelație și runs.

Măsoară cât de echilibrat este un bit:

$$ H(X) = -p_0 \log_2(p_0) - p_1 \log_2(p_1), \quad \begin{cases} p_0 = P(X=0) \\ p_1 = P(X=1) \end{cases} $$

Măsoară cât de asemănător este un bit cu următorul bit din secvență.

$$ \mathrm{Autocorr} = \frac{\sum_{i=0}^{N-2} I(x_i = x_{i+1})}{N-1}, \quad I(x_i = x_{i+1}) = \begin{cases} 1, & x_i = x_{i+1} \\ 0, & x_i \neq x_{i+1} \end{cases} $$

Măsoară cât de des se schimbă secvența de 0 și 1.

$$ R = \frac{1 + \sum_{i=1}^{N-1} I(x_i \neq x_{i-1})}{N} $$

După analizarea acestor metrici, am ales să folosesc doar anumiți biți pentru RNG, ținând cont de criteriile de mai jos:

$$ H(X) > 0.98, \quad P(X=1) \in (0.45, 0.55), \quad \mathrm{Autocorr} \in (0.45, 0.55), \quad R \in (0.45, 0.55) $$

Interesant ar fi și faptul că restricția pe runs nu a micșorat și mai mult mulțimea biților cu rng bun, deci se poate considera că runs este redundant față de constrângerile deja impuse.

Biții aleși sunt:

• accel_y_low - biții: [7, 6, 5, 4, 3, 2]
• accel_z_low - biții: [6, 5, 4, 3, 2]
• gyro_y_low - biții: [4, 3, 2, 1, 0]
• gyro_x_low - biții: [4, 3, 2, 1, 0]
• accel_x_low - biții: [6, 5, 4, 3, 2]
• gyro_z_low - biții: [4, 3, 2, 1, 0]
• antenă - bits: [0]

După cum se observa din rezultatele de mai sus, niciun bit din cadrul senzorului de temperatură nu întrunește condițiile impuse. Datele acestuia vor fi utilizate ulterior, în cadrul formulei ce generează biți în mod aleator. În plus, se remarcă faptul că antena nu contribuie semnificativ.

Pentru a avea niște biți și mai amestecați, aplic o transformare finala biților de la senzori. Aceasta se face în blocuri de câte 32 de biți și implică amestecarea cu o stare internă folosind XOR și rotirea biților obținuți. Seed-ul de la care pornește starea internă este obținut din datele senzorului de temperatură.

more_rng = (rng_state * 1103515245UL + 12345UL);
rng_state ^= more_rng;
rng_state = (rng_state << 7) | (rng_state >> 25);
rng_state ^= sample;

Listă componente principale:

Schemă circuit:

Conexiuni:

Important de menționat este și faptul că au fost utilizate divizoare de tensiune pentru a lega display-ul de placă, deoarece display-ul are logică de 3,3V, iar placa de 5V. Ulterior, divizoarele de tensiune au fost înlocuite cu un convertor de nivel logic, pentru a evita aglomerarea inutilă a breadboard-ului cu componente.

Mediu de dezvoltare utilizat: PlatformIO

La pornire, software-ul populează buffer-ul circular cu biți de la senzori. În acest timp, pe ecran este afișat o bară de încărcare. După ce buffer-ul circular este plin, programul intră în bucla principală, unde citește inputul utilizatorului (de la potențiometrul liniar) și actualizează ecranul pentru joc. Jucătorul primește feedback audio de la buzzer când distruge inamici, când îi ratează și când pierde. În cazul în care jucătorul pierde, jocul revine la starea inițială.

În cadrul proiectului, am utilizat următoarele biblioteci:

• Adafruit GFX Library - funcții primitive pentru desenare
• Adafruit ILI9341 - driver specific necesar pentru controlarea display-ului

• Timere, PWN pentru controlul buzzer-ului
• ADC pentru citirea inputului utilizatorului de la potențiometrul liniar, dar și pentru antenă
• I2C pentru interacțiunea cu MPU6050
• SPI pentru interacțiunea cu Display-ul ILI9341

Senzorii nu au necesitat calibrare, întrucât scopul proiectului nu era să obțină date exact de la senzori. Mult mai semnificativă este partea ce implică citirea repetată a senzorilor, pentru a obține niște biți cu valori pseudoaleatorii.

O optimizare făcută a constat în adăugarea unui strat suplimentar de RNG valorilor senzorilor. Am considerat că doar biții care se schimbă cel mai des de la senzori nu erau suficient pentru niște numere pseudoaleatoare. Astfel, peste biții de la senzori, am adăugat un generator liniar congruențial, inspirat din implementarea clasică a funcției rand() din biblioteca standard C. Valoarea generată de LCG este combinată prin XOR cu starea internă a generatorului, urmată de o rotație de biți, după care rezultatul este din nou mixat cu biți de la senzori. Acest proces ajută la producerea unui output mai impredictibil.

• am implementat jocul în sine
• am adăugat feedback audio de la buzzer

Demonstrație video: Link YouTube

• am implementat formula finală pentru RNG
• am adăugat un loading bar pentru citirea senzorilor RNG

• am implementat citirea senzorilor pentru RNG
• am utilizat un buffer circular pentru salvarea biților buni de la senzori
• am ales o formulă finală pentru RNG

Am finalizat partea introductivă din cadrul documentației, dar și schema circuitului.

Am adăugat teoria de RNG în documentație și am evaluat datele primite de la senzori. Am asamblat piesele, am testat componentele.

Implementare rand

LCG

PRNG