Plusieurs écrans tft 1.8 avec un seul pipico , environnement arduinoIDE

Bonjour.

Je cherche à réaliser une 'console 4 joueurs' avec 4 joysticks et une matrice de led centrale. Façon 'hippo glouton', avec des jeux un peu moins frénétiques.

Je souhaite insérer des écrans tft1.8 pour donner des infos de jeu (score, vitesse), et notamment avoir des infos pour améliorer le gameplay.

Actuellement, j ai un jeu de snake à 4 qui fonctionne. Les joysticks sont gérés par un arduino nano, qui envoie des données sur le port série d'un pipico qui gère le jeu.
Ce dernier envoie à nouveau les données à afficher à un autre pipico; et je souhaite raccorder plusieurs écrans (au moins 2, avec des affichages différents si possibles)

Le pipico comporte 2 bus SPI comme l'indique la doc (SPI1 et SPI0), et j ai alors tellement de questions, pour lesquelles je ne serai pas contre un petit coup de pouce

  • dans guide du tft display (Guide to 1.8 TFT Display with Arduino | Random Nerd Tutorials) , les ports utilisés sont SDA et SCK, ce qui pour mo est un mélange I2C (SDA ) et SCK (la clock qui régit le SPI)
  • Quels bornes utiliser avec le pipico ? (Raspberry Pi Pico Pinout, Features, Programming Options and Peripherals ) il y a plusieurs ports qui semble tolérer les 2 bus SPI , mais dans le code qu'on m'a donné (ci dessous), qui fonctionne avec un seul écran, toutes les bornes utilisées ne sont pas mentionnées ...
  • avec un seul bus SPI, puis je faire fonctionner plusieurs écrans ou bien il faut un bus par écran ? en ce cas, comment rédiger cette nouvelle ouverture ? créer un objet spi0 et spi 1 ?

Vu l'étendue de mon ignorance (je ne connaissais pas le nom de SPI la semaine dernière) , j'arrete la mes questions ( et je vais voir les sujets similaires qui viennent d'apparaître sur mon naigateur )
Je remercie chaleureusement les personnes qui prennent le temps pour les autres sur ce forum. J'ai souvent besoin de formuler mes demandes d'aide pour comprendre mes problèmes :confused:

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

// Broches Pico
#define TFT_CS   17 //vert
#define TFT_DC   20 //jaune
#define TFT_RST  16 //bleu
//sck : gris: 18
//sda : blanc :19


 #define TFT2_CS   13
 #define TFT2_DC   21
#define TFT2_RST  12
// gris 10
//blanc 11

// Créer l’objet TFT
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
Adafruit_ST7735 tft2 = Adafruit_ST7735(TFT2_CS, TFT2_DC, TFT2_RST);

void setup() {
  // Démarrage SPI avec vitesse réduite pour Pico
  SPI.begin(); 
  SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE0)); // 2 MHz
  SPI.beginTransaction(SPISettings(2000000, MSBFIRST, SPI_MODE1)); // 2 MHz
  // tft.initR(INITR_BLACKTAB); // Initialisation écran ST7735
  // tft.fillScreen(ST77XX_BLACK);

 tft2.initR(INITR_BLACKTAB); // Initialisation écran ST7735
 tft2.fillScreen(ST77XX_BLACK); 

  Serial.begin(9600);
  
  Serial1.begin(19200);

  // // Test de couleurs
  // tft.fillScreen(ST77XX_RED);
  // delay(500);
  // tft.fillScreen(ST77XX_GREEN);
  // delay(500);
  // tft.fillScreen(ST77XX_BLUE);
  // delay(500);

  // Texte de test
  // tft.fillScreen(ST77XX_BLACK);
  // tft.setTextColor(ST77XX_MAGENTA);
  // tft.setTextSize(1);
  // tft.setCursor(10, 10);
  // tft.print("coucou");

  // tft2.fillScreen(ST77XX_BLACK);
  // tft2.setTextColor(ST77XX_CYAN);
  // tft2.setTextSize(2);
  // tft2.setCursor(10, 10);
  // tft2.print("coco");

}

void loop() {
  // if (Serial1.available()) {
  //   char clic = Serial1.read();
  //   tft.print(clic);
  //   }
  }

Helas il y a chez des vendeurs, qui ne connaissent pas ce qu’ils vendent, des confusions de langage entre les dénomination I2C et SPI.

L’i2c utilise 2 liaisons : données et horloge
La ligne data est bidirectionnelle.

Le spi en utilise 4.
L’horloge
Données maitre vers esclave : Mosi : master out slave in
Données esclave vers maitre : Miso : master in slave out
Les ligne Mosi et Miso sont unidirrectionnelles.

Plus une liaison pour selectioner un esclave parmi les autres : CS ou SS.

Les trois premières sont partagées entre le maitre et tous les esclaves.
Il faut un CS par esclave.

On peut connecter plusieurs esclaves sur le même bus SPI pour autant qu’il reste des gpio pour les différents CS.

Il existe de nombreuses documentations très complètes sur l’I2C et sur le SPI avec des graphiques très clairs, il faut les consulter pour plus d’explications.

Tout est là


Petite mise au point sur le vocabulaire, afin de mieux se comprendre.

  • Pour les entrées sorties du microcontrôleur, on parle plutôt d'IO ou de GPIO.
  • Le RP2040 de la carte PICO possède 2 périphériques SPI
  • Les entrées/sorties de chacun des périphériques peuvent être aiguillées vers un certain nombre d'IO comme on peut le voir sur l'illustration dans le lien donné ci-dessus

Oui c'est le CS qui active le périphérique auquel tu veux accéder.
Les fabricants chinois ne se prennent pas trop la tête avec les noms de signaux. Donc, on trouve indifféremment CK, SCK, SCL pour l'horloge et DIN, SI, SDA pour la donnée entrant sur l'écran.
Les écrans TFT pas chers ne sont souvent accessible qu'en lecture donc il n'y a pas DOUT, SO ou OUT.
Sur les écrans en SPI il y a généralement un signal DC qui sert à indiquer au driver d'écran si on envoie une commande ou une donnée. Ce signal peut aussi être partagé entre les différents afficheurs.
Mais chaque écran doit avoir sont CS propre.

Merci à vous 2.
C'est comme toujours bien plus clair après qu'avant.

si je comprends bien, je peux utiliser pour comme GPIO pour l'écran 1 :

#define TFT_CS   17 //vert
#define TFT_DC   20 //jaune
#define TFT_RST  16 //bleu
//sck : gris: 18
//sda : blanc :19

pour l'écran 2 , les mêmes connexions; sauf le CS qui pourrait etre le 21 du coup (périphérique SPI 0)? ( Je ne suis pas chez moi donc je ne peux pas essayer)