Discussion :

[electroremy]

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



(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

[jpbbricole]

Bonjour electroremy

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

Je n'ai sans doute pas la solution à ton problème qui semble assez épineux, mais j'ai 2 remarques à faire, ton montage est absolument superbe et je n'ai pas vu les résistances de limitation de courant sur les 2 LED rouges!

Une petite question, pourquoi avoir changé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
//#define TFT_CS 10
#define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI

La pin 0 étant le Rx du port USB du UNO?

Cordialement
jpbbricole.

[electroremy]

Une petite question, pourquoi avoir changé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
//#define TFT_CS 10
#define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI

La pin 0 étant le Rx du port USB du UNO?

Bonjour,

J'ai utilisé la broche 0 comme E/S car je ne pouvais pas utiliser la broche 10 qui est utilisée par Shield Ethernet.

Tu me dis que la pin 0 est Rx du port USB... voilà qui est très intéressant : en effet, le code source WebServeur utilise le moniteur série pour afficher des choses sur l'ordinateur... et ce moniteur série passe par l'USB !

Je vais essayer en retirant dans mon code tout ce qui écrit sur le moniteur série

A bientôt

[electroremy]

Je viens d'essayer, cela n'a aucun effet

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
170
171
#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);
 
  }
}

Il faut que je trouve comment dire au module Ethernet via la librairie Ethernet d'arrêter d'utiliser le bus SPI...

A bientôt

[Auteur]

Bonjour,

pour compléter ce qu'a indiqué jpbbricole, les broches 0 (Rx) et 1 (Tx) sont utilisées par l'objet Serial.

Ensuite, je ne comprends pas pourquoi tu utilises plusieurs sorties pour MOSI, MISO et CLK (dans le code posté, c'est ce que je vois). Les 3 pins par défaut (11, 12 et 13) peuvent normalement piloter les 3 composants.
Pour CS, 10 est déjà utilisé pour le shield Ethernet, donc il faut prendre autre chose pour les deux autres composants. Le pin 4 est effectivement utilisé pour le CS de la carte SD.

Ta connectique devrait ressembler à ça :
MOSI = 11
MISO = 12
CLK = 13
CS Ethernet = 10
CS carte SD = 4
puis par exemple :
CS TFT = 3
CS tactile = 5


Et ce sont les flag CS qui vont activer ou non la communication vers tes modules :

Code Arduino :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
digitalWrite(CSx, HIGH);
digitalWrite(CSx, LOW);

Voir après si c'est un état bas ou un état haut sur CS qui active ou désactive la communication vers le module.

[electroremy]

J'ai décidé de jeter un oeil sur le contenu des librairies...

Mes tests montrent qu'après avoir utilisé l'écran TFT dans le Setup(), j'arrive à utiliser ensuite le Shield Ethernet

Voici un extrait du code de Adafruit_SPITFT.cpp :

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
/*!
    @brief  Call before issuing command(s) or data to display. Performs
            chip-select (if required) and starts an SPI transaction (if
            using hardware SPI and transactions are supported). Required
            for all display types; not an SPI-specific function.
*/
void Adafruit_SPITFT::startWrite(void) {
  SPI_BEGIN_TRANSACTION();
  if (_cs >= 0)
    SPI_CS_LOW();
}
 
/*!
    @brief  Call after issuing command(s) or data to display. Performs
            chip-deselect (if required) and ends an SPI transaction (if
            using hardware SPI and transactions are supported). Required
            for all display types; not an SPI-specific function.
*/
void Adafruit_SPITFT::endWrite(void) {
  if (_cs >= 0)
    SPI_CS_HIGH();
  SPI_END_TRANSACTION();
}

Le code de la librairie de l'écran TFT est assez explicite : la broche CS est remise à l'état haut avant de clore la transaction SPI

Maintenant, voyons ce qu'il y a dans le code de la librairie Ethernet.cpp :

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
void EthernetClass::MACAddress(uint8_t *mac_address)
{
	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
	W5100.getMACAddress(mac_address);
	SPI.endTransaction();
}
 
IPAddress EthernetClass::localIP()
{
	IPAddress ret;
	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
	W5100.getIPAddress(ret.raw_address());
	SPI.endTransaction();
	return ret;
}
 
IPAddress EthernetClass::subnetMask()
{
	IPAddress ret;
	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
	W5100.getSubnetMask(ret.raw_address());
	SPI.endTransaction();
	return ret;
}

Dans Ethernet.h, on voit des SPI.endTransaction() partout mais aucune écriture de la broche CS...

Voici ce qu'on trouve sur SPI.endTransaction() dans la référence Arduino :

endTransaction()
Description
Stop using the SPI bus. Normally this is called after de-asserting the chip select, to allow other libraries to use the SPI bus.

Cela voudrait dire que la bibliothèque Ethernet.h oublie de remettre CS à l'état haut ???

Je suis assez perplexe.

Si c'était le cas, la modif que j'avais faite (post précédent) en ajoutant digitalWrite(10, HIGH); avant d'écrire sur mon écran TFT aurait du marcher...

A bientôt

[Auteur]

Peut-être ajouter une tempo entre 2 transactions ? Un digitalWrite() n'est pas instantané.

[electroremy]

Bonjour,

Ensuite, je ne comprends pas pourquoi tu utilises plusieurs sorties pour MOSI, MISO et CLK (dans le code posté, c'est ce que je vois). Les 3 pins par défaut (11, 12 et 13) peuvent normalement piloter les 3 composants.
Pour CS, 10 est déjà utilisé pour le shield Ethernet, donc il faut prendre autre chose pour les deux autres composants. Le pin 4 est effectivement utilisé pour le CS de la carte SD.

Ta connectique devrait ressembler à ça :
MOSI = 11
MISO = 12
CLK = 13
CS Ethernet = 10
CS carte SD = 4
puis par exemple :
CS TFT = 3
CS tactile = 5

C'est ce que j'ai fait, les broches 11, 12, 13 sont communes à l'écran et à l'Ethernet Shield.
Mais pas à la dalle tactile... en fait j'ai suivit l'exemple de câblage d'un tutoriel... comme cela fonctionne je ne l'ai pas modifié.
J'ai bien une broche unique pour CS de chaque périphérique SPI

Et ce sont les flag CS qui vont activer ou non la communication vers tes modules :
[code=Arduino]digitalWrite(CSx, HIGH);
digitalWrite(CSx, LOW);

Voir après si c'est un état bas ou un état haut sur CS qui active ou désactive la communication vers le module.

C'est ce que j'ai essayé, mais sans succès.

Voici le dernier code essayé, j'ai essayé avec digitalWrite(10, HIGH); ou digitalWrite(10, LOW); aucun effet

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
170
171
172
173
174
175
176
177
178
179
180
181
#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);
 
    char Buffer_DispXY[15];
    int sensorReading;
 
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);
 
  sensorReading = 555;
  snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("A = %d"), sensorReading);
  tft.setCursor(55, 5);
  tft.print(Buffer_DispXY);
 
/*
  // 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;
 
  // 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");
 
 
    delay(1);
    digitalWrite(10, HIGH);
    delay(1);
 
      // 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);
 
  }
}

[jpbbricole]

Bonjour Rémy

Cela voudrait dire que la bibliothèque Ethernet.h oublie de remettre CS à l'état haut ???

Peut-être mettre une sonde logique, un oscillo ou un analyseur logique sur la pin CS de l'Ethernet pour voire l'activité.

Cordialement
jpbbricole

[electroremy]

Peut-être ajouter une tempo entre 2 transactions ? Un digitalWrite() n'est pas instantané.

On a eu la même idée, dans le code (post précédent) j'ai testé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    delay(1);
    digitalWrite(10, HIGH);
    delay(1);

[electroremy]

Bonjour Rémy

Peut-être mettre une sonde logique, un oscillo ou un analyseur logique sur la pin CS de l'Ethernet pour voire l'activité.

Cordialement
jpbbricole

Bien vu !

J'ai branché mon Siglent SDS1204X-E sur la broche 10, la masse sur la masse de l'arduino. Le trigger "single" permet de capturer une trace pendant quelques instants puis ensuite de zoomer et de se balader dedans

Je modifie mon code source pour retirer la partie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    delay(1);
    digitalWrite(10, HIGH);
    delay(1);

Au repos (serveur non sollicité) je vois que la broche 10 alterne entre 0 et 5V régulièrement : fréquence 27Khz, niveau à 5V les 2/3 du temps, à 0V le 1/3 du temps restant

Même mesure en solliciant le serveur. Le signal alterne toujours entre 0 et 5V mais la durée à 0V et à 5V varie (c'est logique)

Donc à priori tout est OK, d'ou viens le problème alors ?

Je précise que le moniteur série reste vierge, j'ai bien supprimé tout utilisation de serial.

Là, je sèche...

A bientôt

[electroremy]

Bonjour,

j'ai trouvé un projet qui ressemble à ce que je souhaite faire

https://seeeddoc.github.io/Ethernet_Shield_V2.4/

Chercher dans la page "Application 1: Home Forecast Weather Station"

Malheureusement le matériel utilisé et les librairies ne sont pas les mêmes que les miennes.

J'ai regardé le code fourni en exemple et je ne voit pas, dans le principe, de différence avec la façon dont je m'y prend.

A bientôt

[electroremy]

Bonjour,

J'ai fait un autre test intéressant...

J'ai modifié le programme comme suit :

Je prend l'exemple qui fonctionne avec l'écran TFT et la dalle tactile, et j'ajoute seulement la partie "initialisation" du shield Ethernet

Surprise :
- j'arrive à écrire sur l'écran TFT avant d'initialiser le shield Ethernet
- j'arrive à utiliser la dalle tactile dans Loop() (le rétroéclairage réagit)
- je n'arrive plus à écrire sur l'écran TFT

En fait, tout se passe comme si une fois initialisé, le Shield Ethernet désactivait l'écran TFT.
Il y a peut être un problème avec les broches CK, MOSI et MISO du Shield Ethernet

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
#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);
 
    char Buffer_DispXY[15];
    int sensorReading;
 
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);
 
  sensorReading = 555;
  snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("A = %d"), sensorReading);
  tft.setCursor(55, 5);
  tft.print(Buffer_DispXY);
 
/*
  // 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;
 
    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);
    }
  }
 
}

A bientôt

[electroremy]

Ensuite, je ne comprends pas pourquoi tu utilises plusieurs sorties pour MOSI, MISO et CLK (dans le code posté, c'est ce que je vois). Les 3 pins par défaut (11, 12 et 13) peuvent normalement piloter les 3 composants.
Pour CS, 10 est déjà utilisé pour le shield Ethernet, donc il faut prendre autre chose pour les deux autres composants. Le pin 4 est effectivement utilisé pour le CS de la carte SD.

Ta connectique devrait ressembler à ça :
MOSI = 11
MISO = 12
CLK = 13
CS Ethernet = 10
CS carte SD = 4
puis par exemple :
CS TFT = 3
CS tactile = 5

Bonjour,

j'ai repensé à ta réponse...

j'ai essayé de câbler autrement mon afficher TFT et la dalle tactile.

Je reprend la version du programme qui fonctionnait juste pour l'écran TFT et la dalle tactile.

- TFT et dalle tactile avec MOSI, MISO et CK communs sur les broches 11, 12 et 13 => ne fonctionne pas

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
// 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_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_SCK 1
*/
 
  #define t_MISO 12 // La broche 4 est utilisée pour le lecteur SD de l'ethernet Shield
  #define t_MOSI 11
  #define t_SCK 13
 
  #define t_IRQ 5
  #define t_CS 2
  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);
    }
  }
}

- TFT et dalle tactile avec MOSI, MISO et CK communs sur les broches 1, 7, 3 (de cette façon aucune broche commune avec le shield Ethernet) => ne fonctionne pas

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
// Ne fonctionne pas :-(
 
#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_CLK 1
  #define TFT_MISO 7
  #define TFT_MOSI 3
 
  //#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))
    {
      delay(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);
      delay(1);
    }
  }
}

- TFT, dalle tactile sur des broches différentes, autre que 11, 12, 13 => ne fonctionne pas

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
// Ne fonctionne pas :-(
 
#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_CLK A1
  #define TFT_MISO A2
  #define TFT_MOSI A0
 
  //#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() {
  pinMode(A0, OUTPUT); //TFT_MOSI
  pinMode(A1, OUTPUT); //TFT_CLK
 
 
  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))
    {
      delay(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);
      delay(1);
    }
  }
}

Il n'y a vraiment que mon câblage initial qui fonctionne :

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);
    }
  }
}

Reste à rendre compatible ce câblage avec le Shield Ethernet 2...

Je pense à un truc : la vitesse du bus SPI. Le Shield Ethernet 2 utilise une vitesse élevée, dans w5100.h on trouve
#define SPI_ETHERNET_SETTINGS SPISettings(14000000, MSBFIRST, SPI_MODE0)

Est-ce que cette vitesse est remise à la bonne valeur quand je m'adresse à l'écran TFT après avoir utilisé le module Ethernet ?

A bientôt

[boijea]

... mais j'ai 2 remarques à faire, ton montage est absolument superbe et je n'ai pas vu les résistances de limitation de courant sur les 2 LED rouges!

Oui, c'est superbe!
Par contre, j’hésiterais sur la valeur des résistances des 2 LED rouges (t'as vraiment trop de matos!?!), je ne mettrais pas les mêmes

La photo aussi est cool, et c'est difficile avec le focus et la profondeur de champ.

Je viens d'en faire une pour un article sur le protocole UDP que j'écris pour ici:



On voit suffisamment bien le numéro des broches ET le modèle d'Arduino.
Je me suis bien amusé en déposant directement le LM35 sur les broches (et juste un fil).

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

Donc ... pourquoi pas un Arduino Uno WiFi Rev2?!
Cordialement

[electroremy]

Donc ... pourquoi pas un Arduino Uno WiFi Rev2?!

Pour de nombreuses raisons. L'une d'elle est que le Wifi a du mal à passer dans toutes les pièces d'une maison avec des gros murs en pierre

J'ai avancé dans mon problème.

Je suis revenu sur le câblage initial, et j'arrive à utiliser le shield Ethernet et la dalle tactile - le programme affiche la valeur des dernières coordonnées saisies sur l'écran tactile sur le site web

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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#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);
 
    char Buffer_DispXY[15];
    int sensorReading;
    int dernierx;
    int derniery;
 
void setup() {
  int radius = 4;
  dernierx=-1;
  derniery=-1;
 
  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);
 
  sensorReading = 555;
  snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("A = %d"), sensorReading);
  tft.setCursor(55, 5);
  tft.print(Buffer_DispXY);
 
/*
  // 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;
 
  // 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(F("HTTP/1.1 200 OK"));
          client.println(F("Content-Type: text/html"));
          client.println(F("Connection: close"));  // the connection will be closed after completion of the response
          client.println(F("Refresh: 5"));  // refresh the page automatically every 5 sec
          client.println();
          client.println(F("<!DOCTYPE HTML>"));
          client.println(F("<html>"));
          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            sensorReading = analogRead(analogChannel);
            client.print(F("analog input "));
            client.print(analogChannel);
            client.print(F(" is "));
            client.print(sensorReading);
            client.println(F("<br />"));
          }
          client.print(F("TFT X="));
          client.print(dernierx);
          client.print(F(" Y="));
          client.print(derniery);
          client.println(F("</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);
    delay(1);
    tft.setCursor(55, 5);
    tft.print(Buffer_DispXY);  
    delay(1);
 
  }
 
    while (ts.dataAvailable())
  {
    ts.read();
    x = ts.getX();
    y = ts.getY();
 
    if ((x != -1) && (y != -1))
    {
      dernierx=x;
      derniery=y;
      snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("X=%3d Y=%3d"), x, y);
 
      delay(1);
      tft.setCursor(55, 5);
      tft.print(Buffer_DispXY);
      delay(1);
      retro=y-10;
      if (retro<0) {retro=0;}
      if (retro>255) {retro=255;}
      analogWrite(TFT_PWM_LED,retro);
    }
  }
 
}

En revanche, l'écran TFT devient impossible à utiliser dès que je commence à utiliser le shield Ethernet.

J'ai eu l'idée de modifier w5100.h et de baisser la vitesse du port SPI

Là l'écran TFT réagit... en devenant tout blanc !

C'est pas ce que je souhaite, mais il y a un début !

Arduino nous promet un bus SPI et tout le monde nous explique qu'on peut utiliser plusieurs périphériques avec.
En pratique c'est plus difficile...
J'ai le sentiment que ceux qui développent des périphériques SPI et les bibliothèques qui vont avec ne font leurs tests qu'avec leur périphérique utilisé SEUL sur un Arduino.

Imagine-t-on une chose pareille avec l'USB ?

Je continue mes tests...

Je ne suis quand même pas le seul à vouloir utiliser plusieurs périphériques SPI ?

A bientôt

[Auteur]

je vais faire mon casse-pieds...
Quand je regarde tes constantes de tous les codes postés, je vois que tu n'as pas fait de modifications. Par exemple, je vois par exemple #define TFT_CS 0.
Donc ma question est de savoir si les codes postés sont ceux testés.

[f-leb]

Bonsoir à tous,

Le souci peut venir d'une interruption pour prendre la main sur le bus pendant qu'un transfert avec un autre périphérique est en cours.
C'est pour ça qu'il est recommandé d'encapsuler un transfert au sein d'une transaction SPI, comme le fait la bibliothèque SPI d'Arduino.
En début de transaction, les paramètres de la communication SPI sont réinitialisés. Et pendant la durée de la transaction, on peut faire en sorte de désactiver les interruptions pour un autre périphérique.

Si une bibliothèque ne gère pas les transactions, c'est la zoubia...

Edit : peut-être en passant par une autre bibliothèque pour le TFT. Celle-là comporte un fichier User_Setup.h. En fin de fichier, il y a une ligne // #define SUPPORT_TRANSACTIONS à dé-commenter pour prendre en charge les transactions au cas ou d'autres périphériques utilisent des interruptions.

[electroremy]

je vais faire mon casse-pieds...
Quand je regarde tes constantes de tous les codes postés, je vois que tu n'as pas fait de modifications. Par exemple, je vois par exemple #define TFT_CS 0.
Donc ma question est de savoir si les codes postés sont ceux testés.

Bonjour,

Si si, je change bien les broches CL, MISO et MOSI - mais pas les broches CS (c'est normal, il faut une broche CS différente pour chaque périphérique SPI)

Je sais que c'est pas évident, et j'ai laissé les broches initiales en commentaire avec //... c'est pas bon pour les yeux et le mal de crâne de comparer ces codes

Sinon je viens d'avoir une autre idée...

Que disent mes tests ? La partie écran TFT ne fonctionne pas si il y a un autre périphérique SPI utilisé et câblé en parallèle (au niveau des broches CK, MISO et MOSI), qu'il s'agisse du shield Ethernet ou bien de la dalle tactile.
Il serait possible que l'écran TFT ne respecte pas totalement les spécifications du bus SPI et que la broche CS ne soit pas prise en compte.
D'ailleurs c'est curieux que le tutorial pour utiliser l'écran TFT demande de ne pas câbler l'écran TFT et la dalle tactile sur les mêmes broches SPI.
J'ai vu sur un blog en anglais que les périphériques SPI pouvaient ne pas tenir compte de la broche CS...
La solution : des transistors pour empêcher l'écran TFT de voir les signaux CK et MOSI si la broche CS est à l'état haut.

Le fait que l'écran TFT soit relié à l'Arduino via des résistances de 10K (adaptation 5V -> 3.3V) simplifie les choses : il suffit que chaque transistor shunte la borne CK et MOSI de l'écran TFT, la résistance de 10K n'empêchera pas le module Ethernet de fonctionner avec l'Arduino.

Je câble, je teste et je reviens vers vous...

A bientôt

[Vincent PETIT]

Salut,
Tu peux nous donner le lien vers les schémas/docs de chaque element ?

Je voudrai regarder quelques choses au niveau hardware, en espérant qu'on trouve les schémas et les docs constructeurs de ce qui se trouvent sur les cartes.

Ton oscillo peut décoder le SPI visiblement, est ce que tout est ok de ce côté ?