Modulo TTP229

 

 

Questo è un modulo Touchpad che occupa solo due pin di Arduino fornendo 16 pulsanti. Da utilizzare quando i pin scarseggiano

 

Il TTP229 è un chip touch controller che può essere utilizzato per rilevare tocchi su una matrice di tasti capacitivi. Nella versione con 16 tasti (ad esempio, il TTP229 a 16 tasti), puoi utilizzare il modulo per rilevare l'attivazione di uno o più tasti su un array di 16 pulsanti, senza dover gestire singolarmente i tasti tramite una matrice come nel caso di pulsanti meccanici.

Funzionamento del TTP229:

Il chip TTP229 rileva i tocchi capacitivi e restituisce un valore che indica quali tasti sono stati premuti. Questo modulo può essere utilizzato per semplificare l'interfacciamento di un array di tasti capacitive con Arduino, riducendo il numero di pin necessari.

  1. Tasti capacitivi: Ogni tasto è capacitativo, il che significa che il chip rileva variazioni nella capacità quando il dito tocca la superficie del tasto. Il chip TTP229 rileva questi tocchi in modo simile a un display touchscreen.

  2. Modalità di uscita:

    • Il chip può operare in modalità single key (un solo tasto alla volta) o in modalità multi-key (per rilevare più tasti contemporaneamente).
    • Le informazioni sui tasti premuti vengono restituite tramite uscite digitali.

  3. Protocollo di comunicazione: Il TTP229 utilizza un protocollo seriale per comunicare con Arduino, che può essere configurato per inviare informazioni sui tasti premuti.

Pin richiesti per l'Arduino:

Il modulo TTP229 a 16 tasti utilizza i seguenti pin di Arduino:

  • SCL (Serial Clock Line): Questo è il pin di clock per la comunicazione I2C.
  • SDA (Serial Data Line): Questo è il pin per i dati in modalità I2C.
  • VCC: Alimentazione (tipicamente 3.3V o 5V, a seconda del modulo).
  • GND: Massa.

Come collegare il TTP229 ad Arduino:

  1. VCC va collegato a 5V (o 3.3V, a seconda della versione del modulo).
  2. GND va collegato a GND.
  3. SDA va collegato al pin SDA di Arduino (di solito il pin A4 su una scheda Arduino Uno).
  4. SCL va collegato al pin SCL di Arduino (di solito il pin A5 su una scheda Arduino Uno).

Pin aggiuntivi:

  • Il TTP229 può avere un pin INT (Interrupt) che, se collegato a un pin di interrupt di Arduino, ti avvisa quando un tasto viene premuto, ma può essere opzionale a seconda della tua implementazione.

Codice per leggere i tasti:

Poiché il TTP229 comunica tramite I2C, puoi usare la libreria Wire per la comunicazione seriale con Arduino. Un esempio base di codice per leggere i tasti del TTP229 è il seguente:

 

 

XXX:

 

#include <Wire.h>

#define TTP229_ADDR 0x57  // Indirizzo I2C del TTP229

void setup() {
  Serial.begin(9600);
  Wire.begin();
}

void loop() {
  Wire.beginTransmission(TTP229_ADDR);
  Wire.write(0x00);  // Comando per leggere lo stato dei tasti
  Wire.endTransmission();
  
  Wire.requestFrom(TTP229_ADDR, 2);  // Richiede 2 byte di dati (16 tasti in due byte)
  
  if (Wire.available()) {
  byte tasti1 = Wire.read();  // Legge il primo byte (tasti 1-8)
  byte tasti2 = Wire.read();  // Legge il secondo byte (tasti 9-16)

  // Controlla i tasti 1-8
  for (int i = 0; i < 8; i++) {
    if (tasti1 & (1 << i)) {
      Serial.print("Tasto ");
      Serial.print(i + 1);
      Serial.println(" premuto");
    }
  }

  // Controlla i tasti 9-16
  for (int i = 0; i < 8; i++) {
    if (tasti2 & (1 << i)) {
      Serial.print("Tasto ");
      Serial.print(i + 9);
      Serial.println(" premuto");
    }
  }
}
  delay(100);  // Aspetta prima di leggere di nuovo
}

 

Operazione di Shift a Sinistra (<<):

L'operazione di shift a sinistra (<<) sposta tutti i bit di un numero verso sinistra di un certo numero di posizioni. Ogni spostamento a sinistra corrisponde a moltiplicare per 2 il numero originale. I bit che escono dalla fine del numero (a sinistra) vengono persi, mentre i nuovi bit a destra vengono riempiti con 0.

Ad esempio:

  • 1 << 0 (shift di 0 posizioni) lascia il numero invariato: 0b00000001.
  • 1 << 1 (shift di 1 posizione) sposta il bit a sinistra: 0b00000010.
  • 1 << 2 (shift di 2 posizioni) sposta il bit a sinistra ancora di più: 0b00000100.

Cosa succede in questo caso?

Supponiamo di partire con 1 (in binario: 0b00000001) e fare uno shift a sinistra di 2 posizioni:

 

1 << 2 

In binario, questo significa spostare il bit più a destra (che è 1) di due posizioni verso sinistra:
0b00000001  (prima)  0b00000100  (dopo lo shift di 2 posizioni)

Il risultato è 0b00000100, che è uguale a 4 in decimale.

Applicato alla Maschera:

Nel codice che hai mostrato prima, usiamo l'operazione di shift per creare una maschera. La maschera è un valore che ha un solo bit impostato a 1 in una determinata posizione, mentre tutti gli altri bit sono 0. La maschera viene quindi utilizzata per isolare o controllare un singolo bit.

Per esempio:

1 << i

Qui i rappresenta la posizione del bit che vogliamo impostare a 1. Se i = 2, l'operazione diventa 1 << 2, che dà come risultato 0b00000100. Questa è la maschera che possiamo utilizzare per testare se il terzo tasto (tasto 3) è stato premuto.

 

 

Spiegazione dell'operazione:

  • tasti1 & (1 << i):
    • 1 << i crea una maschera che ha il bit 1 spostato nella posizione i.
    • L'operatore & (AND bit a bit) viene quindi utilizzato per verificare se il bit i di tasti1 è impostato a 1.

Se fosse 2 << i invece di 1 << i:

Quando scrivi 2 << i, stai facendo uno shift a sinistra del numero 2 (che in binario è 0b00000010). In pratica, se esegui uno shift di i posizioni, otterrai una maschera con il bit 1 nella posizione i+1 (anziché in i come nel caso di 1 << i).

Esempi per chiarire:

  1. 1 << i:

    • Se i = 0, la maschera sarà 0b00000001 (che è 1 in decimale).
    • Se i = 1, la maschera sarà 0b00000010 (che è 2 in decimale).
    • Se i = 2, la maschera sarà 0b00000100 (che è 4 in decimale), e così via.

  2. 2 << i:

    • Se i = 0, la maschera sarà 0b00000010 (che è 2 in decimale).
    • Se i = 1, la maschera sarà 0b00000100 (che è 4 in decimale).
    • Se i = 2, la maschera sarà 0b00001000 (che è 8 in decimale), e così via.

Confronto con il codice:

Nel tuo caso, con tasti1 & (1 << i), l'operazione di AND verifica se il bit nella posizione i di tasti1 è 1. Se è 1, il risultato dell'operazione sarà diverso da 0, altrimenti sarà 0.

Se invece scrivi tasti1 & (2 << i), l'operazione verificherà il bit nella posizione i+1, cioè un bit più a sinistra rispetto al caso precedente.

Esempio pratico:

Immagina di avere tasti1 = 0b00000101 (che è 5 in decimale):

  • Se i = 0, 1 << i diventa 0b00000001. L'operazione tasti1 & (1 << 0) diventa:

    • 0b00000101 & 0b00000001 → 0b00000001, quindi il primo bit è 1 (tasto 1 premuto).

  • Se i = 1, 1 << i diventa 0b00000010. L'operazione tasti1 & (1 << 1) diventa:

    • 0b00000101 & 0b00000010 → 0b00000000, quindi il secondo bit è 0 (tasto 2 non premuto).

  • Se i = 0, 2 << i diventa 0b00000010. L'operazione tasti1 & (2 << 0) diventa:

    • 0b00000101 & 0b00000010 → 0b00000000, quindi il secondo bit non è premuto.

In sintesi:

  • 1 << i crea una maschera con il bit 1 nella posizione i (esempio: 0b00000001, 0b00000010, 0b00000100).
  • 2 << i crea una maschera con il bit 1 nella posizione i+1 (esempio: 0b00000010, 0b00000100, 0b00001000).

Quindi, l'operazione tasti1 & (1 << i) ti permette di controllare il bit nella posizione i, mentre tasti1 & (2 << i) verifica il bit nella posizione i+1.

 

Se ho capito correttamente, vuoi utilizzare un interruttore rotativo a sei posizioni e collegarlo ad Arduino, ma invece di usare un interruttore meccanico fisico per cambiare le posizioni, vuoi utilizzare il modulo TTP229 (che ha tasti a matrice) per simulare il funzionamento dell'interruttore. Vorresti evitare di usare 6 pin digitali di Arduino e ridurre il numero di pin necessari. E sembra che tu stia considerando un modo per "emulare" l'interruttore rotativo con un controllo digitale tramite Arduino.

Vediamo se posso chiarire come potrebbe funzionare.

Interruttore rotativo e le posizioni:

Un interruttore rotativo a sei posizioni ha 6 possibili impostazioni che corrispondono a 6 stati. Questi stati possono essere rilevati tramite i pin di ingresso su Arduino (uno per ogni posizione). Se colleghi ciascuna posizione a un pin digitale di Arduino, puoi leggere facilmente la posizione tramite i pin.

Soluzione con il modulo TTP229:

Se vuoi ridurre il numero di pin utilizzati per rilevare queste 6 posizioni senza usare fisicamente 6 pin su Arduino, un'opzione potrebbe essere quella di utilizzare una matrice di tasti o un multiplexer. Con il modulo TTP229, che ha 16 tasti (e quindi 16 posizioni potenziali), puoi risparmiare pin digitali, poiché i tasti sono letti tramite il bus I2C, che utilizza solo 2 pin (SCL e SDA).

Tuttavia, con il modulo TTP229, puoi avere fino a 16 posizioni, quindi, per simulare 6 posizioni, puoi semplicemente mappare i primi 6 tasti. Ogni tasto corrisponde a una posizione dell'interruttore.

Come impostare il tutto:

  1. Mappa i tasti: Puoi configurare il modulo TTP229 in modo che ogni tasto corrisponda a una delle posizioni dell'interruttore rotativo. Ad esempio, i primi 6 tasti del TTP229 possono rappresentare le 6 posizioni dell'interruttore.

  2. Lettura dei tasti: Utilizzando il bus I2C, Arduino può leggere lo stato dei tasti premuti (quali sono attivi tra i 6 tasti mappati).

  3. Codice Arduino: Quando un tasto è premuto, Arduino rileverà quale tasto è attivo e lo interpreterà come una delle posizioni dell'interruttore.

Esempio di codice di base:

 

 

#include <Wire.h>

#define TTP229_ADDR 0x57  // Indirizzo I2C del TTP229

void setup() {
  Serial.begin(9600);
  Wire.begin();
}

void loop() {
  byte tasti;
  Wire.beginTransmission(TTP229_ADDR);
  Wire.write(0x00);  // Leggi stato dei tasti
  Wire.endTransmission();
  Wire.requestFrom(TTP229_ADDR, 1);
  if (Wire.available()) {
    tasti = Wire.read();  // Leggi il byte con lo stato dei tasti

    // Controlla quali tasti sono premuti (solo i primi 6 tasti)
    for (int i = 0; i < 6; i++) {
      if (tasti & (1 << i)) {
        Serial.print("Posizione ");
        Serial.print(i + 1);
        Serial.println(" selezionata");
      }
    }
  }
  delay(500);  // Ritardo per evitare letture troppo veloci
}

 

 

Come funziona il codice:

  1. Wire.begin(): Inizializza la comunicazione I2C.
  2. Wire.beginTransmission(TTP229_ADDR): Avvia una comunicazione con il modulo TTP229.
  3. Wire.write(0x00): Scrive un comando per chiedere lo stato dei tasti.
  4. Wire.requestFrom(TTP229_ADDR, 1): Richiede un byte da TTP229 (che contiene lo stato dei tasti).
  5. tasti & (1 << i): Usa il bitwise AND per verificare se il tasto corrispondente alla posizione i è stato premuto (se il bit è 1).

Vantaggi:

  • Meno pin: Puoi controllare più posizioni usando solo 2 pin I2C (SCL e SDA) invece di 6 pin digitali.
  • Facilità di gestione: L'uso del modulo TTP229 semplifica la lettura dei tasti senza bisogno di circuiti complessi.

Considerazioni:

Se vuoi gestire più di 6 posizioni, il modulo TTP229 ti permette di utilizzare fino a 16 tasti, ma in questo caso ti limiterai a utilizzare i primi 6 tasti per simulare l'interruttore rotativo.

 

Ho detto:

 

Per fare un es. più semplice. Ogni volta che premo un tasto sul modulo vorrei che gli altri  tasti siano annullati. Per capirci meglio ho sei led. Se pigio il tasto 1 si accenderà il LED 1, se pigio poi successivamente il tasto 3 il LED 1 si dovrà spegnere e si dovrà accendere il led 3. E così via. 

 

Capisco! In pratica, vuoi che ogni volta che premi un tasto sul modulo TTP229, venga acceso il LED corrispondente, mentre gli altri LED si spengano. Se premi un nuovo tasto, il LED precedente si spegne e il nuovo LED si accende. Questo comportamento si avvicina a un sistema di selezione a LED basato sul tasto premuto.

Ecco come possiamo implementarlo:

Concetto:

  • Il modulo TTP229 ti fornisce lo stato dei tasti premuti.
  • Ogni tasto premuto deve attivare un LED specifico.
  • Quando un tasto viene premuto, il LED associato a quel tasto si accende, mentre gli altri si spengono.

Esempio di codice:

Per semplicità, ipotizzeremo che tu abbia 6 LED collegati a 6 pin digitali di Arduino (ad esempio, LED1, LED2, ..., LED6). Ogni tasto premuto sul TTP229 corrisponderà ad accendere un LED specifico.

 

 

#include <Wire.h>

#define TTP229_ADDR 0x57  // Indirizzo I2C del TTP229

// Definisci i pin dei LED
int ledPins[] = {2, 3, 4, 5, 6, 7};  // LED collegati ai pin 2-7
int numLeds = 6;  // Numero di LED (6 in questo caso)

void setup() {
  Serial.begin(9600);
  Wire.begin();

  // Imposta i pin dei LED come uscita
  for (int i = 0; i < numLeds; i++) {
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW);  // Spegne tutti i LED all'inizio
  }
}

void loop() {
  byte tasti;
  Wire.beginTransmission(TTP229_ADDR);
  Wire.write(0x00);  // Leggi stato dei tasti
  Wire.endTransmission();
  Wire.requestFrom(TTP229_ADDR, 1);
  if (Wire.available()) {
    tasti = Wire.read();  // Legge il byte con lo stato dei tasti

    // Per ogni tasto premuto (dal tasto 1 al tasto 6)
    for (int i = 0; i < numLeds; i++) {
      if (tasti & (1 << i)) {
        // Accendi il LED corrispondente al tasto
        digitalWrite(ledPins[i], HIGH);
        Serial.print("Tasto ");
        Serial.print(i + 1);
        Serial.println(" premuto");
      } else {
        // Spegni gli altri LED
        digitalWrite(ledPins[i], LOW);
      }
    }
  }
  delay(100);  // Ritardo per evitare letture troppo veloci
}

 

Spiegazione del codice:

  1. Definizione dei LED:

    • Abbiamo un array ledPins[] che contiene i numeri dei pin Arduino a cui sono collegati i 6 LED.
    • Ogni LED corrisponde a una posizione nell'array (il LED 1 è sul pin 2, il LED 2 è sul pin 3, ecc.).

  2. Inizializzazione dei pin:

    • Nel setup(), impostiamo i pin dei LED come uscite e li spegniamo inizialmente (digitalWrite(ledPins[i], LOW)).

  3. Lettura dello stato dei tasti:

    • Nel loop(), leggiamo lo stato dei tasti dal modulo TTP229 tramite la comunicazione I2C.
    • tasti conterrà un byte che indica quali tasti sono stati premuti (i primi 8 tasti saranno nel primo byte, i successivi 8 nel secondo, ma per semplicità usiamo solo il primo byte, considerando solo i primi 6 tasti).

  4. Accensione e spegnimento dei LED:

    • Per ogni tasto (da 1 a 6), se il bit corrispondente nel byte tasti è settato a 1 (cioè il tasto è premuto), il LED corrispondente viene acceso (digitalWrite(ledPins[i], HIGH)).
    • Se il bit è 0 (cioè il tasto non è premuto), il LED viene spento (digitalWrite(ledPins[i], LOW)).

  5. Serial Monitor:

    • Il monitor seriale mostra quale tasto è stato premuto per debugging.

Come funziona:

  • Quando premi un tasto sul TTP229, il LED corrispondente si accende, mentre gli altri LED si spengono.
  • Se premi un altro tasto, il LED del tasto precedente si spegne e il LED del nuovo tasto si accende.

Considerazioni:

  • Il codice è configurato per lavorare con i primi 6 tasti del TTP229. Se vuoi usarne di più, dovrai espandere il codice per gestire più tasti.
  • Se desideri gestire più di 6 tasti (ad esempio, 16 tasti totali), dovrai leggere anche i tasti successivi nel secondo byte e aggiungere logica per gestire fino a 16 LED.
  • Questo codice fa uso di un ritardo di 100 ms per evitare che il modulo TTP229 venga letto troppo frequentemente.