.. note:: Ciao, benvenuto nella SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasts Community su Facebook! Approfondisci Raspberry Pi, Arduino ed ESP32 insieme ad altri appassionati. **Perché unirti?** - **Supporto esperto**: Risolvi i problemi post-vendita e le sfide tecniche con l'aiuto della nostra community e del nostro team. - **Impara e condividi**: Scambia suggerimenti e tutorial per migliorare le tue competenze. - **Anteprime esclusive**: Ottieni accesso anticipato agli annunci di nuovi prodotti e alle anteprime. - **Sconti speciali**: Goditi sconti esclusivi sui nostri prodotti più recenti. - **Promozioni festive e omaggi**: Partecipa a concorsi e promozioni festive. 👉 Pronto a esplorare e creare con noi? Clicca su [|link_sf_facebook|] e unisciti oggi! .. _3.1.13_c_pi5: 3.1.13 GIOCO - NotNot ============================== Introduzione ------------------- In questo progetto, realizzeremo un dispositivo di gioco interessante, che chiameremo “Not Not”. Durante il gioco, la matrice a punti aggiornerà casualmente una freccia. Il tuo compito è premere il pulsante nella direzione opposta alla freccia entro un tempo limitato. Se il tempo scade, o se viene premuto il pulsante nella stessa direzione della freccia, sei fuori. Questo gioco può davvero esercitare il tuo pensiero inverso, e ora facciamo un tentativo? Componenti necessari ------------------------------ In questo progetto, abbiamo bisogno dei seguenti componenti. .. image:: ../img/list_GAME_14_NotNot.png :align: center È sicuramente conveniente acquistare un kit completo, ecco il link: .. list-table:: :widths: 20 20 20 :header-rows: 1 * - Nome - ELEMENTI IN QUESTO KIT - LINK * - Kit Raphael - 337 - |link_Raphael_kit| Puoi anche acquistarli separatamente dai link sottostanti. .. list-table:: :widths: 30 20 :header-rows: 1 * - INTRODUZIONE COMPONENTE - LINK PER L'ACQUISTO * - :ref:`cpn_gpio_extension_board` - |link_gpio_board_buy| * - :ref:`cpn_breadboard` - |link_breadboard_buy| * - :ref:`cpn_wires` - |link_wires_buy| * - :ref:`cpn_dot_matrix` - |link_led_matrix_buy| * - :ref:`cpn_button` - |link_button_buy| Schema elettrico ------------------------ ============ ======== ======== ==== T-Board Name physical wiringPi BCM GPIO22 Pin 15 3 22 GPIO23 Pin 16 4 23 SPIMOSI Pin 19 12 MOSI SPICE0 pin 24 10 CE0 SPISCLK Pin 23 14 SCLK ============ ======== ======== ==== .. image:: ../img/Schematic_notnot.png :align: center Procedure sperimentali --------------------------------- **Passo 1**: Costruisci il circuito. .. image:: ../img/3.1.14game_notnot.png **Passo 2**: Accendi l'SPI prima di iniziare l'esperimento, consulta :ref:`spi_configuration` per i dettagli. **Passo 3**: Vai nella cartella del codice. .. raw:: html .. code-block:: cd ~/raphael-kit/c/3.1.13/ **Passo 4**: Compila il codice. .. raw:: html .. code-block:: make **Passo 5**: Esegui il file eseguibile. .. raw:: html .. code-block:: sudo ./3.1.13_GAME_NotNot Dopo l'avvio del programma, una freccia verso sinistra o destra verrà aggiornata casualmente sulla matrice a punti. Il tuo compito è premere il pulsante nella direzione opposta alla freccia; allora apparirà un “√” sulla matrice a punti. Se premi il pulsante nella stessa direzione della freccia, sei fuori e la matrice a punti mostrerà una “x”. Puoi anche aggiungere 2 nuovi pulsanti o sostituirli con i tasti del joystick per 4 direzioni—su, giù, sinistra e destra—per aumentare la difficoltà del gioco. .. note:: Se non funziona dopo l'esecuzione, o appare un messaggio di errore: \"wiringPi.h: No such file or directory\", consulta :ref:`install_wiringpi_pi5`. Spiegazione del Codice ---------------------- Questo programma in C è progettato per essere eseguito su un Raspberry Pi utilizzando la libreria WiringPi. Interagisce con un display a matrice LED 8x8 controllato dal chip driver MAX7219 e utilizza due pulsanti per l'interazione con l'utente. Il programma visualizza casualmente una freccia a sinistra o a destra sulla matrice LED, e l'utente deve premere il pulsante corrispondente. Successivamente, visualizza un segno di spunta per una risposta corretta o una croce per una risposta errata. #. File di intestazione: * ``wiringPi.h``: Fornisce funzioni per il controllo GPIO usando la libreria WiringPi. * ``wiringPiSPI.h``: Fornisce funzioni per la comunicazione SPI. * ``stdio.h``: Funzioni di input/output standard (``printf``, ecc.). * ``stdlib.h``: Funzioni di libreria standard (``rand``, ``srand``, ``exit``). * ``time.h``: Funzioni per la manipolazione di data e ora (``time``, ``NULL``). #. Definizioni di tipo: * ``#define uchar unsigned char``: Definisce ``uchar`` come alias per ``unsigned char``. * ``#define uint unsigned int``: Definisce ``uint`` come alias per ``unsigned int``. #. Costanti e Macro: * ``SPI_CHANNEL``: Canale SPI usato per la comunicazione (0 o 1). * ``SPI_SPEED``: Velocità di comunicazione SPI impostata a 1 MHz. * ``AButtonPin``: Numero di pin WiringPi per il pulsante A (GPIO 22). * ``BButtonPin``: Numero di pin WiringPi per il pulsante B (GPIO 23). #. Variabili globali: * ``int stage = 0;``: Tiene traccia della fase attuale del gioco (visualizzazione della freccia o del risultato). #. Array di dati: * ``uchar arrow[2][8]``: Contiene due pattern di 8 byte che rappresentano le frecce destra e sinistra per la matrice LED. * ``arrow[0]``: Pattern della freccia destra. * ``arrow[1]``: Pattern della freccia sinistra. * ``uchar check[2][8]``: Contiene due pattern di 8 byte che rappresentano i simboli di corretto (segno di spunta) e errato (croce). * ``check[0]``: Pattern del simbolo corretto. * ``check[1]``: Pattern del simbolo errato. #. Funzione ``void Delay_xms(uint x)``: * Funzione wrapper per ``delay(x)`` fornita da WiringPi. * Ritarda l'esecuzione del programma per ``x`` millisecondi. #. Funzione ``void Write_Max7219_byte(uchar DATA)``: * Invia un singolo byte (``DATA``) al MAX7219 via SPI. * Usa ``wiringPiSPIDataRW`` per eseguire il trasferimento dei dati SPI. * ``DATA``: Il byte di dati da inviare. #. Funzione ``void Write_Max7219(uchar address1, uchar dat1)``: * Invia un comando e dati al MAX7219. * Combina ``address1`` (indirizzo del registro) e ``dat1`` (dati) in un buffer e li invia tramite SPI. * ``address1``: Indirizzo del registro del MAX7219. * ``dat1``: Dati da scrivere nel registro. #. Funzione ``void Init_MAX7219()``: * Inizializza il driver display MAX7219 con le configurazioni necessarie. * Configura il modo di decodifica, intensità, limite di scansione, modalità di spegnimento e test display. * Pulisce eventuali dati precedenti sul display. #. Funzione ``void Init_WiringPi()``: * Inizializza la libreria WiringPi e l'interfaccia SPI. * Configura i pin dei pulsanti come input con resistori di pull-up. * Verifica l'inizializzazione e termina se fallisce. #. Funzione ``int get_index()``: * Genera un indice casuale (0 o 1) per scegliere tra la freccia sinistra e destra. * Restituisce: ``0`` o ``1``. #. Funzione ``int get_key(uint num)``: * Attende che l'utente prema un pulsante e determina se l'input corrisponde alla freccia visualizzata. * Parametri: * ``num``: L'indice della freccia visualizzata (0 per destra, 1 per sinistra). * Restituisce: * ``1`` se l'input dell'utente è corretto. * ``0`` se l'input dell'utente è errato. * Funzionalità: * Entra in un ciclo infinito controllando lo stato dei pulsanti. * Usa ``digitalRead`` per rilevare le pressioni dei pulsanti (LOW attivo). * Confronta il pulsante premuto con l'input previsto in base a ``num``. #. Funzione ``void display(uint index)``: * Visualizza una freccia o un simbolo di risultato sulla matrice LED in base alla ``stage``. * Parametri: * ``index``: Indice per selezionare il pattern dagli array ``arrow`` o ``check``. * Funzionalità: * Se ``stage == 0``, visualizza un pattern a freccia. * Se ``stage == 1``, visualizza un segno di spunta o un simbolo di croce. #. Funzione Principale: * **Inizializzazione:** * Imposta il generatore di numeri casuali con ``srand((unsigned)time(NULL))``. * Chiama ``Init_WiringPi()`` per configurare GPIO e SPI. * Chiama ``Init_MAX7219()`` per inizializzare il display a matrice LED. * Introduce un breve ritardo con ``Delay_xms(50)``. * **Loop di gioco (``while (1)``):** * **Fase 0 (Visualizza freccia):** * Chiama ``get_index()`` per selezionare casualmente una direzione della freccia. * Chiama ``display(direction)`` per mostrare la freccia sulla matrice LED. * Imposta ``stage = 1`` per passare alla fase successiva. * **Fase 1 (Ottieni input utente e visualizza risultato):** * Chiama ``get_key(direction)`` per attendere l'input dell'utente e determinare la correttezza. * Chiama ``display(key)`` per mostrare il simbolo di risultato (segno di spunta o croce). * Attende 1 secondo usando ``Delay_xms(1000)`` per consentire all'utente di vedere il risultato. * Imposta ``stage = 0`` per riavviare il ciclo. **Riepilogo del flusso del programma:** 1. **Configurazione:** * Inizializza WiringPi e SPI. * Configura i pin dei pulsanti e le impostazioni MAX7219. * Imposta il generatore di numeri casuali. 2. **Visualizza Freccia:** * Seleziona casualmente una direzione della freccia (sinistra o destra). * Visualizza la freccia corrispondente sulla matrice LED. 3. **Interazione con l'utente:** * Attende che l'utente prema il pulsante A o B. * Determina se il pulsante premuto corrisponde alla direzione della freccia. 4. **Visualizza Risultato:** * Mostra un segno di spunta se l'input dell'utente è corretto. * Mostra una croce se l'input dell'utente è errato. * Attende 1 secondo prima del turno successivo. 5. **Ripeti:** * Torna a visualizzare una nuova freccia e continua il gioco.