[RESOLU] Voir en fin de sujet.

Voici le programme ! https://www.dropbox.com/s/ssdp1ol9quytpqt/Afficheur.7z?dl=0

Bonjour à tous,

Je possède un afficheur à LED "Baromètre alphanumérique - Alcatel"  que je souhaiterais piloter, via une carte Arduino par exemple:

/!\Je tiens à signaler avant tout que mes connaissances ne sont pas vraiment étendues en électronique et quasiment nulles au niveau des protocoles de communication etc  /!\

Après inspection de la bête:

l'afficheur est piloté par un microcontrôleur MC68HC705C8ACP

La doc de ce dernier -> (http://pdf.datasheetarchive.com/datasheetsmain/Datasheets-319/15791.pdf) m'as permise de déterminer plusieurs éléments du mode de transfert des données:

- Il s'agit d'une communication série de type RS232 ou RS422 (les deux sont possibles)

- Il y a deux fils pour la transmission des données, apparemment SG (Signal Groud) et RXD (Received data)

Ce que j'ai tenté pour l'instant:

M’étant renseigné à propos des communications séries et plus particulièrement du RS232, j'ai tenté d'envoyer un caractère à l'afficheur en utilisant une carte Arduino. C'est la que le premier problème survient: une communication série de type RS232 nécéssite des tensions comprises entre [-15V / -3V]  (1) et [3V / 15V] (0) or la carte Arduino est incapable (dites moi si je me trompe) d'envoyer des tensions négatives (je possède une Méga). J'ai donc bricolé un "inverseur de tension" (cf: http://www.circuitstoday.com/positive-voltage-to-negative-voltage-converter ) qui me permet d'obtenir du +5V et du -5V

Voici le code:

int _delay = 10;

void setup() {
  pinMode(22, OUTPUT);     //+5V  (0)
  pinMode(23, OUTPUT);     //-5V  (1)
  pinMode(52, OUTPUT);     //LED
}

void loop() {

  //Test envoi du caractère "K"    (11010010)

  digitalWrite(23, HIGH);          //Idle
  delay(300);

  digitalWrite(23, LOW);
  delay(_delay);

  digitalWrite(52, HIGH);       //ça envoie
  delay(_delay);

  digitalWrite(22, HIGH);           //Start
  delay(_delay);
  digitalWrite(22, LOW);

  send1();
  send1();
  send0();
  send1();
  send0();
  send0();
  send1();
  send0();

  digitalWrite(23, HIGH);           //Stop  -> Idle
  delay(300);
  digitalWrite(52, LOW);       //ça n'envoie plus
}

void send0()
{
  digitalWrite(22, HIGH);
  delay(_delay);
  digitalWrite(22, LOW);
}

void send1()
{
  digitalWrite(23, HIGH);
  delay(_delay);
  digitalWrite(23, LOW);
}

Ce qui en résulte:

-Ca ne marche pas (évidement )

-Je me suis rendu compte que mon convertisseur ne fonctionne pas comme prévu :

♦La tension en output reste quasiment constante (certains condensateurs ne se déchargement pas ?)

♦Je me rends compte en écrivant ces lignes que j'aurais du mettre une diode un niveau du triangle violet

♦Juste en branchant l'afficheur (au secteur)  il y a 6.66V au entre les deux fils de communication, est-ce normal ?

♦Je ne sais pas comment "cadencer" le transfert (la doc parle de "baud rate" (p 136) mais je n'y comprends pas grand chose)

Je vous remercie déja d'avoir lu jusqu'ici et vous demande quelques explications et conseils pour arriver à mon but (afficher des caractères).

Merci d'avance,    zDig

PS: je tiens à dire que l'afficheur a 2 cables: un transfo pour l'alimentation et une fiche RJ45 evec 2 fils (bleu et blanc en positions respectives 4 et 5) ce qui m'as conduit au (protocole/norme ?) EIA/TIA-561 mais je n'ai pas plus approfondi.

-
Edité par Gattzoune 17 juillet 2018 à 15:25:50

Arduino dispose déjà d'une liaison série hardware et d'une librairie pour l'utiliser.

Tu l'as d'ailleurs peut être même déjà utilisé puisqu'il s'agit du Serial.

Un petit exemple d'un code qui envoie Salut toutes les secondes :

void setup() {
    Serial.begin(9600);       // Initialisation du Serial avec un baudrate de 9600
}

void loop() {
    Serial.print("Salut");    // Envoie de Salut
    delay(1000);              // Attente d'une seconde
}

D'un point de vue hardware, il existe plusieurs normes pour définir les niveaux de tension d'une liaison série :

• Une vrai liaison série utilise effectivement des niveau de tension -15/+15V comme tu l'annonce

• Un liaison série TTL utilise des niveaux de tension 0/5V ou 0/3.3V

A noter que la liaison série de l'arduino est une liaison série TTL disponible sur les pins TX/RX (pins 0 et 1 si mes souvenir sont bons)

Si ton afficheur est aussi en TTL, tout ce que tu as à faire, c'est donc brancher la pin TX de l'arduino sur le RX de ton afficheur et relier le GND de l'arduino au GND de l'afficheur.

Si ton afficheur n'est pas en TTL mais utilise les niveaux standards, je te conseille vivement d'utiliser un circuit intégré MAX232 dont la mission consiste justement à convertir le -15/+15 en 0/5

La doc du processeur est complètement inutile ici puisque celle-ci décrit toutes les fonctions du processeur.

Elle t'annonce que le processeur possède des timers, une com série, des ports I/O... mais on s'en fou de tout ça...

Tout ce qui t’intéresse, c'est de savoir comment les ingénieurs qui ont conçu l'afficheur ont utilisé le processeur pour piloter les LED.

C'est donc dans la doc de l'afficheur que tu trouveras des infos sur :

• Les niveaux logiques utilisées (0/5V ou -15/+15)

• Le baudrate que les ingénieurs ont choisis d'utilisé (car le processeur est capable d'en faire pleins mais il te faut utiliser celui qu'ils ont choisis)

• Le protocole de communication à respecter (quels caractères envoyer pour qu'ils s'affichent sur l'afficheur)

Merci d'avoir répondu

La doc de cet afficheur est pour l'instant introuvable c'est pourquoi j'ai utilisé celle du processeur. Je vais tenter la communication TTL et si ça ne fonctionne pas je me procurerai un MAX232.

J'ai découvert un forum spécialisé Alcatel (alcatelunleashed.com) sur lequel j'ai trouvé quelques informations intéressantes quant à l’existence d’une doc et la configuration de la communication série.

-> http://www.alcatelunleashed.com/viewtopic.php?f=277&t=1719&hilit=serial+wallboard

Le 6 V en sortie du serial est-il normal ?

EDIT: Le TTL ne marche pas

-
Edité par Gattzoune 1 septembre 2015 à 15:06:41

C'est un peu rapide de dire que le TTL ne marche pas...

Qu'à tu essayé de faire exactement ?

Eh bien j'ai branché le TX de l'arduino au RX de l'afficheur et relié le GND de l'arduino à celui de l'afficheur. Et j'ai testé avec plusieurs baud rates : 600 4800 et 9600.

Que faut il penser du EIA/TIA-561 ? et des 6.66V au niveau du connecteur série de l'afficheur ?

-
Edité par Gattzoune 1 septembre 2015 à 17:51:35

Je ne sais pas vraiment quoi te dire là, sans la doc, c'est pratiquement mission impossible...

• Tu n'as aucune information sur le baudrate...

Cela pourrait très bien être 1200, 2400, 4800, 9600, 19200, 38400 ou encore autre chose (il en existe pleins de différents)

• Tu n'as aucune information sur les niveaux...

Cela pourrait très bien être 0/5V ou -12/+12 ou encore autre chose

• Tu n'as aucune idée sur le protocole...

Ce n'est pas parce que tu envoies Hello à l'afficheur qu'il va t'afficher Hello...

Peut être que l'afficheur attend une trame bien précise du genre [0:Hello] avec [ qui signifie le début de la trame, 0 qui signifie la position du début du texte, Hello qui correspond au message à afficher et ] qui signifie la fin de la trame.

Alors forcément, si tu ne respectes pas la trame, l'afficheur ne comprendra rien.

==========

Bref, cela fait beaucoup d'inconnu...

J'ai découvert un truc !

Lorsque je connecte l'afficheur au port TX0 et que je téléverse un programme, des caractères aléatoires s'affichent et restent affiché jusqu'a un nouveau téléversement -> c'est la communication USB qui est affichée

Le TX0 est relié au port PD0/RDI (p128 de la doc du proc.) du processeur en passant par un circuit intégré: H11L1 qui, semble-t-il passe le TTL en courant alternatif.

La reprogrammation de l'arduino se fait par le connecteur USB qui ré-injecte les données du téléversement sur le Serial au travers d'une puce FTDI.

Or, qui dit Serial dit aussi pin Tx/Rx donc si ton afficheur est relié à l'une de ces pins lors du téléversement, il reçoit les données du téléversement.

Dans tout ce qu'il reçoit, il doit interpréter des choses et affiche donc des données à l'écran.

En tout cas, cela signifie une chose : c'est bien du niveau TTL, pas besoin de MAX232 pour convertir en -15/+15.

De mémoire, il me semble que le baudrate utilisé pour le téléversement est 19200.

Vu que tu ne l'as pas testé, je pense que ce serait une bonne idée de voir ce qu'il se passe avec ce débit.

Et soit un peu persévérant avant de dire que ça ne marche pas tout de suite

-
Edité par lorrio 1 septembre 2015 à 20:44:12

J'ai déjà testé pas mal de baudrates ( 800, 1200, 4800, 9600, 19200, 34800 etc) mais l'afficheur se comporte toujours de la même manière...

N'y a-t-il pas autre chose que le baudrate qui puisse gêner l'interpretation ?

J'ai essayé de changer le pin du serial  (j'ai une Arduino Mega) et là, je n'obtiens plus rien (l'USB ne doit plus interagir)

Changer la pin du Serial ???

Quel branchement as tu fais et quel code utilises tu ?

J'ai mis "Serial1.begin" et "Serial1.print"

je me branches sur le TX1 de la carte que je relie au RX de l'afficheur. Je ne touche pas aux GNDs

C'est pas bon ?

Le GND de ton arduino doit être relié au GND de ton afficheur

Mais quel arduino utilises tu pour avoir Serial1 ???

Bah là, je ne vois pas quoi dire de plus...

Je t'ai déjà annoncer tout ce que j'étais en mesure de te dire sans la doc :

• Brancher le Tx de l'arduino sur le Rx de ton appareil sans convertisseur TTL (car apparemment, le fait que ça affiche des choses pendant un téléversement prouve que ce n'est pas nécessaire)

• Relier les 2 GND ensemble

• Utiliser le Serial grâce à Serial.begin et Serial.print

• Essayer plusieurs baudrate et insister particulièrement sur 19200 et 115200

• Essayer d'envoyer un max de choses jusqu'à voir quand l'afficheur réagit

----------

A noter que l'afficheur attend peut-être une frame d'auto baudrate donc je te conseillerais bien d'essayer ça :

void setup() {

    Serial1.begin(19200);                 // Initialisation du Serial avec un baudrate de 9600

    for ( int i = 0 ; i < 32 ; i++ ) {    // Boucle d'envoi de l'auto-baud en 0xAA
        Serial1.write( (char)0xAA );
    }

}
 
void loop() {
    Serial1.print("Salut");                // Envoie de Salut
    Serial1.write( (char)0x00 );           // Envoie d'un 0x00 (on sait jamais)
    delay(1000);                           // Attente d'une seconde
}

Essayes ça avec différents baudrate.

Essayes aussi en remplaçant 0xAA par 0x55.

A noter qu'il est préférable de procédé ainsi pour chaque essais :

1/ Téléversement sur arduino

2/ Reset de l'écran (avec un bouton reset si il en a un ou en coupant son alim)

3/ Reset de l'arduino (avec le bouton reset)

J'ai fait tout ce que tu m'as dit mais l'afficheur se comporte toujours de la même manière qu'avant :/

Je pense qu'il vaut mieux tenter de le contrôler en remplaçant directement le proc par l'arduino, non ?

Gattzoune a écrit:

J'ai fait tout ce que tu m'as dit mais l'afficheur se comporte toujours de la même manière qu'avant :/

Je pense qu'il vaut mieux tenter de le contrôler en remplaçant directement le proc par l'arduino, non ?

Effectivement, c'est une solution envisageable, surtout que le processeur est monté sur support donc amovible pour brancher autre chose.

Le mieux serait d'avoir le schéma électrique de la carte pour voir comment piloter les LED mais si tu ne trouves pas de doc, il y a encore moins de chance que tu trouves un schéma.

Cependant, le circuit électronique n'a pas l'air bien complexe, les pistes sont bien visible et l'ensemble très répétitif donc on peut facilement en déduire les schémas.

========================================

Il y a surement du multiplexage pour allumer toutes les LED dont on peut deviner la composition en regardant les composants de ta photo.

On voit qu'il y a 5 gros transistors en bas de ta carte et comme il y a 5 colonnes de LED par caractère, on peut en déduire que chaque transistor pilote une colonne des 12 caractères.

Il y a ensuite 12 drivers ou registres à 8 sorties en haut de la carte donc on peut en déduire que chaque driver contrôle les 7 lignes de son caractère.

-
Edité par lorrio 3 septembre 2015 à 10:01:54

SuN969 a écrit:

Si tu sais même pas comment ton proc est relié aux afficheurs tu peux laisser tomber l'idée de le remplacer...

Maintenant je sais !

Je viens de terminer le schéma du circuit ce sera plus pratique avec ça:
- Circuit1 (alim)
- Circuit2 (contrôleur)
- une martice de leds (un caractère) (1/12)
- une Photo annotée du circuit

J'ai fait des "jonctions" entre les schémas sous forme de X(numéroté) au bout d'un fil ou de "J3" ou "J1" colorés.

Si vous ne comprenez pas quelque-chose ou que vous trouvez des incohérences, n'hésitez pas à me demander.

Oui, c'est bien ce que je disais

DU multiplexage avec les colonnes reliées à chaque transistors et les circuit du haut pour les lignes

salut

j'ai le meme , j'y arrive pas non plus, pour info c"est du 4800b

Bonjour,

Désolé de déterrer le sujet, mais je suis confronté au même problème, i.e faire fonctionner un wallboard Alcatel 2x16 via le port série.

Du coup, je serai preneur des infos de VincentBafour ou/et Gattzoune sur la méthode pour faire fonctionner le bouzin.

Merci de votre aide.

Avant de déterrer, tu aurais peut-être du vers un tour sur leur profil

VincentBafour: