IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

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


Sujet :

Arduino

  1. #1
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut 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

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

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

    Avec ce montage :

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

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

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

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

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

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

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

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

    Merci

    A bientôt

  2. #2
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 016
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 016
    Points : 2 351
    Points
    2 351
    Par défaut
    Bonjour electroremy

    Citation Envoyé par electroremy Voir le message
    (Les deux leds rouges servent juste à caler la carte Arduino sur la plaque de prototypage)
    Je n'ai sans doute pas la solution à ton problème qui semble assez épineux, mais j'ai 2 remarques à faire, ton montage est absolument superbe et je n'ai pas vu les résistances de limitation de courant sur les 2 LED rouges!

    Une petite question, pourquoi avoir changé:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    //#define TFT_CS 10
    #define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI
    La pin 0 étant le Rx du port USB du UNO?

    Cordialement
    jpbbricole.

  3. #3
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Citation Envoyé par jpbbricole Voir le message
    Une petite question, pourquoi avoir changé:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    //#define TFT_CS 10
    #define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI
    La pin 0 étant le Rx du port USB du UNO?
    Bonjour,

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

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

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

    A bientôt

  4. #4
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Je viens d'essayer, cela n'a aucun effet

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

    A bientôt

  5. #5
    Expert éminent sénior
    Avatar de Auteur
    Profil pro
    Inscrit en
    Avril 2004
    Messages
    7 655
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 7 655
    Points : 11 150
    Points
    11 150
    Par défaut
    Bonjour,

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

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

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


    Et ce sont les flag CS qui vont activer ou non la communication vers tes modules :
    Code Arduino : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    digitalWrite(CSx, HIGH);
    digitalWrite(CSx, LOW);
    Voir après si c'est un état bas ou un état haut sur CS qui active ou désactive la communication vers le module.

  6. #6
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    J'ai décidé de jeter un oeil sur le contenu des librairies...

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

    Voici un extrait du code de Adafruit_SPITFT.cpp :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    /*!
        @brief  Call before issuing command(s) or data to display. Performs
                chip-select (if required) and starts an SPI transaction (if
                using hardware SPI and transactions are supported). Required
                for all display types; not an SPI-specific function.
    */
    void Adafruit_SPITFT::startWrite(void) {
      SPI_BEGIN_TRANSACTION();
      if (_cs >= 0)
        SPI_CS_LOW();
    }
     
    /*!
        @brief  Call after issuing command(s) or data to display. Performs
                chip-deselect (if required) and ends an SPI transaction (if
                using hardware SPI and transactions are supported). Required
                for all display types; not an SPI-specific function.
    */
    void Adafruit_SPITFT::endWrite(void) {
      if (_cs >= 0)
        SPI_CS_HIGH();
      SPI_END_TRANSACTION();
    }
    Le code de la librairie de l'écran TFT est assez explicite : la broche CS est remise à l'état haut avant de clore la transaction SPI

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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    void EthernetClass::MACAddress(uint8_t *mac_address)
    {
    	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
    	W5100.getMACAddress(mac_address);
    	SPI.endTransaction();
    }
     
    IPAddress EthernetClass::localIP()
    {
    	IPAddress ret;
    	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
    	W5100.getIPAddress(ret.raw_address());
    	SPI.endTransaction();
    	return ret;
    }
     
    IPAddress EthernetClass::subnetMask()
    {
    	IPAddress ret;
    	SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
    	W5100.getSubnetMask(ret.raw_address());
    	SPI.endTransaction();
    	return ret;
    }
    Dans Ethernet.h, on voit des SPI.endTransaction() partout mais aucune écriture de la broche CS...

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

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

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

    Je suis assez perplexe.

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

    A bientôt

  7. #7
    Expert éminent sénior
    Avatar de Auteur
    Profil pro
    Inscrit en
    Avril 2004
    Messages
    7 655
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 7 655
    Points : 11 150
    Points
    11 150
    Par défaut
    Peut-être ajouter une tempo entre 2 transactions ? Un digitalWrite() n'est pas instantané.

  8. #8
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Bonjour,

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

    Ta connectique devrait ressembler à ça :
    MOSI = 11
    MISO = 12
    CLK = 13
    CS Ethernet = 10
    CS carte SD = 4
    puis par exemple :
    CS TFT = 3
    CS tactile = 5
    C'est ce que j'ai fait, les broches 11, 12, 13 sont communes à l'écran et à l'Ethernet Shield.
    Mais pas à la dalle tactile... en fait j'ai suivit l'exemple de câblage d'un tutoriel... comme cela fonctionne je ne l'ai pas modifié.
    J'ai bien une broche unique pour CS de chaque périphérique SPI

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

  9. #9
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 016
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 016
    Points : 2 351
    Points
    2 351
    Par défaut
    Bonjour Rémy
    Citation Envoyé par electroremy Voir le message
    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

  10. #10
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Citation Envoyé par Auteur Voir le message
    Peut-être ajouter une tempo entre 2 transactions ? Un digitalWrite() n'est pas instantané.
    On a eu la même idée, dans le code (post précédent) j'ai testé

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
        delay(1);
        digitalWrite(10, HIGH);
        delay(1);

  11. #11
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Citation Envoyé par jpbbricole Voir le message
    Bonjour Rémy

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

    Cordialement
    jpbbricole
    Bien vu !

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

    Je modifie mon code source pour retirer la partie

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
        delay(1);
        digitalWrite(10, HIGH);
        delay(1);
    Au repos (serveur non sollicité) je vois que la broche 10 alterne entre 0 et 5V régulièrement : fréquence 27Khz, niveau à 5V les 2/3 du temps, à 0V le 1/3 du temps restant

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

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

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

    Là, je sèche...

    A bientôt

  12. #12
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    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

  13. #13
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Bonjour,

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

    J'ai modifié le programme comme suit :

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

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

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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    #include <SPI.h>
    #include <Ethernet.h>
     
    // Ethernet Shield 2 : communicates with both the W5500 and SD card using the SPI bus (through the ICSP header).
    // This is on digital pins 10, 11, 12, and 13 on the Uno and pins 50, 51, and 52 on the Mega.
    // On both boards, pin 10 is used to select the W5500 and pin 4 for the SD card. These pins cannot be used for general I/O.
    // On the Mega, the hardware SS pin, 53, is not used to select either the W5500 or the SD card, but it must be kept as an output or the SPI interface won't work.
     
    #include "Adafruit_GFX.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques    
    #include "Adafruit_ILI9341.h" // Trouvé et ajouté via le menu Outil / Gérer les bibliothèques
    #include "URTouch.h" // Ajouté au format ZIP      
     
      //On définit les broches pour la partie affichage
      #define TFT_CLK 13
      #define TFT_MISO 12
      #define TFT_MOSI 11
      //#define TFT_CS 10
      #define TFT_CS 0 // On change juste cette broche pour piloter aussi le module Ethernet avec le bus SPI
      #define TFT_DC 9
      #define TFT_RST 8
      Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);
     
      #define TFT_PWM_LED 6 // Un transistor PNP permet de piloter le rétroéclairage 
      // Il est possible d'ajuster le niveau de rétroéclairage en fonction de la luminosité ambiante grâce à une photodiode sur une entrée analogique
      // On peut réduire et éteindre le rétroéclairage après une période d'inactivité de la dalle tactile
      // Et réactiver le rétroéclairage en cas de notification
     
      //On définit les broches pour la partie tactile
      #define t_IRQ 5
      //#define t_MISO 4
      #define t_MISO 7 // La broche 4 est utilisée pour le lecteur SD de l'ethernet Shield
      #define t_MOSI 3
      #define t_CS 2
      #define t_SCK 1
      URTouch ts(t_SCK, t_CS, t_MOSI, t_MISO, t_IRQ);
     
     
    // Enter a MAC address and IP address for your controller below.
    // The IP address will be dependent on your local network:
    byte mac[] = {
      0xA8, 0x61, 0x0A, 0xAE, 0x75, 0xCA
    };
    IPAddress ip(192, 168, 123, 177);
     
    // Initialize the Ethernet server library
    // with the IP address and port you want to use
    // (port 80 is default for HTTP):
    EthernetServer server(80);
     
        char Buffer_DispXY[15];
        int sensorReading;
     
    void setup() {
      int radius = 4;
     
      analogWrite(TFT_PWM_LED,128);
     
      tft.begin();
      tft.setRotation(0);
     
      ts.InitTouch(PORTRAIT);
      ts.setPrecision(PREC_EXTREME);
      tft.fillScreen(ILI9341_BLACK);
     
      tft.setTextColor(ILI9341_RED, ILI9341_BLACK);
      tft.setTextSize(2);
     
      tft.fillCircle(10, 10, radius, ILI9341_YELLOW);
      tft.fillCircle(10, 310, radius, ILI9341_YELLOW);
      tft.fillCircle(230, 310, radius, ILI9341_YELLOW);
      tft.fillCircle(230, 10, radius, ILI9341_YELLOW);
      tft.fillCircle(120, 160, radius, ILI9341_YELLOW);
     
      sensorReading = 555;
      snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("A = %d"), sensorReading);
      tft.setCursor(55, 5);
      tft.print(Buffer_DispXY);
     
    /*
      // Open serial communications and wait for port to open:
      Serial.begin(9600);
      while (!Serial) {
        ; // wait for serial port to connect. Needed for native USB port only
      }
      Serial.println("Ethernet WebServer Example");
    */
     
      // You can use Ethernet.init(pin) to configure the CS pin
      //Ethernet.init(10);  // Most Arduino shields
      //Ethernet.init(5);   // MKR ETH shield
      //Ethernet.init(0);   // Teensy 2.0
      //Ethernet.init(20);  // Teensy++ 2.0
      //Ethernet.init(15);  // ESP8266 with Adafruit Featherwing Ethernet
      //Ethernet.init(33);  // ESP32 with Adafruit Featherwing Ethernet
     
      // start the Ethernet connection and the server:
      Ethernet.begin(mac, ip);
     
      // Check for Ethernet hardware present
      if (Ethernet.hardwareStatus() == EthernetNoHardware) {
        //Serial.println("Ethernet shield was not found.  Sorry, can't run without hardware. :(");
        while (true) {
          delay(1); // do nothing, no point running without Ethernet hardware
        }
      }
      if (Ethernet.linkStatus() == LinkOFF) {
        //Serial.println("Ethernet cable is not connected.");
      }
     
      // start the server
      server.begin();
      //Serial.print("server is at ");
      //Serial.println(Ethernet.localIP());
    }
     
     
    void loop() {
        int retro;
        int x, y;
     
        while (ts.dataAvailable())
      {
        ts.read();
        x = ts.getX();
        y = ts.getY();
     
        if ((x != -1) && (y != -1))
        {
          snprintf_P(Buffer_DispXY, sizeof(Buffer_DispXY), PSTR("X=%3d Y=%3d"), x, y);
          tft.setCursor(55, 5);
          tft.print(Buffer_DispXY);
          retro=y-10;
          if (retro<0) {retro=0;}
          if (retro>255) {retro=255;}
          analogWrite(TFT_PWM_LED,retro);
        }
      }
     
    }
    A bientôt

  14. #14
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

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

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

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

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

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

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

    A bientôt

  15. #15
    Rédacteur

    Homme Profil pro
    Architecte de système d'information
    Inscrit en
    Novembre 2006
    Messages
    503
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Architecte de système d'information
    Secteur : Transports

    Informations forums :
    Inscription : Novembre 2006
    Messages : 503
    Points : 1 332
    Points
    1 332
    Par défaut
    Citation Envoyé par jpbbricole Voir le message
    ... mais j'ai 2 remarques à faire, ton montage est absolument superbe et je n'ai pas vu les résistances de limitation de courant sur les 2 LED rouges!
    Oui, c'est superbe!
    Par contre, j’hésiterais sur la valeur des résistances des 2 LED rouges (t'as vraiment trop de matos!?!), je ne mettrais pas les mêmes

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

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

    Nom : ArduinoLM35r.jpg
Affichages : 1480
Taille : 1,20 Mo

    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 Voir le message
    Voici mon montage :
    - Arduino Uno Officiel
    - Shield Ethernet 2 Arduino Officiel SPI
    - Ecran tactile SPI
    Donc ... pourquoi pas un Arduino Uno WiFi Rev2?!
    Cordialement

  16. #16
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

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

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

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

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

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

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

    Je continue mes tests...

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

    A bientôt

  17. #17
    Expert éminent sénior
    Avatar de Auteur
    Profil pro
    Inscrit en
    Avril 2004
    Messages
    7 655
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 7 655
    Points : 11 150
    Points
    11 150
    Par défaut
    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.

  18. #18
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    12 864
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 12 864
    Points : 58 437
    Points
    58 437
    Billets dans le blog
    44
    Par défaut
    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.

  19. #19
    Membre expérimenté Avatar de electroremy
    Homme Profil pro
    Ingénieur sécurité
    Inscrit en
    Juin 2007
    Messages
    958
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Doubs (Franche Comté)

    Informations professionnelles :
    Activité : Ingénieur sécurité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 958
    Points : 1 312
    Points
    1 312
    Par défaut
    Citation Envoyé par Auteur Voir le message
    je vais faire mon casse-pieds...
    Quand je regarde tes constantes de tous les codes postés, je vois que tu n'as pas fait de modifications. Par exemple, je vois par exemple #define TFT_CS 0.
    Donc ma question est de savoir si les codes postés sont ceux testés.
    Bonjour,

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

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

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

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

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

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

    A bientôt

  20. #20
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 211
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 211
    Points : 11 722
    Points
    11 722
    Par défaut
    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é ?

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 3 123 DernièreDernière

Discussions similaires

  1. Arduino UNO + USB HOST Shield DUINOFUN
    Par fred2355 dans le forum Arduino
    Réponses: 9
    Dernier message: 26/04/2019, 22h55
  2. Réponses: 4
    Dernier message: 01/12/2018, 14h31
  3. Réponses: 2
    Dernier message: 31/12/2015, 11h11
  4. TFT TACTILE ADC STM32F1
    Par boby6613 dans le forum C
    Réponses: 8
    Dernier message: 26/04/2012, 16h17
  5. Réponses: 8
    Dernier message: 24/08/2006, 13h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo