Ecran Bizarre ssd1306

Bonjour hbachetti

Les modules en ma possession, on effectivement 10K sur le bus i2C en entrée, par contre les bus SC0-SD0 à SC7-SD7 en sont dépourvus, c'est direct pin > connecteur.
Pour ce qui est des affichages OLED j'ai ceux-ci, SSD1306??, il y a > 1 mOhms entre SDA ou SCL et VCC.

Cordialement
jpbbricole

Bonsoir, du coup je l'ai met les résistances en pull up sur les sorties SCL et SDA de chaque ecran ?
Pour les TCA, j'ai bien des modules avec des résistances mais en effet pas sur les sorties, c'est le module violet sur la photo précédente.

Quand je parlais du discord ou des formations, en fait je cherche de quoi me former à l'arduino sur du long terme afin d'avoir un bon niveau. Des livres, des sites ....je suis preneur

Pour le discord, il s'agit d'un logiciel qui permet de communiquer en vocal ou par écrit en instantané avec des gens qui ont le même centre d'intérêt que nous.

J'ai trouvé des liens Discord mais ils sont parlés en anglais.... je cherche du francophone moi.
Merci à vous

Oui, il faut des pullups pour chaque écran.
Quelquefois ça fonctionne sans les pullups, mais ce n'est pas fiable.

Bonsoir à tous, j'en reviens vers vous pour la suite de mon projet, ça avance doucement mais j'ai bonne espoir.

Après avoir soudés une résistance de 4.7 Ohms sur chaque sortie SDA du TCA, les 6 écrans affichent du texte de façon répété comme prévu.
Seulement, maintenant, chaque fois que je demande de lire la valeur du Serial pour l'écrire sur les écrans, je me retrouve avec des écrans qui font des actions étranges.
Exemple : je demande le chiffre 58, les écrans vont affichés 13,48, 52 ( je met des chiffres aléatoires là ) bref, ça finit sur le chiffre 10. toujours... et je ne sais pas d'où il sort.

J'en appelle à votre aide.

#include <Adafruit_GFX.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>

/*#include <SSD1306Ascii.h>
  #include <SSD1306AsciiAvrI2c.h>
  #include <SSD1306AsciiSoftSpi.h>
  #include <SSD1306AsciiSpi.h>
  #include <SSD1306AsciiWire.h>
  #include <SSD1306init.h>
*/


#define OLED_RESET 4


Adafruit_SSD1306 ecran(OLED_RESET);


float voila = 335;

void TCA9548A(uint8_t bus) {
  Wire.beginTransmission(0x70);
  Wire.write(1 << bus );
  Wire.endTransmission();
}

void displayd() {

  ecran.clearDisplay();
  ecran.setTextColor(WHITE);
  ecran.setTextSize(2);
  ecran.setCursor(20, 0);
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  TCA9548A(1);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
 
  TCA9548A(2);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(3);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(4);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(5);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(6);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
}

void loop() {

  char carlu = 0;
  // variable contenant le nombre de caractère disponibles dans le buffer
  int cardispo = 0;

  cardispo = Serial.available();


  while (cardispo > 0) // tant qu'il y a des caractères à lire
  {
    carlu = Serial.read(); // on lit le caractère
   Serial.print(carlu); // puis on le renvoi à l’expéditeur tel quel
    cardispo = Serial.available(); // on relit le nombre de caractères dispo
    voila = carlu;
  }


  TCA9548A(1);
  displayd();
  ecran.print("ecran 6");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();
  

  TCA9548A(2);
  displayd();
  ecran.print("ecran 5");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();

  TCA9548A(3);
  displayd();
  ecran.print("ecran 4");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();
 
  TCA9548A(4);
  displayd();
  ecran.print("ecran 3");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();


  TCA9548A(5);
  displayd();
  ecran.print("ecran 2");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();
  

  TCA9548A(6);
  displayd();
  ecran.print("ecran 1");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();
  




}

Il faut que tu convertisses la chaîne de caractères reçue en nombre flottant (puisque voila est un float).


void loop() {
  if (Serial.available()) // si il y a des caractères à lire
  {
    char buf[10];
    int n=Serial.readBytesUntil('\n',buf, sizeof buf-1);
    buf[n]=0;   // fin de la chaine
    voila = atof(buf);
  }
// ...

Merci encore une fois Kamill, je vais tester ça dès que possible.
J'avoue que j'ai du mal à comprendre cette notion. Si j'écris un nombre dans le moniteur, pourquoi devoir convertir ce nombre ? Il est lu comme une chaine de caractères en fait, c'est ça ? Et pas comme un simple nombre ?
Que signifie ce 10 et pourquoi ce chiffre a chaque essai ?

Oui le nombre est envoyé comme une chaîne de caractères.
10 c'est le code ASCII du dernier caractère de !a chaîne qui est line feed'

1 Like

Bonsoir à tous, j'ai bien essayé ton code Kamill, alors il fonctionne très bien. Je tape le chiffre dans le moniteur, et il arrive illico sur les écrans. Seulement un char ne prend que 255 il me semble, et mes nombres doivent être des int ou au mieux, des float car j'aurai aimé connaitre jusqu'à la virgule de filament passés dans mon compteur.
Après maintes comprehension sur le port serie, j'ai connecté ma nano sur ma uno (RX, TX et inverse) . Pour rappel, la nano gère le rotary encodeur, et la uno les écrans.
Je demande donc à la nano d'envoyer en format long sa valeur recue du rotary via le port serie et a la uno de la lire et l'ecrire..... ben ca ne se passe pas comme prévu.

Oui j'ai bien des valeurs, mais elles sont aléatoires, parfois l'ecran ecrit -257 et un petit coup l'envoie a 10025 qui defile doucement puis zero, j'ai beau divisé la valeur envoyé par 10, ou modifier en long, int ou float.....mettre du delay pour contrecarré la latence... je ne sais plus quoi faire

code de la nano :

volatile long temp, compteur = 0; //Cette variable augmentera ou diminuera en fonction de la rotation de l'encodeur
    
void setup() {
  Serial.begin (9600);
  pinMode(2, INPUT_PULLUP); // entrée pullup interne 2 
  
  pinMode(3, INPUT_PULLUP); // entrée pullup interne 3
   
  //Une impulsion montante d'encoder active interrupt0(). AttachInterrupt 0 est sur DigitalPin 2.
  attachInterrupt(0, interrupt0, RISING);
   
  //Une impulsion montante d'encoder active interrupt1(). AttachInterrupt 1 est sur DigitalPin 3.
  attachInterrupt(1, interrupt1, RISING);
  }

void sendLong(long resultat) {
  Serial.write(resultat & 0xFF); // Envoi l'octet de poids faible
Serial.write((resultat >> 8) & 0xFF); 
Serial.write((resultat >> 16) & 0xFF); 
Serial.write((resultat >> 24) & 0xFF); // puis l'octet de poids fort
}
   
  void loop() {
  // Envoyer la valeur du compteur
      if( compteur != temp ){
          
          temp = compteur;
          long resultat = temp /10;
          sendLong(resultat);
          delay(50);
          /*Serial.println (resultat);
          Serial.write(resultat);*/
          }

  
  }
   
  void interrupt0() {
    
  if(digitalRead(3)==LOW) {
  compteur++;
  }else{
  compteur--;
  }
  }
   
  void interrupt1() {
  
  if(digitalRead(2)==LOW) {
  compteur--;
  }else{
  compteur++;
  }
  }

code de la UNO :

#include <Adafruit_GFX.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>

/*#include <SSD1306Ascii.h>
  #include <SSD1306AsciiAvrI2c.h>
  #include <SSD1306AsciiSoftSpi.h>
  #include <SSD1306AsciiSpi.h>
  #include <SSD1306AsciiWire.h>
  #include <SSD1306init.h>
*/


#define OLED_RESET 4


Adafruit_SSD1306 ecran(OLED_RESET);


long voila = 335;

void TCA9548A(uint8_t bus) {
  Wire.beginTransmission(0x70);
  Wire.write(1 << bus );
  Wire.endTransmission();
}

void displayd() {

  ecran.clearDisplay();
  ecran.setTextColor(WHITE);
  ecran.setTextSize(2);
  ecran.setCursor(20, 0);
}

void setup() {
  Wire.begin();
  Serial.begin(9600);

  TCA9548A(1);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
 
  TCA9548A(2);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(3);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(4);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(5);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
  TCA9548A(6);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  
}

void loop() {

/*if (Serial.available()) // si il y a des caractères à lire
  {
    char buf[10];
    int n=Serial.readBytesUntil('\n',buf, sizeof buf-1);
    buf[n]=0;   // fin de la chaine
    voila = atof(buf);
  }*/


  
  voila = Serial.read() + (Serial.read() << 8) + (Serial.read() << 16) + (Serial.read() << 24);





  TCA9548A(1);
  displayd();
  ecran.print("ecran 6");
  ecran.setCursor(10, 18);
  ecran.print(voila);
  ecran.display();
  

  TCA9548A(2);
  displayd();
  ecran.print("ecran 5");
  ecran.setCursor(10, 18);
  ecran.print("voila");
  ecran.display();

  TCA9548A(3);
  displayd();
  ecran.print("ecran 4");
  ecran.setCursor(10, 18);
  ecran.print("voila");
  ecran.display();
 
  TCA9548A(4);
  displayd();
  ecran.print("ecran 3");
  ecran.setCursor(10, 18);
  ecran.print("voila");
  ecran.display();


  TCA9548A(5);
  displayd();
  ecran.print("ecran 2");
  ecran.setCursor(10, 18);
  ecran.print("voila");
  ecran.display();
  

  TCA9548A(6);
  displayd();
  ecran.print("ecran 1");
  ecran.setCursor(10, 18);
  ecran.print("voila");
  ecran.display();
  

Je ne comprends pas pourquoi tu parles des char, le programme traite des float ainsi qu'est définie ta variable voila.

Affiche déjà la valeur du compteur sur le terminal série de la nano. Si c'est correct tu peux ensuite te pencher sur le problème de transmission.
Il n'y a pas de synchronisation ni rien qui indique le début ou la fin du message. Donc l'émission et la réception peuvent être désynchronisées et la réception peut commencer en plein milieu du message ce qui donne n'importe quoi.
Utilise une transmission ascii avec terminateur comme dans le programme au dessus.

Pourquoi tu lis l'encodeur avec une nano? Ça peut très bien être fait par la uno.

Bonjour Kamill, je parlais des char car le tableau que tu as crée pour récupérer les variables du Serial.available -> ( char buf [10]; ) ne peut prendre que 255 caractères non ? ou alors je m'embrouille entre variables char et tableau de char... enfin bref, c'est peut etre moi qui n'est pas bien maitrisé le sujet.

Je lit avec la nano, parce que la Uno doit gérer les écrans ainsi que l'écriture de la valeur sur une carte SD toutes les 5 minutes. Je me suis dit que ça faisait beaucoup de taches pour une seule carte, donc j'ai pensé que ce serait mieux afin d'eviter les problemes de le gérer avec une nano. Ce qui s'avère plus complexe que prévu.
Je pense que je doit réviser ma comprehension sur le port Serie et je vais regarder sur le terminal de la nano, ce qu'elle y écrit afin de récupérer cette valeur sur la Uno.

je suis désolé si je vous importune parfois avec mes questions répétitives, mais je suis à fond afin de comprendre et maitriser à mon niveau ce projet. Je patauge un peu, donc si vous avez quelques cours... je suis preneur

Le nombre peut contenir 9 caractères (en fait 9 plus le 0 final), ce qui est suffisant pour aller jusqu'à un milliard s'il n'y a pas de point décimal.

Je ne suis pas convaincu que la réception série prenne moins de temps processeur que la gestion directe de l'encodeur.
On tourne l'encodeur à la main, donc la fréquence des interruptions n'est pas très élevée.

1 Like

Merci encore de tes réponses Kamill, j'apprécie ton investissement dans mon projet.
Je vais tester de tout gérer avec la Uno alors, après tout, il est vrai que le mouvement du fil ne va pas bouger si vite que ça, je devrai pouvoir gérer je pense entre l'encodeur, l'enregistrement sur SD et l'affichage avec la Uno. A voir....

Oui, tu peux essayer de tout gérer avec la uno. Si ça ne fonctionne pas (mais ça m'étonnerait), tu pourras toujours revenir à ton idée première de gérer le codeur par une nano.