Aller plus loin avec un Minitel

Il y a beaucoup de vidéos à ce sujet : utiliser un minitel comme terminal.

Une liaison série et hop, on a un écran 40x25 + un clavier.

Il y a le récurrent exemple du "3615 FACEBOOK", mais je l'ai trouvé super mal développé. Pas développé du tout d'ailleurs.

Alors j'ai mis les mains dans le cambouis, en lisant totalement la doc STUM1B. elle décrit la totalité du fonctionnement interne du minitel via son superbe processeur 80C52 (motorola).

Et j'ai trouvé des infos grandioses : la config du bidule par le port série.

  • Déplacer le curseur à la position X, Y en 3 octets
  • Convertir le clavier en étendu
  • Mettre l'écran en 80x25
  • Obtenir tout un tas d'infos sur la config interne et la modifier à volonté
  • passer la vitesse série à 4800 bauds

Ah ben tiens, voilà, je bloque. chaque commande envoyée au minitel provoque un retour d'info (acquittement). C'est formidable! Oui, mais si le Minitel ne comprend pas la commande, il ne fait rien, mais peut tout de même renvoyer une info. Je commence à comprendre comment il gère ça, mais c'est pas gagné.

Par exemple :

modification de la vitesse du port série :

1 - envoyer le code de modification.
2 - si la manip fonctionne, le minitel envoie un acquittement à la nouvelle vitesse
3 - si la commande échoue, le minitel envoie un acquittement à l'ancienne vitesse

Alors on fait comment?

j'envoie la commande et passe tout de suite à la nouvelle vitesse, mais ça foire et le minitel m'envoie un charabia pas possible puisqu'il est resté à l'ancienne vitesse...

Et on s'aperçoit que tout fonctionne ainsi. si ça marche pas, t'es dans la M. (Bon, on débranche, on rallume et ça redevient comme avant, ouf).

Quelqu'un a déjà essayé de jouer avec les fonctionnalités internes du bidule (PRO1, PRO2, CSI...)?

Les PTT ont appelé ça le "Protocole", mais pas si protocolaire que ça!

Vous envoyez la commande, vous lisez la réponse en ayant changé la vitesse, si vous recevez rien ou du charabia revenez à la vitesse d’avant

C'est tellement simple...

J'aurais voulu faire quelque chose de simple et rapide, mais le charabia envoyé (par exemple) à 300 bauds alors que je lis à 4800, combien d'octets cela représente-t-il? Pour l'instant, je mets une tempo et teste différentes vitesses (on peut interroger le minitel et il nous répond à quelle vitesse il émet, je trouve ça génial! C'est comme appeler quelqu'un pour lui demander son numéro...)

Un autre souci est ma façon de récupérer ce qu'il envoie. j'ai désactivé l'ISR du core arduino et ai écrit la mienne, qui trie au fur et à mesure les données qui arrivent. Je mets ainsi à jour mes variables locales d'état en temps réel. Mon ISR ne devrait pas trop être gênée par le charabia, puisque comme le minitel, dès qu'une séquence ne correspond à rien, j'ignore. Mais j'ai un flag de surcharge (j'ai déjà réussi à faire déborder le tampon de réception du minitel, et seul un reboot peut rétablir la connexion). Pour l'instant, ce flag risque de perturber la réception côté arduino lors de mes tests, mais il est indispensable.

Ma question est surtout de voir si des gens étaient allés jouer en profondeur dans un minitel, pour comparer les façons de faire...

jamais essayé

pour la partie sur le vitesse il y a différentes approches, cf ce post par exemple

J-M-L:
pour la partie sur le vitesse il y a différentes approches, cf ce post par exemple

Il faudrait pour ça que le minitel renvoie du charabia... mais si on n'est pas à sa vitesse, ça ne se fait pas sur commande.

J'ai finalement résolu cette question de vitesse en trouvant (par moi même) que la bestiole n'accepte pas de changer de vitesse si on n'a pas déjà envoyé une commande simple du "protocole". Donc je procède ainsi :

1 - je lui demande la configuration clavier à 1200 bauds (la vitesse de base à l'allumage).
2 - si je reçois la bonne réponse, ok, je suis connecté et roule ma poule, tout est permis.
3 - si au bout d'une seconde, je n'ai toujours pas la bonne réponse, alors je recommence à 4800 bauds (la vitesse où il était avant que je reset mon arduino : je ne vois que ces deux vitesses possibles, du coup!)
4 - si je reçois une réponse correcte, c'est donc qu'il est à 4800, donc roule ma poule aussi.

Une fois tout ça fait, ben c'est tout bonheur, et depuis deux jours, j'implémente tout un tas de nouvelles fonctions, et je remplis une page d'écran en 1/4 de seconde. Reste que l'arduino, avec son peu de ram et flash, il va limiter la chose (j'en suis déjà à 50% juste avec le menu principal (10 options), malgré une optimisation du code au top).

Il faut que je fasse une vidéo de la chose pour montrer les services que peut rendre un minitel bien utilisé.

Super !

Bonjour,
Super :wink:
je suis avec intérêt ce post
ça donne des idées de bricolage pour cet hiver (j'en ai un bien rangé au grenier) ....

je suis très intéressé parton code pour changer la vitesse à 4800 bauds. tu as créé une library ? ton code est disponible quelque part ?

de la même façon, on peux aussi désactiver l'écho depuis le sketch plutôt qu'au clavier du minitel ?

mathkuma:
je suis très intéressé parton code pour changer la vitesse à 4800 bauds. tu as créé une library ? ton code est disponible quelque part ?

de la même façon, on peux aussi désactiver l'écho depuis le sketch plutôt qu'au clavier du minitel ?

Pour la postérité, j'ai trouvé mon bonheur ici : https://github.com/Lefinnois/Minitel
pour le changement de vitesse, la libraire permet de spécifier une vitesse lors de l'initialisation
Minitel(int rx, int tx, int speed);

ou vec la fonction
void setMaxSpeed();

pour désactiver ou activer l'écho local, ça se passe avec les commandes suivantes
activation
ESC, PRO3, AIGUILLAGE_ON, RCPT_ECRAN, EMET_MODEM
-> 0x1B 0x3B 0x61 0x58 0x52
->
minitel.textByte(0x1B);
minitel.textByte(0x3B);
minitel.textByte(0x61);
minitel.textByte(0x58);
minitel.textByte(0x52);

désactivation
ESC, PRO3, AIGUILLAGE_OFF, RCPT_ECRAN, EMET_MODEM
-> 0x1B 0x3B 0x60 0x58 0x52
->
minitel.textByte(0x1B);
minitel.textByte(0x3B);
minitel.textByte(0x60);
minitel.textByte(0x58);
minitel.textByte(0x52);

pas implémenté dans la libraire ci-dessus

Heureux que tu aies trouvé! Pour ma part, j'ai du aller fouiller assez loin pour au final faire une sale bidouille :

boolean minitel_init(){
  byte data, v_1200;
  
  LED_stop_ON;
  LED_run_ON;
//  UCSR0C = 0x24;  // Assynchrone, parité paire, 7 bits.
  data = 0;
  v_1200 = false;
// ici, on va chercher la vitesse actuelle de la prise du minitel. On n'a pas d'autres choix que de les tester une à une...  
// on part du principe que :
//   1 - le minitel vient d'être allumé, il est donc à 1200 bauds
//   2 - le minitel est déjà en route et on revient d'un reset arduino : il peut être à 4800 bauds.

    Serial.begin(4800, SERIAL_7E1);  // vitesse à 4800
    m_F_clavier = false;
    m_busy = false;   // on force le passage
    minitel_PRO2(0x72, 0x59);  // demande config clavier
    timer2_start;  // démarrer le time out
    while(!m_F_clavier){
      if (Msec > 1000) {  // time out 1 seconde !
        data = 1;
        break;
      }
    }  // attente de réponse
    timer2_stop;      // on arrête tout
    if (data == 1) {  // on a tapé le time out, c'est donc que le minitel n'est pas à 4800.
      Serial.end();
      IF_Et = 0;
      IF_data1 = 0;
      IF_data2 = 0;
      data = 0;
      Serial.begin(1200, SERIAL_7E1);  // vitesse de base du minitel
      m_F_clavier = false;
      m_busy = false;   // on force le passage
      minitel_PRO2(0x72, 0x59);  // demande config clavier
      timer2_start;
      while(!m_F_clavier){
        if (Msec > 1000) {  // time out 1 seconde !
          data = 1;
          break;
        }
      }  // attente de réponse
      timer2_stop;      // on arrête tout, le minitel ne répond pas...
      if (!data) {
        v_1200 = true;
      }
    }

// ---------------------------------------
    
  m_F_clavier = false;
  minitel_PRO3 (0x69, 0x59, 0x41);  // clavier en étendu
  while (!m_F_clavier){}     // attendre la validation
  m_F_clavier = false;
  minitel_PRO3 (0x69, 0x59, 0x43);  // flèches en codage simple
  while (!m_F_clavier){}     // attendre la validation

  if (v_1200) {           // modification de la vitesse pour la passer en 4800 bauds.
    m_F_prise = false;
    data = 0;
    minitel_PRO2 (0x6B, 0x76);  // demande de changement vitesse.
    Serial.end();
    Serial.begin(4800, SERIAL_7E1);
    timer2_start;
    while (!m_F_prise){
      if (Msec > 1000) {  // time out 1 seconde !
        data = 1;
        break;
      }
    }
    timer2_stop;      // si time out : on arrête tout, le minitel ne répond pas...
    if (data){  // raté, on reste en 1200, tant pis.
      Serial.end();
      Serial.begin(1200, SERIAL_7E1);
    } 
  }
  minitel_bip();
  m_F_ag_module &= (~m_F_ag_in_modem);         // mise à zéro du bit qui nous intéresse
  minitel_PRO3(0x60, 0x5A, 0x52);              // bloquage du modem pour arrêter l'écho local
  while(!(m_F_ag_module & m_F_ag_in_modem)){}  // attente du retour d'acquittement.
  minitel_clear();
  Serial.flush();  // attente de fin de transmission
  LED_stop_OFF;
  LED_run_OFF;
  return true;
}

C'est assez sioux comme méthode, d'autant plus que j'utilise tout un tas de flags qui sont mis à jour automatiquement au fur et à mesure des réceptions d'acquittements du minitel. Plus aussi un time out dans le cas où le minitel ne répond pas...
Le plus gros souci a été le fait que le minitel refuse de changer de vitesse si c'est la première commande qui lui est envoyé, d'où ma demande en premier de la configuration du clavier...

J'aurais bien fait une librairie, mais j'y arrive pas, c'est donc un fichier minitel.h qui contient tous les codes et que je copie dans le répertoire du sketch... Ca permet d'adapter le code à chaque projet...