Bonjour à tous,

Voici mon montage :
- Arduino Uno Officiel
- Shield Ethernet 2 Arduino Officiel SPI
- Ecran tactile SPI

Le Shield Ethernet utilise les broches suivantes :
- 13 CK
- 12 MISO
- 11 MOSI
- 10 (CS pour la fonction Ethernet)
- 4 (CS pour la fonction lecteur carte SD)

L'écran TFT utilise les broches suivantes (via les résistances requises) :
- 13 CK
- 12 MISO
- 11 MOSI
- 0 CS

La dalle tactile utilise les broches suivantes (via les résistances requises) :
- 13 CK
- 12 MISO
- 11 MOSI
- 7 CS

J'utilise la broche 6 comme sortie PWM pour piloter le rétroéclairage de l'écran TFT avec un transistor PNP

Nom : Dsc03607.jpg
Affichages : 2248
Taille : 684,3 Ko

(Les deux leds rouges servent juste à caler la carte Arduino sur la plaque de prototypage)

Avec ce montage :

- si je téléverse un programme qui utilise juste l'écran TFT et la dalle tactile, ça fonctionne très bien

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// Programme qui fonctionne (écran TFT et dalle tactile) sur Arduino seul
// Programme qui fonction aussi (écran TFT et dalle tactile) sur Arduino avec Ethernet Shield 2 officiel Arduino
// L'écran TFT, la dalle tactile et le module Ethernet Shield 2 sont compatibles électriquement
 
#include "Adafruit_GFX.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques    
#include "Adafruit_ILI9341.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques
#include "URTouch.h" // Ajouté au format ZIP         
 
  //On définit les broches pour la partie affichage
  #define TFT_CLK 13
  #define TFT_MISO 12
  #define TFT_MOSI 11
  //#define TFT_CS 10
  #define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI
  #define TFT_DC 9
  #define TFT_RST 8
  Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);
  #define TFT_PWM_LED 6 // Un transistor PNP permet de piloter le rétroéclairage 
  // Il est possible d'ajuster le niveau de rétroéclairage en fonction de la luminosité ambiante grâce à une photodiode sur une entrée analogique
  // On peut réduire et éteindre le rétroéclairage après une période d'inactivité de la dalle tactile
  // Et réactiver le rétroéclairage en cas de notification
 
  //On définit les broches pour la partie tactile
  #define t_IRQ 5
  //#define t_MISO 4
  #define t_MISO 7 // La broche 4 est utilisée pour le lecteur SD de l'ethernet Shield
  #define t_MOSI 3
  #define t_CS 2
  #define t_SCK 1
  URTouch ts(t_SCK, t_CS, t_MOSI, t_MISO, t_IRQ);
 
void setup() {
 
  int radius = 4;
 
  analogWrite(TFT_PWM_LED,128);
 
  tft.begin();
  tft.setRotation(0);
 
  ts.InitTouch(PORTRAIT);
  ts.setPrecision(PREC_EXTREME);
  tft.fillScreen(ILI9341_BLACK);
 
  tft.setTextColor(ILI9341_RED, ILI9341_BLACK);
  tft.setTextSize(2);
 
  tft.fillCircle(10, 10, radius, ILI9341_YELLOW);
  tft.fillCircle(10, 310, radius, ILI9341_YELLOW);
  tft.fillCircle(230, 310, radius, ILI9341_YELLOW);
  tft.fillCircle(230, 10, radius, ILI9341_YELLOW);
  tft.fillCircle(120, 160, radius, ILI9341_YELLOW);
 
}
 
void loop()
{
  int retro;
  int x, y;
  char Buffer_DispXY[15];
  while (ts.dataAvailable())
  {
    ts.read();
    x = ts.getX();
    y = ts.getY();
 
    if ((x != -1) && (y != -1))
    {
      snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("X=%3d Y=%3d"), x, y);
      tft.setCursor(55, 5);
      tft.print(Buffer_DispXY);
      retro=y-10;
      if (retro<0) {retro=0;}
      if (retro>255) {retro=255;}
      analogWrite(TFT_PWM_LED,retro);
    }
  }
}
- si je téléverse un programme qui utilise juste le shield Ethernet (exemple Webserveur), ça fonctionne très bien

=> Cela me laisse à penser que le câblage est correct

- mais quand j'essaye de "fusionner" les deux programmes pour utiliser le shield Ethernet, l'écran TFT et la dalle tactile, je sèche

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#include <SPI.h>
#include <Ethernet.h>
 
// Ethernet Shield 2 : communicates with both the W5500 and SD card using the SPI bus (through the ICSP header).
// This is on digital pins 10, 11, 12, and 13 on the Uno and pins 50, 51, and 52 on the Mega.
// On both boards, pin 10 is used to select the W5500 and pin 4 for the SD card. These pins cannot be used for general I/O.
// On the Mega, the hardware SS pin, 53, is not used to select either the W5500 or the SD card, but it must be kept as an output or the SPI interface won't work.
 
#include "Adafruit_GFX.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques    
#include "Adafruit_ILI9341.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques
#include "URTouch.h" // Ajouté au format ZIP      
 
  //On définit les broches pour la partie affichage
  #define TFT_CLK 13
  #define TFT_MISO 12
  #define TFT_MOSI 11
  //#define TFT_CS 10
  #define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI
  #define TFT_DC 9
  #define TFT_RST 8
  Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);
 
  #define TFT_PWM_LED 6 // Un transistor PNP permet de piloter le rétroéclairage 
  // Il est possible d'ajuster le niveau de rétroéclairage en fonction de la luminosité ambiante grâce à une photodiode sur une entrée analogique
  // On peut réduire et éteindre le rétroéclairage après une période d'inactivité de la dalle tactile
  // Et réactiver le rétroéclairage en cas de notification
 
  //On définit les broches pour la partie tactile
  #define t_IRQ 5
  //#define t_MISO 4
  #define t_MISO 7 // La broche 4 est utilisée pour le lecteur SD de l'ethernet Shield
  #define t_MOSI 3
  #define t_CS 2
  #define t_SCK 1
  URTouch ts(t_SCK, t_CS, t_MOSI, t_MISO, t_IRQ);
 
 
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
  0xA8, 0x61, 0x0A, 0xAE, 0x75, 0xCA
};
IPAddress ip(192, 168, 123, 177);
 
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
 
void setup() {
  int radius = 4;
 
  analogWrite(TFT_PWM_LED,128);
 
  tft.begin();
  tft.setRotation(0);
 
  ts.InitTouch(PORTRAIT);
  ts.setPrecision(PREC_EXTREME);
  tft.fillScreen(ILI9341_BLACK);
 
  tft.setTextColor(ILI9341_RED, ILI9341_BLACK);
  tft.setTextSize(2);
 
  tft.fillCircle(10, 10, radius, ILI9341_YELLOW);
  tft.fillCircle(10, 310, radius, ILI9341_YELLOW);
  tft.fillCircle(230, 310, radius, ILI9341_YELLOW);
  tft.fillCircle(230, 10, radius, ILI9341_YELLOW);
  tft.fillCircle(120, 160, radius, ILI9341_YELLOW);
 
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.println("Ethernet WebServer Example");
 
  // You can use Ethernet.init(pin) to configure the CS pin
  //Ethernet.init(10);  // Most Arduino shields
  //Ethernet.init(5);   // MKR ETH shield
  //Ethernet.init(0);   // Teensy 2.0
  //Ethernet.init(20);  // Teensy++ 2.0
  //Ethernet.init(15);  // ESP8266 with Adafruit Featherwing Ethernet
  //Ethernet.init(33);  // ESP32 with Adafruit Featherwing Ethernet
 
  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
 
  // Check for Ethernet hardware present
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
    while (true) {
      delay(1); // do nothing, no point running without Ethernet hardware
    }
  }
  if (Ethernet.linkStatus() == LinkOFF) {
    Serial.println("Ethernet cable is not connected.");
  }
 
  // start the server
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}
 
 
void loop() {
    int retro;
    int x, y;
    char Buffer_DispXY[15];
    int sensorReading;
 
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // the connection will be closed after completion of the response
          client.println("Refresh: 5");  // refresh the page automatically every 5 sec
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            sensorReading = analogRead(analogChannel);
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(sensorReading);
            client.println("<br />");
          }
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
 
 
      // Affichage sur l'écran TFT - ne fonctionne pas
      snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("A = %d"), sensorReading);
      tft.setCursor(55, 5);
      tft.print(Buffer_DispXY);
 
  }
}
j'arrive à afficher un truc sur l'écran TFT, puis à faire fonctionner le module Ethernet en serveur, mais une fois que j'ai commencé à utiliser la partie Ethernet je ne peux plus écrire sur l'écran.

Ce sont les fameux librairies Ethernet.h, URTouch.h, Adafruit_ILI9341.h et Adafruit_GFX.h qui gèrent les broches du SPI, y compris les fameuses broches CS

Il me semble évident qu'il faut que l'Arduino utilise à tour de rôle le bus SPI sur chaque module :
- le module Ethernet pour voir s'il y a des choses à récupérer, et quand il faut envoyer des données
- l'écran TFT quand il faut écrire dessus
- la dalle tactile pour récupérer la saisie de l'utilisateur
En particulier, je dois interroger à tour de rôle et assez rapidement le module Ethernet et la dalle tactile pour ne pas perdre en réactivité.
Mais je ne vois pas comment m'y prendre.
Le point épineux est que l'essentiel du code se trouve dans les bibliothèques, je ne sait pas trop ce qu'elles font, si elles utilisent des interruptions ou pas...
Les exemples de code source ne montre que comment utiliser chaque bibliothèque une par une, mais pas avec d'autres en libérant le bus SPI.

Remarque importante : je n'ai pas forcément besoin que le module Ethernet fonctionne en serveur.
Le projet final est de relier plusieurs boîtiers composés d'un arduino uno, un module ethernet et un écran tactile à un arduino méga "central"
Via des câbles Ethernet, les arduinos unos doivent pouvoir envoyer et recevoir des données à l'arduino méga.
C'est un autre aspect de mon projet que je n'ai pas encore complètement cerné : définir quels modules Arduinos seront "client", "serveur" ou autre chose...

Merci

A bientôt