TFT tactile SPI et Ethernet Shield 2 SPI en même temps sur un Arduino UNO ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

1 pièce(s) jointe(s)

TFT tactile SPI et Ethernet Shield 2 SPI en même temps sur un Arduino UNO ?

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

Pièce jointe 572695

(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:

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 :aie:

Code:

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

13/06/2020, 15h54
jpbbricole
Bonjour electroremy

Citation:

Envoyé par 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!:pastaper:

Une petite question, pourquoi avoir changé:
Code:

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.
13/06/2020, 15h59
electroremy
Citation:
Envoyé par jpbbricole

Une petite question, pourquoi avoir changé:

Code:

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

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

Code:

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

13/06/2020, 16h23
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:

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.

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:

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:

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

13/06/2020, 16h31
Auteur

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

Bonjour,

Citation:

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

Citation:

Envoyé par Auteur

Voir le message

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:

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

13/06/2020, 16h46
jpbbricole

Bonjour Rémy

Citation:

Envoyé par electroremy

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
13/06/2020, 16h47
electroremy
Citation:

Envoyé par Auteur

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:

1 2 3 delay(1); digitalWrite(10, HIGH); delay(1);
13/06/2020, 17h07
electroremy
Citation:

Envoyé par jpbbricole

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:

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
13/06/2020, 17h36
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

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:

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

Citation:

Envoyé par Auteur

Voir le message

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:

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:

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:

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:

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

13/06/2020, 18h35
boijea

1 pièce(s) jointe(s)

Citation:

Envoyé par jpbbricole

... 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!:pastaper:

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 :pastaper::pastaper:

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:

Pièce jointe 572720

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).

Citation:

Envoyé par electroremy

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

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

Citation:

Envoyé par boijea

Voir le message

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:

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 ? :mouarf:

Je continue mes tests...

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

A bientôt

13/06/2020, 20h45
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.
13/06/2020, 21h22
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.
14/06/2020, 10h25
electroremy

Citation:

Envoyé par 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.

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 :aie: :mouarf:

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
14/06/2020, 10h45
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é ?

1 pièce(s) jointe(s)

Bonjour,

Avant de mettre mes transistors, j'ai vérifier qu'au repos (afficheur TFT inactif, code source qui utilise que l'écran TFT et la dalle tactile) que les niveaux de tension étaient les suivants :
- CS = +5V
- CL = 0V
- MOSI = 0V
Mon câblage avec des transistors NPN est donc compatible

Voici le montage :

Pièce jointe 572812

Premiere chose à tester : que ça ne perturbe pas l'afficheur et la dalle tactile.

Je prends donc le programme qui utilise uniquement l'écran et la dalle tactile pour vérifier, et ça fonctionne

Code:

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

Maintenant, le programme qui essayer d'utiliser, en plus le shield Ethernet :

Code:

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
#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");
  }
 
    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(10);
      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(10);
    }
  }
}

Le résultat est le même :
- l'écran TFT fonctionne au début (setup)
- le webserveur fonctionne
- la dalle tactile fonctionne (le site web affiche les dernières coordonnées)
- mais l'écran TFT ensuite ne fonctionne pas

J'ai fait différents tests avec différentes vitesses du bus SPI dans w5100.h...

Avec la vitesse "normale" #define SPI_ETHERNET_SETTINGS SPISettings(14000000, MSBFIRST, SPI_MODE0)
L'écran TFT reste figé sur ce que je lui avait demandé d'afficher dans le setup

Avec une vitesse plus faible (je suis descendu jusque #define SPI_ETHERNET_SETTINGS SPISettings(1000, MSBFIRST, SPI_MODE0) pour voir)
L'écran TFT devient blanc

Il faut chercher ailleurs...

A bientôt

14/06/2020, 11h06
electroremy

Citation:

Envoyé par Vincent PETIT

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

Le Shield Ethernet 2 est le shield officiel Arduino, pas un clone douteux : https://store.arduino.cc/arduino-ethernet-shield-2

L'écran TFT est lui une chinoiserie acheté ici : https://www.amazon.fr/gp/product/B07..._title_o00_s03
Il y a de la doc ici : Http://tftdata.tjc1688.com/2.8_spi/2.8-spi-9341.rar

Citation:

Envoyé par Vincent PETIT

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

Oui j'y ai pensé...
Le truc c'est que, lorsque je n'utilise pas le shield, l'écran TFT fonctionne
C'est lorsque j'utilise le shield Ethernet qu'ensuite je n'arrive pas à utiliser l'écran TFT

Ca va être compliqué, à l'oscilloscope, de séparer les données qui vont au Shield Ethernet et à l'écran TFT
... ou alors je retire dans loop tout ce qui concerne le shield Ethernet
La je pourrais comparer.

A bientôt

Citation:

Envoyé par 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.

Bonjour,

c'est ce que j'avais suspecté dans le post #6

Voici un extrait du code de Adafruit_SPITFT.cpp :
Code:

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(); }
Mais effectivement, tester d'autres bibliothèques n'est pas bête... surtout que l'afficheur est très lent avec la lib Adafruit (c'est pénible)

Celle là a l'air pas mal : https://github.com/marekburiak/ILI9341_due

A bientôt

Bonjour,

j'ai voulu tester la bibliothèque http://marekburiak.github.io/ILI9341_due/

je n'arrive même pas à faire un "hello world" :aie: :mouarf:

voici le fichier ILI9341_due_config.h (j'ai d'abord essayé avec le diviseur à 2 puis je l'ai monté...)

Code:

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
/*
ILI9341_due_config.h - Arduino Due library for interfacing with ILI9341-based TFTs
 
Code: https://github.com/marekburiak/ILI9341_due
Documentation: http://marekburiak.github.io/ILI9341_due/
 
Copyright (c) 2015  Marek Buriak
 
*/
 
#ifndef _ILI9341_due_configH_
#define _ILI9341_due_configH_
 
// comment out the SPI mode you want to use (does not matter for AVR)
//#define ILI9341_SPI_MODE_NORMAL	// uses SPI library
//#define ILI9341_SPI_MODE_EXTENDED	// uses Extended SPI in Due, make sure you use pin 4, 10 or 52 for CS
#define ILI9341_SPI_MODE_DMA		// uses DMA in Due
 
// set the clock divider
#if defined ARDUINO_SAM_DUE
#define ILI9341_SPI_CLKDIVIDER 128	// for Due
#elif defined ARDUINO_ARCH_AVR
#define ILI9341_SPI_CLKDIVIDER SPI_CLOCK_DIV2	// for Uno, Mega,...
#endif
 
// uncomment if you want to use SPI transactions. Uncomment it if the library does not work when used with other libraries.
#define ILI_USE_SPI_TRANSACTION
 
// comment out if you do need to use scaled text. The text will draw then faster.
#define TEXT_SCALING_ENABLED
 
// default letter spacing
#define DEFAULT_LETTER_SPACING 2
 
// default line spacing
#define DEFAULT_LINE_SPACING 0
 
// sets the space between lines as part of the text
//#define LINE_SPACING_AS_PART_OF_LETTERS
 
// number representing the maximum angle (e.g. if 100, then if you pass in start=0 and end=50, you get a half circle)
// this can be changed with setArcParams function at runtime
#define DEFAULT_ARC_ANGLE_MAX 360		
 
// rotational offset in degrees defining position of value 0 (-90 will put it at the top of circle)
// this can be changed with setAngleOffset function at runtime
#define DEFAULT_ANGLE_OFFSET -90	
 
 
 
 
#endif

Voici le code :

Code:

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
#include <SPI.h>
#include <ILI9341_due_config.h>
#include <ILI9341_due.h>
 
#include "fonts/Arial_bold_14.h"
 
#define TFT_CS 0
#define TFT_DC 9
#define TFT_RST 8
ILI9341_due tft = ILI9341_due(TFT_CS, TFT_DC, TFT_RST);
 
#define TFT_PWM_LED 6 // Un transistor PNP permet de piloter le rétroéclairage 
 
void setup()
{
	Serial.begin(9600);
 
	bool result = tft.begin();
 
/*
	Serial.print("TFT begin successful: ");
	Serial.println(result ? "YES" : "NO");
*/
 
  analogWrite(TFT_PWM_LED,128);
 
	tft.setRotation(iliRotation270);
	tft.fillScreen(ILI9341_BLUE);
 
	tft.setFont(Arial_bold_14);
	tft.setTextLetterSpacing(5);
	tft.setTextColor(ILI9341_WHITE, ILI9341_BLUE);
	tft.printAligned(F("Hello World"), gTextAlignMiddleCenter);
}
 
void loop()
{
 
	/* add main program code here */
 
}

Note : j'ai désactivé les lignes qui utilisaient sérial, mais ça ne change rien

Lorsque ces lignes étaient activités, le moniteur série m'affichait TFT begin successful: YES

A bientôt

Citation:

Envoyé par f-leb

Voir le message

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.

Bonjour,

je viens de tester la librairie que tu indiques

voici le fichier User_Setup.h :

Code:

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
//                            USER DEFINED SETTINGS V16
//            Set fonts to be loaded, pins used and SPI control method
 
 
// ##################################################################################
//
// Define the fonts that are to be used here
//
// ##################################################################################
 
// Comment out the #defines below with // to stop that font being loaded
// As supplied font 8 is disabled by commenting out
//
// If all fonts are loaded the extra FLASH space required is about 17000 bytes...
// To save FLASH space only enable the fonts you need!
 
#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
//#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
//#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
//#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
//#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
 
 
// ##################################################################################
//
// Define the pins that are used to interface with the display here
//
// ##################################################################################
 
// We must use hardware SPI
// FYI Mega SCK is pin 52, MOSI is 51, UNO/NanoPro micro etc SCK is pin 13 and MOSI is 11
// Leonardo Pro micro SCK is pin 15 and MOSI is 16
 
// These are the control pins I use on my Mega setup
//   TFT_CS  47  // Chip select control pin
//   TFT_DC  48  // Data Command control pin
//   TFT_RST 44  // Reset pin (could connect to Arduino RESET pin)
 
// These are the control pins I use on my UNO/Nano/Pro Micro/ATmega328 setup
//   TFT_CS  10  // Chip select control pin
//   TFT_DC   9  // Data Command control pin
//   TFT_RST  7  // Reset pin (could connect to Arduino RESET pin)
 
// ###### EDIT THE PIN NUMBERS IN THE 3 LINES FOLLOWING TO SUIT YOUR SETUP ######
 
//#define TFT_CS   10  // Chip select control pin
//#define TFT_DC   8  // Data Command control pin
//#define TFT_RST  7  // Reset pin (could connect to Arduino RESET pin)
 
#define TFT_CS   0  // Chip select control pin
#define TFT_DC   9  // Data Command control pin
#define TFT_RST  8  // Reset pin (could connect to Arduino RESET pin)
 
 
// ##################################################################################
//
// Other speed up options
//
// ##################################################################################
 
// If your sketch uses the GLCD font in size 1 with background then uncomment
// this next line will speed up rendering x5, code size will increase 136 bytes
// Only worth it if you print lots of GLCD font text...
 
#define FAST_GLCD
 
// Uncomment the following #define to invoke a 20% faster drawLine() function
// This speeds up other funtions such as triangle outline drawing too
// Code size penalty is about 72 bytes
 
#define FAST_LINE
 
// Comment out the following #define to stop boundary checking and clipping
// for fillRectangle()and fastH/V lines. This speeds up other funtions such as text
// rendering where size>1. Sketch then must not draw graphics/text outside screen
// boundary. Code saving for no bounds check (i.e. commented out) is 316 bytes
 
//#define CLIP_CHECK
 
// Comment out the following #define if "SPI Transactions" do not need to be
// supported. Tranaction support is required if other SPI devices use interrupts.
// When commented out the code size will be ~700 bytes smaller and sketches will
// run slightly faster, so leave it commented out unless you need it!
// Transaction support is needed to work with SD libraru but not needed with TFT_SdFat
 
#define SUPPORT_TRANSACTIONS

Et le code testé :

Code:

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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
// Demo based on:
// UTFT_Demo_320x240 by Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
/*
 
 This sketch uses the GLCD and font 2 only. Disable other fonts to make
 the sketch fit in an UNO!
 
 Make sure all the required fonts are loaded by editting the
 User_Setup.h file in the TFT_ILI9341 library folder.
 
 If using an UNO or Mega (ATmega328 or ATmega2560 processor) then for best
 performance use the F_AS_T option found in the User_Setup.h file in the
 TFT_ILI9341 library folder.
 
 The library uses the hardware SPI pins only:
   For UNO, Nano, Micro Pro ATmega328 based processors
      MOSI = pin 11, SCK = pin 13
   For Mega:
      MOSI = pin 51, SCK = pin 52
 
 The pins used for the TFT chip select (CS) and Data/command (DC) and Reset (RST)
 signal lines to the TFT must also be defined in the library User_Setup.h file.
 
 Sugested TFT connections for UNO and Atmega328 based boards
   sclk 13  // Don't change, this is the hardware SPI SCLK line
   mosi 11  // Don't change, this is the hardware SPI MOSI line
   cs   10  // Chip select for TFT display
   dc   9   // Data/command line
   rst  7   // Reset, you could connect this to the Arduino reset pin
 
 Suggested TFT connections for the MEGA and ATmega2560 based boards
   sclk 52  // Don't change, this is the hardware SPI SCLK line
   mosi 51  // Don't change, this is the hardware SPI MOSI line
   cs   47  // TFT chip select line
   dc   48  // TFT data/command line
   rst  44  // you could alternatively connect this to the Arduino reset
 
  #########################################################################
  ###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ######
  ######       TO SELECT THE FONTS AND PINS YOU USE, SEE ABOVE       ######
  #########################################################################
 */
 
  #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
 
#include "SPI.h"
 
#include "TFT_ILI9341.h"
 
#define TFT_GREY 0x7BEF
 
TFT_ILI9341 myGLCD = TFT_ILI9341();       // Invoke custom library
 
unsigned long runTime = 0;
void setup()
{
  randomSeed(analogRead(A0));
  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  delay(10);
  digitalWrite(7, HIGH);
 
  analogWrite(TFT_PWM_LED,128);
 
// Setup the LCD
  myGLCD.init();
  myGLCD.setRotation(1);
}
 
void loop()
{
  randomSeed(millis());
  //randomSeed(1234); // This ensure test is repeatable with exact same draws each loop
  int buf[318];
  int x, x2;
  int y, y2;
  int r;
  runTime = millis();
// Clear the screen and draw the frame
  myGLCD.fillScreen(TFT_BLACK);
 
 
  myGLCD.fillRect(0, 0, 319, 14,TFT_RED);
 
  myGLCD.fillRect(0, 226, 319, 14,TFT_GREY);
 
  myGLCD.setTextColor(TFT_BLACK,TFT_RED);
  myGLCD.drawCentreString("* TFT_ILI9341 *", 160, 4, 1);
  myGLCD.setTextColor(TFT_YELLOW,TFT_GREY);
  myGLCD.drawCentreString("Adapted by Bodmer", 160, 228,1);
 
  myGLCD.drawRect(0, 14, 319, 211, TFT_BLUE);
 
// Draw crosshairs
  myGLCD.drawLine(159, 15, 159, 224,TFT_BLUE);
  myGLCD.drawLine(1, 119, 318, 119,TFT_BLUE);
  for (int i=9; i<310; i+=10)
    myGLCD.drawLine(i, 117, i, 121,TFT_BLUE);
  for (int i=19; i<220; i+=10)
    myGLCD.drawLine(157, i, 161, i,TFT_BLUE);
 
// Draw sin-, cos- and tan-lines  
  myGLCD.setTextColor(TFT_CYAN);
  myGLCD.drawString("Sin", 5, 15,2);
  for (int i=1; i<318; i++)
  {
    myGLCD.drawPixel(i,119+(sin(((i*1.13)*3.14)/180)*95),TFT_CYAN);
  }
  myGLCD.setTextColor(TFT_RED);
  myGLCD.drawString("Cos", 5, 30,2);
  for (int i=1; i<318; i++)
  {
    myGLCD.drawPixel(i,119+(cos(((i*1.13)*3.14)/180)*95),TFT_RED);
  }
  myGLCD.setTextColor(TFT_YELLOW);
  myGLCD.drawString("Tan", 5, 45,2);
  for (int i=1; i<318; i++)
  {
    myGLCD.drawPixel(i,119+(tan(((i*1.13)*3.14)/180)),TFT_YELLOW);
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
  myGLCD.drawLine(159, 15, 159, 224,TFT_BLUE);
  myGLCD.drawLine(1, 119, 318, 119,TFT_BLUE);
int col = 0;
// Draw a moving sinewave
  x=1;
  for (int i=1; i<(317*20); i++) 
  {
    x++;
    if (x==318)
      x=1;
    if (i>318)
    {
      if ((x==159)||(buf[x-1]==119))
        col = TFT_BLUE;
      else
      myGLCD.drawPixel(x,buf[x-1],TFT_BLACK);
    }
    y=119+(sin(((i*1.1)*3.14)/180)*(90-(i / 100)));
    myGLCD.drawPixel(x,y,TFT_BLUE);
    buf[x-1]=y;
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some filled rectangles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        col = TFT_MAGENTA;
        break;
      case 2:
        col = TFT_RED;
        break;
      case 3:
        col = TFT_GREEN;
        break;
      case 4:
        col = TFT_BLUE;
        break;
      case 5:
        col = TFT_YELLOW;
        break;
    }
    myGLCD.fillRect(70+(i*20), 30+(i*20), 60, 60,col);
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some filled, rounded rectangles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        col = TFT_MAGENTA;
        break;
      case 2:
        col = TFT_RED;
        break;
      case 3:
        col = TFT_GREEN;
        break;
      case 4:
        col = TFT_BLUE;
        break;
      case 5:
        col = TFT_YELLOW;
        break;
    }
    myGLCD.fillRoundRect(190-(i*20), 30+(i*20), 60,60, 3,col);
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some filled circles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        col = TFT_MAGENTA;
        break;
      case 2:
        col = TFT_RED;
        break;
      case 3:
        col = TFT_GREEN;
        break;
      case 4:
        col = TFT_BLUE;
        break;
      case 5:
        col = TFT_YELLOW;
        break;
    }
    myGLCD.fillCircle(100+(i*20),60+(i*20), 30,col);
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some lines in a pattern
 
  for (int i=15; i<224; i+=5)
  {
    myGLCD.drawLine(1, i, (i*1.44)-10, 223,TFT_RED);
  }
 
  for (int i=223; i>15; i-=5)
  {
    myGLCD.drawLine(317, i, (i*1.44)-11, 15,TFT_RED);
  }
 
  for (int i=223; i>15; i-=5)
  {
    myGLCD.drawLine(1, i, 331-(i*1.44), 15,TFT_CYAN);
  }
 
  for (int i=15; i<224; i+=5)
  {
    myGLCD.drawLine(317, i, 330-(i*1.44), 223,TFT_CYAN);
  }
 
  //delay(2000);
 
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some random circles
  for (int i=0; i<100; i++)
  {
    x=32+random(256);
    y=45+random(146);
    r=random(30);
    myGLCD.drawCircle(x, y, r,random(0xFFFF));
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some random rectangles
  for (int i=0; i<100; i++)
  {
    x=2+random(316);
    y=16+random(207);
    x2=2+random(316);
    y2=16+random(207);
    if (x2<x) {
      r=x;x=x2;x2=r;
    }
    if (y2<y) {
      r=y;y=y2;y2=r;
    }
    myGLCD.drawRect(x, y, x2-x, y2-y,random(0xFFFF));
  }
 
  //delay(2000);
 
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
// Draw some random rounded rectangles
  for (int i=0; i<100; i++)
  {
    x=2+random(316);
    y=16+random(207);
    x2=2+random(316);
    y2=16+random(207);
    // We need to get the width and height and do some window checking
    if (x2<x) {
      r=x;x=x2;x2=r;
    }
    if (y2<y) {
      r=y;y=y2;y2=r;
    }
    // We need a minimum size of 6
    if((x2-x)<6) x2=x+6;
    if((y2-y)<6) y2=y+6;
    myGLCD.drawRoundRect(x, y, x2-x,y2-y, 3,random(0xFFFF));
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
 //randomSeed(1234);
 int colour = 0;
 for (int i=0; i<100; i++)
  {
    x=2+random(316);
    y=16+random(209);
    x2=2+random(316);
    y2=16+random(209);
    colour=random(0xFFFF);
    myGLCD.drawLine(x, y, x2, y2,colour);
  }
 
  //delay(2000);
 
  myGLCD.fillRect(1,15,317,209,TFT_BLACK);
 
  // This test has been modified as it takes more time to calculate the random numbers
  // than to draw the pixels (3 seconds to produce 30,000 randoms)!
  //for (int i=0; i<10000; i++)
  //{
  //  myGLCD.drawPixel(2+random(316), 16+random(209),random(0xFFFF));
  //}
 
  // Draw 10,000 pixels to fill a 100x100 pixel box
  // use the coords as the colour to produce the banding
  byte i = 100;
  while (i--) {
    byte j = 100;
    while (j--) myGLCD.drawPixel(i+110,j+70,i+j);
    //while (j--) myGLCD.drawPixel(i+110,j+70,0xFFFF);
  }
  //delay(2000);
 
  myGLCD.fillScreen(TFT_BLUE);
  myGLCD.fillRoundRect(80, 70, 239-80,169-70, 3,TFT_RED);
 
  myGLCD.setTextColor(TFT_WHITE,TFT_RED);
  myGLCD.drawCentreString("That's it!", 160, 93,2);
  myGLCD.drawCentreString("Restarting in a", 160, 119,2);
  myGLCD.drawCentreString("few seconds...", 160, 132,2);
 
  runTime = millis()-runTime;
  myGLCD.setTextColor(TFT_GREEN,TFT_BLUE);
  myGLCD.drawCentreString("Runtime: (msecs)", 160, 210,2);
  myGLCD.drawNumber(runTime, 130, 225,2);
  delay (5000);
}

Pareil, aucun affichage :aie:

A bientôt

Bonjour,

en regardant le code de Adafruit_ILI9341.cpp je remarque ceci :

Code:

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
/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver with software SPI
    @param    cs    Chip select pin #
    @param    dc    Data/Command pin #
    @param    mosi  SPI MOSI pin #
    @param    sclk  SPI Clock pin #
    @param    rst   Reset pin # (optional, pass -1 if unused)
    @param    miso  SPI MISO pin # (optional, pass -1 if unused)
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t mosi,
                                   int8_t sclk, int8_t rst, int8_t miso)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, mosi, sclk,
                      rst, miso) {}
 
/**************************************************************************/
/*!
    @brief  Instantiate Adafruit ILI9341 driver with hardware SPI using the
            default SPI peripheral.
    @param  cs   Chip select pin # (OK to pass -1 if CS tied to GND).
    @param  dc   Data/Command pin # (required).
    @param  rst  Reset pin # (optional, pass -1 if unused).
*/
/**************************************************************************/
Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t rst)
    : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, rst) {}

Dans mon code et mon montage, j'utilise les broches SPI pour l'écran TFT...

Je devrais donc utiliser

Code:

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

au lieu de

Code:

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

Problème, si je compile ce code :

Code:

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
// 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);
 
  Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);
 
  #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);
    }
  }
}

J'ai une erreur call of overloaded 'Adafruit_ILI9341(int, int, int)' is ambiguous

Bizarement, le code fonctionne avec

Code:

1
2
3
4
5
6
7
8
9
  //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);

Donc je ferais du "software SPI" avec les broches hardware SPI ???

Plus étrange, j'avais testé ce code avec des broches différentes... (donc là ça aurait du faire du software SPI) ça ne fonctionnait pas

Précision : la dalle tactile doit certainement utiliser elle aussi du software SPI, car elle est raccordée sur les broches suivantes :

Code:

1
2
3
4
5
6
7
8
  //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);

Il y a un truc que je n'ai pas essayé :
- mettre la dalle tactile sur le hardware SPI avec le shield Ethernet
- mettre l'écran TFT sur d'autres broches en software SPI

A bientôt

14/06/2020, 13h24
Vincent PETIT

1 pièce(s) jointe(s)

Re,
En regardant le hard de l'afficheur, il y a quand même quelque chose d'anormal, tu peux mettre des pullup sur tous tes /CS (sauf le shield Ethernet, là elle y est, mais si le schéma dont tu as donné le lien, est bon alors elles ont été oubliées.)

Citation:

Envoyé par electroremy

Donc je ferais du "software SPI" avec les broches hardware SPI ???

Oui ça par contre c'est possiblement un problème surtout si c'est pas très très bien émulé.

En SPI on doit régler CPOL et CPHA, et faire ça en soft ça peut être complexe. Je n'ai pas eu le temps de regarder dans les datasheets qu'elles étaient les réglages demandés par les esclaves.

Pièce jointe 572848

Citation:

Envoyé par electroremy

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.

Non, non, fait pas ça. C'est la solution de celui qui n'a rien compris :aie:
14/06/2020, 20h00
electroremy

Bonjour,

Citation:

Envoyé par Vincent PETIT

Re,
En regardant le hard de l'afficheur, il y a quand même quelque chose d'anormal, tu peux mettre des pullup sur tous tes /CS (sauf le shield Ethernet, là elle y est, mais si le schéma dont tu as donné le lien, est bon alors elles ont été oubliées.)

D'abord merci d'avoir pris le temps de regarder :bravo:

Je ne comprends pas... la broche /CS est une entrée côté périphérique SPI et une sortie côté Arduino... Pourquoi avoir besoin de pullup ?

Les sorties Arduino que j'utilise sont-elles à collecteur ouvert ?

Citation:

Envoyé par Vincent PETIT

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.

Non, non, fait pas ça. C'est la solution de celui qui n'a rien compris :aie:

C'est un conseil vu ici : https://www.2bitornot2bit.com/blog/h...s-with-arduino

J'ai peut être trouvé une solution ici :https://forums.adafruit.com/viewtopic.php?f=31&t=69620

"The problem is that the SD driver and the TFT driver both set up the SPI control register (SPCR) differently. To make the two drivers work together, you have to re-set the control register to the right configuration before you start with a series of operations."

Résumons la situation :
- Dans tous les cas Shield Ethernet et la dalle tactile fonctionne
- Le TFT fonctionne tant que je ne commence pas à utiliser le Shield Ethernet
je ne dois pas être si loin de la solution. C'est pas comme si rien ne fonctionnait :aie:

Ce qui me chagrine c'est que pour ce projet je croyais avoir "joué la sécurité", j'ai choisi un Arduino UNO, un shield Ethernet officiel et un écran du commerce en me disant "ce sont des équipements répandus qui ont fait leur preuves depuis des années, je n'aurais aucun problème à les utiliser autant ne pas m'embêter à concevoir un circuit imprimé de A à Z avec un microcontrôleur et tout un tas de composants annexes, dont il faudra développer le code assembleur de A à Z" :mouarf:

Je ne suis quand même pas le premier à vouloir faire fonctionner un module Ethernet et un écran TFT tactile ensemble...

D'un autre côté si j'y arrive et que je publie mon projet ça aura du succès 8-) :mrgreen:

Je vais quand même tester l'histoire de la résistance pull-up c'est vite fait...

A bientôt

Bonjour,

je viens de découvrir autre chose.

Lorsque j'essayais de remplacer

Code:

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

par

Code:

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

J'avais une erreur call of overloaded 'Adafruit_ILI9341(int, int, int)' is ambiguous

En éditant Adafruit_ILI9341.h et Adafruit_ILI9341.cpp j'ai trouvé pourquoi : une surcharge de la fonction Adafruit_ILI9341() pour ESP8266 faisait doublon
J'ai donc mis les fonctions concernées en commentaire.

J'ai d'abord laissé

Code:

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

pour voir si le code fonctionne

Code:

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
// Programme qui fonctionne (écran TFT et dalle tactile) sur Arduino seul
// Programme qui fonctionne 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);
 
  //Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);
 
  #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);
    }
  }
}

Ca fonctionne normalement (c'est le fameux code qui n'utilise pas le Shield Ethernet

Maintenant, avec Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST)

Code:

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
// 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);
 
  Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);
 
  #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);
    }
  }
}

Et là, ça ne fonctionne plus :calim2:

Cela veut dire que depuis le début, je pilote mon écran TFT en faisant du software SPI sur les broches SPI (ce qui est aberrant)

Tant qu'à faire, si je fais du software SPI, autant utiliser d'autres broches et pas les broches SPI...
J'avais déjà essayé sans succès... je réessaye...

Code:

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
// 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 A0  //13
  #define TFT_MISO A1 //12
  #define TFT_MOSI A2 //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() {
  pinMode(A0, OUTPUT);
  pinMode(A2, OUTPUT);
 
  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);
    }
  }
}

Et là, ça fonctionne !
J'avais du faire une erreur de câblage lors de mon test précédent...

Maintenant, l'essai ultime : Shield Ethernet + Dalle Tactile + Ecran TFT, tout sur des broches séparées...

Code:

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
#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 A0  //13
  #define TFT_MISO A1 //12
  #define TFT_MOSI A2 //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() {
  pinMode(A0, OUTPUT);
  pinMode(A2, OUTPUT);
 
  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");
  }
 
    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(10);
      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(10);
    }
  }
}

Et là ça fonctionne 8-) :D

Bon OK c'est crade :
- Il n'y a plus que 3 broches de libres (en fait 4 car je n'utilise pas le MISO avec l'écran TFT - en fait 6 car finalement les /CS du TFT et de la dalle tactile je pourrais les mettre à la masse) :aie:
- la dalle tactile est en software SPI au lieu d'utiliser le SPI :aie:
- l'écran TFT est en software SPI au lieu d'utiliser le SPI :aie:
- j'utilise 25164 octets (78%) de l'espace de stockage de programmes :aie:
- j'utilise 558 octets (27%)
- l'écriture sur l'écran TFT est lent

Il y a des optimisations à faire...

A bientôt

14/06/2020, 20h50
electroremy

1 pièce(s) jointe(s)

J'oubliais la photo de la solution crade :aie: 8-)

Pièce jointe 572887

Bonjour,

voici le code de calibration de l'écran tactile qui va avec mon montage (indispensable avec la bibliothèque URTouch) :

Code:

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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
// URTouch_Calibration 
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program can be used to calibrate the touchscreen
// of the display modules.
// This program requires the UTFT library and a touch
// screen module that is compatible with UTFT.
//
// It is assumed that the display module is connected to an
// appropriate shield or that you know how to change the pin 
// numbers in the setup.
//
// Instructions will be given on the display.
//
 
#include <UTFT.h>
#include <URTouch.h>
 
// Define the orientation of the touch screen. Further 
// information can be found in the instructions.
#define TOUCH_ORIENTATION  PORTRAIT
 
//On définit les broches pour la partie affichage
  #define TFT_CLK A0  //13
  #define TFT_MISO A1 //12
  #define TFT_MOSI A2 //11
  #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
UTFT    myGLCD(ILI9341_S5P,TFT_MOSI,TFT_CLK,TFT_CS,TFT_RST,TFT_DC);
 
  #define TFT_PWM_LED 6 // Un transistor PNP permet de piloter le rétroéclairage 
 
//On définit les broches pour la partie tactile
  #define t_IRQ 5
  #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  myTouch(t_SCK, t_CS, t_MOSI, t_MISO, t_IRQ);
 
// ************************************
// DO NOT EDIT ANYTHING BELOW THIS LINE
// ************************************
 
// Declare which fonts we will be using
extern uint8_t SmallFont[];
 
uint32_t cx, cy;
uint32_t rx[8], ry[8];
uint32_t clx, crx, cty, cby;
float px, py;
int dispx, dispy, text_y_center;
uint32_t calx, caly, cals;
char buf[13];
 
void setup()
{
  pinMode(A0, OUTPUT);
  pinMode(A2, OUTPUT);
  analogWrite(TFT_PWM_LED,128);
 
 
  myGLCD.InitLCD();
  myGLCD.clrScr();
  myGLCD.setFont(SmallFont);
 
  myTouch.InitTouch(TOUCH_ORIENTATION);
  dispx=myGLCD.getDisplayXSize();
  dispy=myGLCD.getDisplayYSize();
  text_y_center=(dispy/2)-6;
}
 
void drawCrossHair(int x, int y)
{
  myGLCD.drawRect(x-10, y-10, x+10, y+10);
  myGLCD.drawLine(x-5, y, x+5, y);
  myGLCD.drawLine(x, y-5, x, y+5);
}
 
void readCoordinates()
{
  int iter = 5000;
  int failcount = 0;
  int cnt = 0;
  uint32_t tx=0;
  uint32_t ty=0;
  boolean OK = false;
 
  while (OK == false)
  {
    myGLCD.setColor(255, 255, 255);
    myGLCD.print(F("*  PRESS  *"), CENTER, text_y_center);
    while (myTouch.dataAvailable() == false) {}
    myGLCD.print(F("*  HOLD!  *"), CENTER, text_y_center);
    while ((myTouch.dataAvailable() == true) && (cnt<iter) && (failcount<10000))
    {
      myTouch.calibrateRead();
      if (!((myTouch.TP_X==65535) || (myTouch.TP_Y==65535)))
      {
        tx += myTouch.TP_X;
        ty += myTouch.TP_Y;
        cnt++;
      }
      else
        failcount++;
    }
    if (cnt>=iter)
    {
      OK = true;
    }
    else
    {
      tx = 0;
      ty = 0;
      cnt = 0;
    }
    if (failcount>=10000)
      fail();
  }
 
  cx = tx / iter;
  cy = ty / iter;
}
 
void calibrate(int x, int y, int i)
{
  myGLCD.setColor(255, 255, 255);
  drawCrossHair(x,y);
  myGLCD.setBackColor(255, 0, 0);
  readCoordinates();
  myGLCD.setColor(255, 255, 255);
  myGLCD.print("* RELEASE *", CENTER, text_y_center);
  myGLCD.setColor(80, 80, 80);
  drawCrossHair(x,y);
  rx[i]=cx;
  ry[i]=cy;
  while (myTouch.dataAvailable() == true) {}
}
 
void waitForTouch()
{
  while (myTouch.dataAvailable() == true) {}
  while (myTouch.dataAvailable() == false) {}
  while (myTouch.dataAvailable() == true) {}
}
 
void toHex(uint32_t num)
{
  buf[0] = '0';
  buf[1] = 'x';
  buf[10] = 'U';
  buf[11] = 'L';
  buf[12] = 0;
  for (int zz=9; zz>1; zz--)
  {
    if ((num & 0xF) > 9)
      buf[zz] = (num & 0xF) + 55;
    else
      buf[zz] = (num & 0xF) + 48;
    num=num>>4;
  }
}
 
void startup()
{
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect(0, 0, dispx-1, 13);
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.drawLine(0, 14, dispx-1, 14);
  myGLCD.print(F("URTouch Calibration"), CENTER, 1);
  myGLCD.setBackColor(0, 0, 0);
 
  if (dispx==220)
  {  
    myGLCD.print(F("Use a stylus or something"), LEFT, 30);
    myGLCD.print(F("similar to touch as close"), LEFT, 42);
    myGLCD.print(F("to the center of the"), LEFT, 54);
    myGLCD.print(F("highlighted crosshair as"), LEFT, 66);
    myGLCD.print(F("possible. Keep as still as"), LEFT, 78);
    myGLCD.print(F("possible and keep holding"), LEFT, 90);
    myGLCD.print(F("until the highlight is"), LEFT, 102);
    myGLCD.print(F("removed. Repeat for all"), LEFT, 114);
    myGLCD.print(F("crosshairs in sequence."), LEFT, 126);
    myGLCD.print(F("Touch screen to continue"), CENTER, 162);
  }
  else
  {
    myGLCD.print(F("INSTRUCTIONS"), CENTER, 30);
    myGLCD.print(F("Use a stylus or something similar to"), LEFT, 50);
    myGLCD.print(F("touch as close to the center of the"), LEFT, 62);
    myGLCD.print(F("highlighted crosshair as possible. Keep"), LEFT, 74);
    myGLCD.print(F("as still as possible and keep holding"), LEFT, 86);
    myGLCD.print(F("until the highlight is removed. Repeat"), LEFT, 98);
    myGLCD.print(F("for all crosshairs in sequence."), LEFT, 110);
 
    myGLCD.print(F("Further instructions will be displayed"), LEFT, 134);
    myGLCD.print(F("when the calibration is complete."), LEFT, 146);
 
    myGLCD.print(F("Do NOT use your finger as a calibration"), LEFT, 170);
    myGLCD.print(F("stylus or the result WILL BE imprecise."), LEFT, 182);
 
    myGLCD.print(F("Touch screen to continue"), CENTER, 226);
  }
 
  waitForTouch();
  myGLCD.clrScr();
}
 
void done()
{
  myGLCD.clrScr();
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect(0, 0, dispx-1, 13);
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.drawLine(0, 14, dispx-1, 14);
  myGLCD.print(F("URTouch Calibration"), CENTER, 1);
  myGLCD.setBackColor(0, 0, 0);
 
  if (dispx==220)
  {  
    myGLCD.print(F("To use the new calibration"), LEFT, 30);
    myGLCD.print(F("settings you must edit the"), LEFT, 42);
    myGLCD.setColor(160, 160, 255);
    myGLCD.print(F("URTouchCD.h"), LEFT, 54);
    myGLCD.setColor(255, 255, 255);
    myGLCD.print(F("file and change"), 88, 54);
    myGLCD.print(F("the following values. The"), LEFT, 66);
    myGLCD.print(F("values are located right"), LEFT, 78);
    myGLCD.print(F("below the opening comment."), LEFT, 90);
    myGLCD.print(F("CAL_X"), LEFT, 110);
    myGLCD.print(F("CAL_Y"), LEFT, 122);
    myGLCD.print(F("CAL_S"), LEFT, 134);
    toHex(calx);
    myGLCD.print(buf, 75, 110);
    toHex(caly);
    myGLCD.print(buf, 75, 122);
    toHex(cals);
    myGLCD.print(buf, 75, 134);
  }
  else
  {  
    myGLCD.print(F("CALIBRATION COMPLETE"), CENTER, 30);
    myGLCD.print(F("To use the new calibration"), LEFT, 50);
    myGLCD.print(F("settings you must edit the"), LEFT, 62);
    myGLCD.setColor(160, 160, 255);
    myGLCD.print(F("URTouchCD.h"), LEFT, 74);
    myGLCD.setColor(255, 255, 255);
    myGLCD.print(F("file and change"), 88, 74);
    myGLCD.print(F("the following values."), LEFT, 86);
    myGLCD.print(F("The values are located right"), LEFT, 98);
    myGLCD.print(F("below the opening comment in"), LEFT, 110);
    myGLCD.print(F("the file."), LEFT, 122);
    myGLCD.print(F("CAL_X"), LEFT, 150);
    myGLCD.print(F("CAL_Y"), LEFT, 162);
    myGLCD.print(F("CAL_S"), LEFT, 174);
 
    toHex(calx);
    myGLCD.print(buf, 75, 150);
    toHex(caly);
    myGLCD.print(buf, 75, 162);
    toHex(cals);
    myGLCD.print(buf, 75, 174);
  }
 
}
 
void fail()
{
  myGLCD.clrScr();
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect(0, 0, dispx-1, 13);
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.drawLine(0, 14, dispx-1, 14);
  myGLCD.print(F("URTouch Calibration FAILED"), CENTER, 1);
  myGLCD.setBackColor(0, 0, 0);
 
  myGLCD.print(F("Unable to read the position"), LEFT, 30);
  myGLCD.print(F("of the press. This is a"), LEFT, 42);
  myGLCD.print(F("hardware issue and can"), 88, 54);
  myGLCD.print(F("not be corrected in"), LEFT, 66);
  myGLCD.print(F("software."), LEFT, 78);
 
  while(true) {};
}
 
void loop()
{
  startup();
 
  myGLCD.setColor(80, 80, 80);
  drawCrossHair(dispx-11, 10);
  drawCrossHair(dispx/2, 10);
  drawCrossHair(10, 10);
  drawCrossHair(dispx-11, dispy/2);
  drawCrossHair(10, dispy/2);
  drawCrossHair(dispx-11, dispy-11);
  drawCrossHair(dispx/2, dispy-11);
  drawCrossHair(10, dispy-11);
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.print(F("***********"), CENTER, text_y_center-12);
  myGLCD.print(F("***********"), CENTER, text_y_center+12);
 
  calibrate(10, 10, 0);
  calibrate(10, dispy/2, 1);
  calibrate(10, dispy-11, 2);
  calibrate(dispx/2, 10, 3);
  calibrate(dispx/2, dispy-11, 4);
  calibrate(dispx-11, 10, 5);
  calibrate(dispx-11, dispy/2, 6);
  calibrate(dispx-11, dispy-11, 7);
 
  if (TOUCH_ORIENTATION == LANDSCAPE)
    cals=(long(dispx-1)<<12)+(dispy-1);
  else
    cals=(long(dispy-1)<<12)+(dispx-1);
 
  if (TOUCH_ORIENTATION == PORTRAIT)
    px = abs(((float(rx[2]+rx[4]+rx[7])/3)-(float(rx[0]+rx[3]+rx[5])/3))/(dispy-20));  // PORTRAIT
  else
    px = abs(((float(rx[5]+rx[6]+rx[7])/3)-(float(rx[0]+rx[1]+rx[2])/3))/(dispy-20));  // LANDSCAPE
 
  if (TOUCH_ORIENTATION == PORTRAIT)
  {
    clx = (((rx[0]+rx[3]+rx[5])/3));  // PORTRAIT
    crx = (((rx[2]+rx[4]+rx[7])/3));  // PORTRAIT
  }
  else
  {
    clx = (((rx[0]+rx[1]+rx[2])/3));  // LANDSCAPE
    crx = (((rx[5]+rx[6]+rx[7])/3));  // LANDSCAPE
  }
  if (clx<crx)
  {
    clx = clx - (px*10);
    crx = crx + (px*10);
  }
  else
  {
    clx = clx + (px*10);
    crx = crx - (px*10);
  }
 
  if (TOUCH_ORIENTATION == PORTRAIT)
    py = abs(((float(ry[5]+ry[6]+ry[7])/3)-(float(ry[0]+ry[1]+ry[2])/3))/(dispx-20));  // PORTRAIT
  else
    py = abs(((float(ry[0]+ry[3]+ry[5])/3)-(float(ry[2]+ry[4]+ry[7])/3))/(dispx-20));  // LANDSCAPE
 
  if (TOUCH_ORIENTATION == PORTRAIT)
  {
    cty = (((ry[5]+ry[6]+ry[7])/3));  // PORTRAIT
    cby = (((ry[0]+ry[1]+ry[2])/3));  // PORTRAIT
  }
  else
  {
    cty = (((ry[0]+ry[3]+ry[5])/3));  // LANDSCAPE
    cby = (((ry[2]+ry[4]+ry[7])/3));  // LANDSCAPE
  }
  if (cty<cby)
  {
    cty = cty - (py*10);
    cby = cby + (py*10);
  }
  else
  {
    cty = cty + (py*10);
    cby = cby - (py*10);
  }
 
  calx = (long(clx)<<14) + long(crx);
  caly = (long(cty)<<14) + long(cby);
  if (TOUCH_ORIENTATION == LANDSCAPE)
    cals = cals + (1L<<31);
 
  done();
  while(true) {}
}

Bonsoir,

j'ai trouvé ce post en anglais : https://forum.developer.sony.com/top...ay-sw-spi-does

Citation:

I played around with the drivers you linked to.
And found that if you change the following line in Adafruit_SPITFT.h

//void initSPI(uint32_t freq = 0, uint8_t spiMode = SPI_MODE0);
void initSPI(uint32_t freq = 0, uint8_t spiMode = SPI_MODE3);
or even better in Adafruit_ILI9341 line 189:

initSPI(freq);
to
initSPI(freq, SPI_MODE3);
you should get the desired result.

Please give it a try and see if it works better.

BR
Karl

J'ai recâblé le TFT sur les broches SPI, fait la modif, testé mon programme avec
Code:

1 2 3 4 5 6 7 8 9 10 ... //On définit les broches pour la partie affichage #define TFT_CLK 13 #define TFT_MISO 12 #define TFT_MOSI 11 #define TFT_CS 0 #define TFT_DC 9 #define TFT_RST 8 Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST); ...
Mais rien à faire, ça ne fonctionne pas...

A bientôt

14/06/2020, 23h15
electroremy

Le problème pourrait aussi venir des résistances :

Citation:

I wouldn't use a resistive divider on SPI.
The resistors coupled with the gate capacitance form a low-pass filter limiting the maximum frequency you can reliably communicate at.
Using software SPI you are going a lot slower, so it works better.
You should use a proper active level shifter.

A bientôt

Bonsoir,

Voilà ça marche ! :D

Cette histoire de résistances... je me suis dit... il faut tester en baissant la vitesse...

Dans Adafruit_ILI9341.cpp j'ai remplacé la ligne

Code:

initSPI(freq);

par

Code:

initSPI(3000000, SPI_MODE3); //Pour que ça marche, il faut préciser une vitesse (possiblement plus élevée avec un convertisseur 5V/3.3V au lieu de résistances) et aussi le MODE3

J'ai câblé mon écran TFT sur le bus SPI, et utilisé Adafruit avec le hardware SPI

Code:

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
#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);
  Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);
 
  #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");
  }
 
    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);
      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);
    }
  }
}

Il faut donc :
- forcer le MODE 3 du bus SPI
- et aussi limiter la vitesse... avec 3000000 l'affichage est déjà 3 à 4 fois plus rapide qu'avec le software SPI 8-)

J'ai testé avec une vitesse de 4000000 ça ne marche pas, mais mes connections sont longues et j'ai de bêtes résistances de 10K en série au lieu d'un vrai convertisseur...

Il y a juste un petit truc un peu étrange...

A chaque fois que le shield Ethernet est utilisé l'écran clignote légèrement (comme s'il y avait une perturbation du rétroéclairage).
Cela n'arrivait pas lorsque l'écran était branché sur d'autres bornes que le SPI

A bientôt

15/06/2020, 00h29
electroremy

Bonjour,

Le petit clignotement bizarre lorsque le Shield Ethernet fonctionne ne se produit plus si je débranche la borne MISO de l'écran TFT

De toutes façon elle ne sert pas car dans mes programmes je ne lit pas de données depuis l'afficheur TFT

Voilà un problème résolu !
15/06/2020, 11h53
f-leb

Bonjour,

Bravo pour avoir réglé tous ces problèmes:bravo:

Par contre je suis un peu noyé dans ces explications et tous ces tests sur plus de 35 messages. Pourrais-tu résumer en un seul post toutes les modifications qui fonctionnent ?
15/06/2020, 17h46
electroremy

Citation:

Envoyé par f-leb

Bonjour,

Bravo pour avoir réglé tous ces problèmes:bravo:

Par contre je suis un peu noyé dans ces explications et tous ces tests sur plus de 35 messages. Pourrais-tu résumer en un seul post toutes les modifications qui fonctionnent ?

Alors pour résumer :

CABLAGE :
- Le shield Ethernet utilise le bus SPI, ainsi que la broche 4 pour le lecteur SD intégré ; c'est un shield, il faut faire avec, et on ne massacre pas le shield à la pince coupante :nono:
- L'écran TFT doit avoir sa broche CK et sa broche MOSI raccordées sur les broches SPI matérielles de l'Arduino
- NE PAS câbler la broche MISO de l'écran TFT
- Mette la broche /CS de l'écran TFT sur une autre broche (pas les broches SPI, ni la broche 4)
- Câbler la dalle tactile sur d'autres broches qui sont utilisées pour rien d'autre

CODE :
- pour la dalle tactile utiliser URTouch.h, ça fonctionne bien (je n'ai pas cherché à utiliser le SPI matériel)
- il faut utiliser Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST); en définissant la valeur des broches TFT_CS, TFT_DC, TFT_RST avec #define
- pour ne pas avoir l'erreur call of overloaded 'Adafruit_ILI9341(int, int, int)' is ambiguous il faut éditer Adafruit_ILI9341.h et Adafruit_ILI9341.cpp et mettre en commentaire les surcharges de la fonction Adafruit_ILI9341() pour ESP8266 qui font doublon car elles ont elles aussi trois paramètres
- il faut éditer Adafruit_ILI9341.cpp et remplacer initSPI(freq); par initSPI(freq, SPI_MODE3);
- enfin, dans le code, il faut appeler tft.begin(); avec en paramètre une vitesse compatible avec le câblage par exemple tft.begin(3000000);

On peut mettre une vitesse plus élevée avec un câblage court et un adaptateur de niveau 5V/3,3V digne de ce nom et rapide (les résistances en série forment un filtre passe bas avec les capacités parasites des entrées logiques de l'afficheur, donc elles brident la vitesse)

Je vais aller sur le forum de Adafruit et/ou leur envoyer un mail pour leur expliquer ce qu'il doivent corriger dans leur bibliothèque...

C'est encore ça le mieux à faire pour éviter que tout le monde galère...
Ou que tout le monde sous-exploite son matériel : combien se font couillonner en faisant du software SPI très lent sur les broches SPI matériel parce que sans mes modifs qui corrigent les bugs de la librairie, on ne peut pas faire autrement ? Surtout que si on n’épluche pas le code de la librairie, difficile de savoir que
- Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); c'est du software SPI
- Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST) du hardware SPI
Avoir deux constructeurs avec des noms explicites ça n'aurait pas été du luxe

C'est ça qui est un peu dommage avec le monde de l'open source... les références officielles sont plutôt succinctes, on se perd dans les forks qui se multiplient, on trouve plein de tutoriels mauvais ou qui ne vont pas au fond des choses, les bonnes infos sont éparpillées dans des forums telles des aiguilles dans des bottes de foin.
Pour ne rien arranger fabricants de clones et vendeurs de matériel ne maîtrisent pas les aspects logiciels et sont souvent incapables de fournir un manuel complet avec un exemple de code source optimal et propre.
Ajoutons à cela du matériel qui peut être défectueux ou ne pas respecter les spécifications (plus jamais je n’achèterais les modules Ethernet SPI W5100 à bas coût)
Bref un problème sur Arduino peut avoir tellement de causes que le débogage est parfois un vrai défit !

A bientôt
15/06/2020, 19h13
Auteur

Bonsoir,

bravo à toi.
Une question : qu'appelles-tu le SPI software et le SPI Hardware ?

Citation:

Envoyé par electroremy

combien se font couillonner en faisant du software SPI très lent sur les broches SPI matériel parce que sans mes modifs qui corrigent les bugs de la librairie, on ne peut pas faire autrement ? Surtout que si on n’épluche pas le code de la librairie, difficile de savoir que
- Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO); c'est du software SPI
- Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST) du hardware SPI
Avoir deux constructeurs avec des noms explicites ça n'aurait pas été du luxe

Hum, d’une part on est dans le logiciel libre, donc bien souvent la doc est dans le code source et ils sont très clair sur le Hardware SPI versus Software:
Code:

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 /**************************************************************************/ /*! @brief Instantiate Adafruit ILI9341 driver with software SPI @param cs Chip select pin # @param dc Data/Command pin # @param mosi SPI MOSI pin # @param sclk SPI Clock pin # @param rst Reset pin # (optional, pass -1 if unused) @param miso SPI MISO pin # (optional, pass -1 if unused) */ /**************************************************************************/ Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t mosi, int8_t sclk, int8_t rst, int8_t miso) : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, mosi, sclk, rst, miso) {} /**************************************************************************/ /*! @brief Instantiate Adafruit ILI9341 driver with hardware SPI using the default SPI peripheral. @param cs Chip select pin # (OK to pass -1 if CS tied to GND). @param dc Data/Command pin # (required). @param rst Reset pin # (optional, pass -1 if unused). */ /**************************************************************************/ Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t rst) : Adafruit_SPITFT(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT, cs, dc, rst) {}
Ensuite leur code fonctionne peut être avec leur écran... si vous avez un clone il se peut qu’il y ait des différences suffisantes pour créer des soucis...

Cela dit, gros bravo pour la persévérance et cette résolution de votre besoin !!

15/06/2020, 19h51
Jay M

Citation:

Envoyé par Auteur

Une question : qu'appelles-tu le SPI software et le SPI Hardware ?

Il y a des bibliothèques qui font du SPI en «*bit banging*» tout en logiciel - (un peu comme software serial émule port série matériel ils gèrent du SPI à la main)

Bien sûr c’est plus lent que quand c’est en matériel !!

Voir 40 message(s) de cette discussion en une page

Fuseau horaire GMT +2. Il est actuellement 00h14.

Copyright © 2000-2024 www.developpez.com - Legal informations