[Jérémy]

Bonjour à tous,

J'ouvre ce nouveau POST, car je galère à bien comprendre le dialogue UART .

Voici le programme émission : Je vous écrit comme je crois comprendre les choses.

J'utilise 4 boutons pour envoyer car 4 chaines de caractères et de longueur différents ( lettres et chiffres) en guise d'exercice.

Donc après chaque envoie j'envoie aussi un CR et un LF pour dire au récepteur que c'est la fin de ma chaine quelques soit sa taille.

Voila mon programme émetteur : Voyez vous des erreurs à éviter . je pense que les bugs sont dans le programme réception plus délicat je trouve.

Code : Tout sélectionner

/*##################################################################################
Programme de test pour liaison UART-USB sur carte EasyPIC_V7 avec ecran PIC18FJ
Fait par Jérémy sur FantasPic.fr
- Version du "23-01-2016"
- MikroC version 6.6.2
- PIC 18F46K22 FOSC à 8MHZ, Quartz extrene de 8Mhz, PLL désactivée
- Data-Shit du PIC : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
- manuel et schéma de la carte : http://www.mikroe.com/downloads/get/1711/easypic_v7_manual_v104c.pdf
#################################################################################*/

#define BP0 PORTD.B0
#define BP1 PORTD.B1
#define BP6 PORTD.B6
#define BP7 PORTD.B7


// Connections de l'écran LCD
sbit LCD_RS at LATB4_bit;
sbit LCD_EN at LATB5_bit;
sbit LCD_D4 at LATB0_bit;
sbit LCD_D5 at LATB1_bit;
sbit LCD_D6 at LATB2_bit;
sbit LCD_D7 at LATB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// Fin connections LCD

// Déclaration des  variables utilisées  -------------------------------------------

char P_compteur[7];     // tableau contenant mon compteur de 5 chiffres ( int) + 2 pour le terminateur de string /0
char P_Variable[32];    // Tableau contenant  les caractéres des 8 variables de 3 chiffres ( 3x8=24) + 6 espaces + 2 terminateur = 32
char texte[55]= "1---5----10----15----20----25----30";  // Tablmeua contenant du texte
unsigned int Registre, Flag_Data_OK=0, i=0, Flag_Erreur=0, compteur = 95;
unsigned char var0=100, var1=101,var2=102, var3=103, var4=104, var5=105, var6=106, var7=110;

// Fin des variables----------------------------------------------------------------

//##################################################################################
//#########################      PROGRAMME PRINCIPAL       #########################
//##################################################################################
void main() {

    ANSELB = 0x00;            // Configure le PORTB en digital pour le LCD
    ANSELC = 0x00;            // PORTB en digital
    ANSELD = 0x00;            // PORTB en digital

    TRISB = 0x00;             // PORTB en sortie
    TRISC = 0x00;             // PORTC en sortie
    TRISD = 0xFF;             // PORTD en entrée

    UART1_Init(9600);          // Initialisation de l'UART
    delay_ms(100);            // Petite pause

    Lcd_Init();               // Initialisation du LCD
    Lcd_Cmd (_LCD_CLEAR);     // On efface l'écran
    Lcd_Cmd (_LCD_CURSOR_OFF);// On arrete le clignotement du curseur
    delay_ms(100);            // Petite pause

    Lcd_Out (1, 1, "Envoi:");
    Lcd_Out (2, 1, "Reception:");
//#######################    BOUCLE INFINIE     ####################################
 while (1)
 {

    if (((BP0==1) && (UART1_Tx_Idle() == 1)))  // Check le BP0 et le buffer
       {
            compteur++;                        // On incrémente le compteur
            IntToStr (compteur, P_compteur);   // On le convertit en string
            Lcd_Out (1, 8,P_compteur);         // On l'affiche sur le LCD de l’émetteur
            UART1_Write_Text(P_compteur);      // Envoie du texte
            UART1_Write(13);                   // envoie un CR
            UART1_Write(10);                   // Envoie un CL
            while (BP0==1);                    // Anti rebond
       }
       
    if (((BP1==1) && (UART1_Tx_Idle() == 1)))  // Check le BP1 et le buffer
       {
            Lcd_Out (1, 9,"TEXTE   ");            // On l'affiche sur le LCD de l’émetteur
            UART1_Write_Text(texte);           // Envoie du texte deja en string donc pas de conversion
            UART1_Write(13);                   // envoie un CR
            UART1_Write(10);                   // Envoie un CL
            while (BP1==1);                    // Anti rebond
       }
       
    if (((BP6==1) && (UART1_Tx_Idle() == 1)))  // Check le BP6 et le buffer
       {
            Lcd_Out (1, 9,"COMPTEUR");            // On l'affiche sur le LCD de l’émetteur
            var0++; var1++; var2++; var3++; var4++; var5++; var6++; var7+=5;   // On incrémente nos compteurs
            sprintf(P_Variable,"%3d %3d %3d %3d %3d %3d %3d %3d",var0,var1,var2,var3,var4,var5,var6,var7);  // On convertit
            UART1_Write_Text(P_Variable);     // Envoie du texte
            UART1_Write(13);                  // envoie un CR
            UART1_Write(10);                  // Envoie un CL
            while (BP6==1);                   // Anti rebond
       }
       
    if (((BP7==1) && (UART1_Tx_Idle() == 1)))  // Check le BP7 et le buffer
       {
            Lcd_Out (1, 9,"COMPTEUR");            // On l'affiche sur le LCD de l’émetteur
            var0--; var1--; var2--; var3--; var4--; var5--; var6--; var7-=5;  // On décrémente nos compteurs
            sprintf(P_Variable,"%3d %3d %3d %3d %3d %3d %3d %3d",var0,var1,var2,var3,var4,var5,var6,var7);  // On convertit
            UART1_Write_Text(P_Variable);     // Envoie du texte
            UART1_Write(13);                  // envoie un CR
            UART1_Write(10);                  // Envoie un CL
            while (BP7==1);                   // Anti rebond
       }

       if (((Flag_Erreur==1) && (UART1_Tx_Idle() == 1)))  // Check le le flag erreur  et le buffer
       {
            Lcd_Out (1, 1, "Erreur");   // Si erreur on l'affiche sur le LCD
            UART1_Write(13);            // envoie un CR
            UART1_Write(10);            // Envoie un CL
            Flag_Erreur=0;              // On RAZ le flag
            delay_ms(1000);
              _asm reset;               // On RESET
       }

  }
}
  

[Jérémy]

Après une après-midi de test je touche enfin au but .
Il me reste un probléme sur lequel je bute .

Quand j’appuie sur le BP6 (incrémentation), le texte sur le LCD des fois se décale . il s'agit du texte "COMPTEUR+" qui se retrouve sur la deuxième ligne et puis partout . je ne comprends pas pourquoi ? alors que je lui demande de s’afficher sur la ligne 1 a partir de la 8 position à chaque fois ?

pouvez vous aussi me confirmer que le fait de terminer une chaine de caractère par un terminateur , remplis toute le reste du tableau de blanc ?

Voici le programme test en emission :

Code : Tout sélectionner

/*##################################################################################
Programme de test pour liaison UART-USB sur carte EasyPIC_V7 avec ecran PIC18FJ
Fait par Jérémy sur FantasPic.fr
- Version du "23-01-2016"
- MikroC version 6.6.2
- PIC 18F46K22 FOSC à 8MHZ, Quartz extrene de 8Mhz, PLL désactivée
- Data-Shit du PIC : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
- manuel et schéma de la carte : http://www.mikroe.com/downloads/get/1711/easypic_v7_manual_v104c.pdf
#################################################################################*/

#define BP0 PORTD.B0
#define BP1 PORTD.B1
#define BP6 PORTD.B6
#define BP7 PORTD.B7


// Connections de l'écran LCD
sbit LCD_RS at LATB4_bit;
sbit LCD_EN at LATB5_bit;
sbit LCD_D4 at LATB0_bit;
sbit LCD_D5 at LATB1_bit;
sbit LCD_D6 at LATB2_bit;
sbit LCD_D7 at LATB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// Fin connections LCD

// Déclaration des  variables utilisées  -------------------------------------------

char P_compteur[7];     // tableau contenant mon compteur de 5 chiffres ( int) + 2 pour le terminateur de string /0
char P_Variable[32];    // Tableau contenant  les caractéres des 8 variables de 3 chiffres ( 3x8=24) + 6 espaces + 2 terminateur = 32
char texte[55]= "1---5----10----15----20----25----30";  // Tablmeua contenant du texte
unsigned int Registre, Flag_Data_OK=0, i=0, Flag_Erreur=0, compteur = 95;
unsigned int var0=100, var1=101,var2=102, var3=103, var4=104, var5=105, var6=106, var7=110;

// Fin des variables----------------------------------------------------------------

//##################################################################################
//#########################      PROGRAMME PRINCIPAL       #########################
//##################################################################################
void main() {

    ANSELB = 0x00;            // Configure le PORTB en digital pour le LCD
    ANSELC = 0x00;            // PORTB en digital
    ANSELD = 0x00;            // PORTB en digital

    TRISB = 0x00;             // PORTB en sortie
    TRISC = 0x00;             // PORTC en sortie
    TRISD = 0xFF;             // PORTD en entrée

    UART1_Init(9600);          // Initialisation de l'UART
    delay_ms(100);            // Petite pause

    Lcd_Init();               // Initialisation du LCD
    Lcd_Cmd (_LCD_CLEAR);     // On efface l'écran
    Lcd_Cmd (_LCD_CURSOR_OFF);// On arrete le clignotement du curseur
    delay_ms(100);            // Petite pause

    Lcd_Out (1, 1, "Envoi:");
    Lcd_Out (2, 1, "Reception:");
//#######################    BOUCLE INFINIE     ####################################
 while (1)
 {

    if (((BP0==1) && (UART1_Tx_Idle() == 1)))  // Check le BP0 et le buffer
       {
            compteur++;                        // On incremente le compteur
            IntToStr (compteur, P_compteur);   // On le convertit en string
            Lcd_Out (1, 8,P_compteur);         // On l'affiche sur le LCD de l'emettteur
            Lcd_Out (1, 14,"   ");
            UART1_Write_Text(P_compteur);      // Envoie du texte
            UART1_Write(13);                   // envoie un CR
            UART1_Write(10);                   // Envoie un CL
            while (BP0==1);                    // Anti rebond
            delay_ms(50);
       }
       
    if (((BP1==1) && (UART1_Tx_Idle() == 1)))  // Check le BP1 et le buffer
       {
            Lcd_Out (1, 9,"TEXTE   ");            // On l'affiche sur le LCD de l'emettteur
            UART1_Write_Text(texte);           // Envoie du texte deja en string donc pas de conversion
            UART1_Write(13);                   // envoie un CR
            UART1_Write(10);                   // Envoie un CL
            while (BP1==1);                    // Anti rebond
            delay_ms(50);
       }

    if (((BP6==1) && (UART1_Tx_Idle() == 1)))  // Check le BP6 et le buffer
       {
            Lcd_Out (1, 8,"COMPTEUR+");            // On l'affiche sur le LCD de l'emettteur
            var0++; var1++; var2++; var3++; var4++; var5++; var6+=100; var7+=1000;   // On incremente nos compteurs
            sprintf(P_Variable,"%3u  %3u  %3u  %3u  %3u  %3u  %3u  %3u",var0,var1,var2,var3,var4,var5,var6,var7);  // On convertit
            UART1_Write_Text(P_Variable);     // Envoie du texte
            UART1_Write(13);                  // envoie un CR
            UART1_Write(10);                  // Envoie un CL
            //while (BP6==1);                   // Anti rebond
            delay_ms(80);
       }
       
    if (((BP7==1) && (UART1_Tx_Idle() == 1)))  // Check le BP7 et le buffer
       {
            Lcd_Out (1, 8,"COMPTEUR-");            // On l'affiche sur le LCD de l'emettteur
            var0--; var1--; var2--; var3--; var4--; var5--; var6-=100; var7-=1000;  // On décremente nos compteurs
            sprintf(P_Variable,"%3u  %3u  %3u  %3u  %3u  %3u  %3u  %3u",var0,var1,var2,var3,var4,var5,var6,var7);  // On convertit
            UART1_Write_Text(P_Variable);     // Envoie du texte
            UART1_Write(13);                  // envoie un CR
            UART1_Write(10);                  // Envoie un CL
            while (BP7==1);                   // Anti rebond
            delay_ms(50);
       }

       if (((Flag_Erreur==1) && (UART1_Tx_Idle() == 1)))  // Check le le flag erreur  et le buffer
       {
            Lcd_Out (1, 1, "Erreur");   // Si erreur on l'affiche sur le LCD
            UART1_Write(13);            // envoie un CR
            UART1_Write(10);            // Envoie un CL
            Flag_Erreur=0;              // On RAZ le flag
            delay_ms(1000);
              _asm reset;               // On RESET
       }

  }
} 

Et en réception :

Code : Tout sélectionner

#include "Visual_TFT_ecran_objects.h"
// Déclaration des  variables utilisées  -------------------------------------------
unsigned int Registre, Flag_Data_OK=0, Index_Buffer=0, Flag_Erreur=0;
unsigned char Rx_buffer[55] ;
// Fin des varaibles----------------------------------------------------------------

// Début Interruption---------------------------------------------------------------
void interrupt (){
   if ((PIR1.RC1IF) && (RC1IE_bit)) // On check le FLAG de l'INT et si elle est autorisée
      {
       if (OERR1_bit)       // Gestion des erreurs ici over run erreur est traité
           {                 // saturation du buffer. 2 bit stockées une 3ieme recue.
              CREN1_bit = 0; // Remise à zéro de CREN1 pour effacer l'erreur
              Flag_Erreur = 1;
              _asm nop;
              CREN1_bit = 1;
              _asm nop;
           }

        while (FERR1_bit)       // Framing Error
           {                // Il s'agit du temps ecoulé trop long pour recevoir le bit de stop
             TXREG1='*';    // On indique une erreur par l'affichage d'un echo '*'
             Flag_Erreur = 1;
             Registre = RCREG1;
           }

        Registre=RCREG1;     // On enregsitre le buffer, qui a pour effet de RAZ le flag RC1IF

        if ((Registre == 13) || (Index_Buffer>=53)) // Si on recoit "CR" ou qu'on dépasse la taille du buffer
           {
             RC1IE_bit = 0;   // On interrompt la recetpion le temps de l'affichage
             Flag_Data_OK = 1;  // On léve le drapeau pour indiqué que le mot est fini
             Rx_buffer[Index_Buffer]=0;  // terminateur de string
           }
         else
           {
             Rx_buffer[Index_Buffer]= Registre; // On enregistre la lettre à l'emplacement de l'index dans le buffer
             Index_Buffer ++ ;                    // On incremente l'index pour la lettre suivante
            }
      }
}
// Fin Interruption ----------------------------------------------------------------

void main() {

  Start_TP();

//----- config. interrutpion ------------------------------------------------------
    INTCON.GIE = 1;           // Activation Global des INT
    INTCON.PEIE = 1;          // Active l'INT sur periphérique
    PIE1.RC1IE = 1;           // Active l'INT sur reception EUSART
    PIR1.RC1IF = 0;           // bit=0 --> buffer vide
//---------------------------------------------------------------------------------

  UART1_Init(9600);        // Initialisation de l'UART
  delay_ms(100);            // Petite pause

  TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
  TFT_Write_Text("Pas de reception", 70, 117);


  while (1) {
    Check_TP();
  
   if (Flag_data_OK==1)      // Si la drapeau de fin de trame, on affiche le mot stocker dans le buffer
       {

          TFT_Set_Brush(1, CL_BLACK, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE); // On efface le texte par un rectangle noir
          TFT_Rectangle(10,178, 320,190);

          TFT_Set_Font(TFT_defaultFont, CL_YELLOW, FO_HORIZONTAL);   // On ecrit notre mot recu
          TFT_Write_Text(Rx_buffer, 10, 175);

          Flag_data_OK = 0;            // on rearme notre drapeau
          Index_Buffer = 0;            // on raz l'index
          RC1IE_bit = 1;               // On autoriser l'INT

       }
   if (((Flag_Erreur==1) && (UART1_Tx_Idle() == 1)))  // Check le BP et le buffer
       {
            TFT_Write_Text("Erreur", 70, 90);  // Envoie du texte
            UART1_Write(13);       // envoie un CR
            UART1_Write(10);       // Envoie un CL
            Flag_Erreur=0;
            delay_ms(1000);
            TFT_Rectangle(70,90, 125,110);
            Flag_data_OK = 0;            // on rearme notre drapeau
            Index_Buffer = 0;            // on raz l'index
            RC1IE_bit = 1;               // On autoriser l'INT
       }
  }
} 

Question en plus :
on met un "0" en terminateur de string, mais ne peut-il pas etre confondu avec un "0" d'un chiffre ?

[Jérémy]

Question en plus :
on met un "0" en terminateur de string, mais ne peut-il pas être confondu avec un "0" d'un chiffre ?

Je viens de comprendre que le "0" rajouter en fin de chaine de caractère, n'est pas un simple 0, mais le premier caractère ACSII qui est un NULL ( /0). Pour affiché u n"0" il faut avoir la valeur 48 dans le tableau .

[paulfjujo]

bonjour,



// economie d'une paire de parentheses

Code : Tout sélectionner

  if ((BP0==1) && (UART1_Tx_Idle() == 1))  // Check le BP0 et le buffer   

// economie du test UART1_Tx_Idle
// car UART_Write ... test deja cette condition avant d'envoyer un char (ou un string)

Code : Tout sélectionner

if (BP0==1)  // Check le BP0    

J'ai deja rencontré des problemes de positionnement curseur ..
résolu en rajoutant un petit delai apres le positionnement et avant d'y ecrire quelque chose
nota : il est preferable de mettre le texte en dur dans le en Flash ROM plutot qu'en RAM
sinon le compilo le met en RAM par defaut.. ce peut etre problematique si on a peu de memoire RAM dispo.
de plus le test sur le nb de car empeche tout debordement taille ligne LCD

Code : Tout sélectionner


LCD_Cmd(0xC0+8);      // positionne sur 2em ligne at colonne 8
Delay_ms(25);
LCD_putsRom("Compteur+");;

void LCD_putsRom(const code char *s)
{int i=0;
  while((*s != 0)&& (i<16))  // si LCD 16 car / ligne
  {
    Lcd_Chr_Cp(char out_char);
      s++;i++;
  }
}
 

[Jérémy]

Re,

Des news du front !

J'ai essayé avec tempo et placement u curseur comme tu me la préconisé ! sans succès !
Mais j'ai déplacé le texte et au miracle ça fonctionne sans bug !

Je dois absolument mettre la ligne
Lcd_Out (1, 8,"COMPTEUR+");

APRÈS la ligne

sprintf(P_Variable,"%3u %3u %3u %3u %3u %3u %3u %3u",var0,var1,var2,var3,var4,var5,var6,var7);

Comme ceci
[spoil]

Code : Tout sélectionner

    if ((BP6==1) && (UART1_Tx_Idle() == 1))  // Check le BP6 et le buffer
       {
            var0++; var1++; var2++; var3++; var4++; var5++; var6+=100; var7+=1000;   // On incremente nos compteurs
            sprintf(P_Variable,"%3u  %3u  %3u  %3u  %3u  %3u  %3u  %3u",var0,var1,var2,var3,var4,var5,var6,var7);  // On convertit
            Lcd_Out (1, 8,"COMPTEUR+");            // On l'affiche sur le LCD de l'emettteur
            UART1_Write_Text(P_Variable);     // Envoie du texte
            UART1_Write(13);                  // envoie un CR
            UART1_Write(10);                  // Envoie un CL
            //while (BP6==1);                   // Anti rebond
            delay_ms(80);
       }

[/spoil]

Sinon ça bug . J'en déduis que la commande sprintf interagis avec le LCD , mais dans le détail je ne serais pas l'expliquer !

Concernant le placement du texte, je suis bien d'accord avec toi . Tu as la bonne facon de faire, amis elle est compliqué pour un novide dans mon genre. J'ai déjà du mal avec les strings, l'acsii et les inttostr et tout tout ..... Alors pour le moment je suis pas radin sur la mémoire et je fais au plus simple.

[Jérémy]

Re,

Bon j'avance un peu .... mais j'ai la désagréable sensation d'avoir résolu un problème sans le comprendre exactement .
Après avoir créer un bouton sur mon écran, en appuyant sur celui-ci j’envoie du texte en UART sur mon PIC qui l'affiche sur le LCD .
J'affiche aussi sur mon écran le mot "test" pour m'indiquer que j'ai envoyer quelques chose et ensuite je l'efface .

Programme émission:

Code : Tout sélectionner


void Bouton_TXOnClick()
   {
     UART1_Write_Text("Test Tx");     // Envoie du texte
     UART1_Write(13);                 // Envoie un CR
     TFT_Set_Font(TFT_defaultFont, CL_YELLOW, FO_HORIZONTAL);
     TFT_Write_Text("test", 10, 175);  // On ecrit un mot  sur l'écran pour verifier l'execution de la fonction

     delay_ms(500);

     TFT_Set_Brush(1, CL_BLACK, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE); // On efface le texte par un rectangle noir
     TFT_Rectangle(10,178, 320,190);
   }
   
    

programme reception :

Code : Tout sélectionner


    if (Flag_Data_OK == 1)             // reception d'un mot dans le buffer
       {
          Lcd_Out (2, 7, Rx_Buffer);   // On l'affiche sur le LCD
          delay_ms(1500);              // Petite pause
          Lcd_Out (2, 7,"         ");  // On l'efface

          Flag_data_OK = 0;            // on rearme notre drapeau
          Index_Buffer = 0;            // on raz l'index
          RC1IE_bit = 1;               // On autoriser l'INT

       }
        

Le probléme venait du fait que je mette un UART1_Write(10); // Envoie un LF apres le UART1_Write(13); // Envoie un CR !

Une erreur était détecté . En enlevant le LF tout rentre dans l'ordre .
J'ai donc pensé que le premier mot se terminait après reception du CR, puis ensuite venait le second mot composé d'un LF seul donc qui ne s'arrete jamais car pas de CR . donc saturation du buffer donc erreur ?
Si mon raisonnement est bon . on ne peut donc pas faire de CR et LF ? sauf si on met une condition OU pour arrêter une chaine de caractère sur CR OU LF ?

Je sais pas si j'ai été très clair ?

[paulfjujo]

Lorsqu'on traite un AUART ET un LCD on est confronté au probleme que les 2 elements d'affichage ne sont pas tres compatible
Le LCD n'appreciant pas du tout de recevoir un LF ou CR, ou un string qui depasse la largeur (en carcateres) utile du LCD
avec ce probleme de LF ,On en arrive à vouloir afficher sur le LCD une ligne qui disparait de suite à cause de celui ci..

si tu recois effectivement CR LF

dans la routine de reception
si tu test uniquement CR
cela fait que tu met un 0 , fin de string à la place du CR dans le buffer
la chaine s'arrete bien AVANT le CR, mais à la prochaine reception, tu auras le LF , deja present dans RCREG
sauf si dans le traitemment test flag interrupt du "main",
tu fais une lecture registre RCREG pour le vider
avant de reinitialiser l'interrupt RX , et l'index du buffer à zero.

l'autre soluce serait de valider l'interrupt en traitant LF plutot que CR
je recois le LF , je met le drapeau à 1;
et je met zero dans buffer[index-1] au lieu de Buffer[Index]

[Jérémy]

Ok génial ! merci pour ces précisions parfaites .

Je suis content car j'avais vu juste ! mais je n'étais pas sur de mon raisonnement . Grâce tes indications j'y vois encore un peu plus clair . Je vais finir par comprendre à la longue .
Aujourd'hui j'avance bien car je garde les enfants malades , qui dorment lol .

Du coup j'ai bientôt finis ma simulation entre écran et pic . Si je veux être rigoureux je passe à l'I²C . car l' PIC18Fj va recevoir de l'UART par le transceiver, mais devras communiquer des infos par I2C a l’autre PIC

Merci bien Paulfjujo de prendre du temps pour mes problèmes qui doivent te paraitre bien facile