[Jérémy]

Bon j'avance mais j'y arrive pas ..... .
envoyer, quand j'appui sur un BP , la valeur d'un compteur avec mon Easypic sur l'UART, puis de le recevoir sur le PIC de mon écran et l'affiché. Toujours cette maudite histoire de conversion que je ne pas trop bien assimilée . mais a force de test je vais bien reussir

[sylvain54]

C'est plus pour faire un drone terrestre que du modélisme , mais ça y ressemble fortement en effet. j'ai déjà réaliser un drone terrestre, mais je souhaite recommencer avec plus d'option ce coup ci. Drone car il se pilote sans le voir avec des lunettes d'immersion. mais on en est pas encore la

Sympa le truc, Beau projet

Pour le tuto sur le TFT pro, j'ai vu, je me le garde sur le coude pour mon prochain projet. Je compte bien réussir également à faire fonctionner mes écrans easy TFT. Je me demande si tu n'as pas cramé le tien pendant tes essais ?! Ces écrans ne supportent pas le 5 V sur leurs lignes sauf pour l'éclairage.
Je ne manquerai pas de partager si j'y arrive.

Bon week-end.

++

[satinas]

C'est dommage que le lcd n'ait pas été placé sur le port parallèle PMP 8/16 bit du pic, en D0-D7. Il l'ont mis sur J0-J7, Il faut donc gérer toutes les pins en mode i/o. Avec le port PMP il suffisait d'écrire la data dans le registre output du PMP et la data partait aussi sec, le signal WR étant généré automatiquement par le module PMP.

[Jérémy]

Hello satinas ,

Bon je dois t’avouer que je n'ai pas trop compris ce que tu as dis. Le port PMP kesako ?

Par contre il m'arrive un truc chelou sans aucun doute du à la com UART . Ca risque d’être dur à expliquer.
Pour ce faire je parlerai du PIC qui se trouve sur ma carte EAsypic7 ( un 18F46K22), en tant que easypic , et l’écran sur mon écran comme le PIC PICFJ .

J'ai donc relié mes deux pics en UART reliant les broches RX/TX et TX/RX directement avec un fil . J'ai mis les masses en commun a l'aide d'un fil aussi.
Pour le moment je me suis contenter de simuler l'envoi d'info sur l'UART du Easypic au PICFJ. cette envoi s'effectue a chaque appui sur un BP de ma carte. l'info envoyer et juste un simple compteur qui s’incrémente a chaque appui .
Je rajoute aussi qu'a chaque envoi j'affiche la valeur que jai envoyé sur le LCD de la carte Easypic.
Voici le code de l’émetteur je vous passe les autres détail sauf si nécessaire !.

Code : Tout sélectionner

// Déclaration des  variables utilisées  -------------------------------------------
char P_compteur[5];
int Registre, Flag_Data_OK=0, i=0, Flag_Erreur=0, compteur = 48;

// Fin des varaibles----------------------------------------------------------------

    UART1_Init(57600);          // 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:");
   
   
if (((BP==1) && (UART1_Tx_Idle() == 1)))  // Check le BP et le buffer
       {
            compteur++;
            IntToStr (compteur, P_compteur);
            Lcd_Out (1, 8,P_compteur);
            UART1_Write_Text(P_compteur);  // Envoie du texte
            UART1_Write(13);       // envoie un CR
            while (BP==1);         // Anti rebond
            i=0;                   // Pour le test l'appui sur l’émission efface l’écran

       } 

Je passe pour un IntToStr car par la suite je pense envoyer une trame de 8 octets , comme le ferais mon transceiver en réel .

Et sur mon PICFJ à la reception j'ai ceci :

Code : Tout sélectionner

#include "Visual_TFT_ecran_objects.h"
// Déclaration des  variables utilisées  -------------------------------------------
unsigned int compteur1=0, compteur2=0 ;
char variable1[10];
char variable2[10];
char texte1[]="oups";
char texte2[]= "erreur";
int Registre, Flag_Data_OK=0, i=0, Flag_Erreur=0;
char Rx_buffer[5] ;
char Save_Rx_Buffer[3];
// 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
      {
        Registre=RCREG1;     // On enregsitre le buffer, qui a pour effet de RAZ le flag RC1IF

        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;
           }

        if ((Registre == 13) || (Registre == 10) || (i>=5)) // 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
           }
         else
           {
             Rx_buffer[i]= Registre; // On enregistre la lettre à l'emplacement de l'index dans le buffer
             i++;                    // 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(57600);        // 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_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
          TFT_Write_Text("Pas de reception", 70, 117);
          TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
          TFT_Write_Text("reception", 70, 117);
          
          TFT_Set_Brush(1, CL_BLACK, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE);
          TFT_Rectangle(70,140, 120,150);

          TFT_Set_Font(TFT_defaultFont, CL_YELLOW, FO_HORIZONTAL);
          TFT_Write_Text(Rx_buffer, 70, 137);

          delay_ms(500);

          TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
          TFT_Write_Text("reception", 70, 117);
          TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
          TFT_Write_Text("Pas de reception", 70, 117);
          TFT_Write_Text(Rx_buffer, 70, 137);
          Flag_data_OK = 0;            // on reame notre drapeau
          i = 0;                       // on raz l'index
          RC1IE_bit = 1;              // On autoriser l'INT
       }
  }
} 

Que ce passe-t-il ?

ça fonctionne un peu . disons que parfois j'ai 2 chiffres qui se colle .
par exemple:
dans un état disons chiffre affiché sur mon écran54 .
j’appuie sur mon BP la valeur, la valeur envoyé est donc 55 . Au lieu d'effacer 54 et d'ecrire 55 , cela m'écris 5554 ?
J'ai essayé en limitant le nombre de valeur dans le tableau sans succès ;
Mon code est certainement un peu fouillis , je sais pas si vous allez tout saisir ! . Je suis en face d’expérimentation ,ne m'en tenez pas rigueur ; j'avoue me mélanger grave les pinceaux .

Si vous avez une idée de comment corriger ce problème .

Le but a atteindre , est que le PICFJ, reçoive 8 octets de la part de easypic et les affichent à l'écran sans bug , simulant ainsi la reception de la télémétrie !.
ensuite je passerai au sens inverse envoyé du PICFJ quand on appui sur un bouton à l’écran , vers le easypic

[satinas]

Pour ton problème de port série UART, commence par descendre la vitesse à 9600 bauds, ou même a 1200 bauds, et vois ce que ça donne.

Les 3 ports dont on a parlé UART, I2C, SPI sont des ports série, asynchrone pour l'UART et synchrones pour les 2 autres. Les bits passent sur un seul fil.
Il y a un autre type de port, le port parallèle qui véhicule tous les bits de la data en une fois sur plusieurs fils. C'est ce que tu fais pour le lcd :
En écriture du lcd
- déposer un octet sur le port data
- descendre puis remonter le signal WR
En lecture du lcd
- descendre le signal RD
- lire un octet sur le port data
- remonter le signal RD

PMP pour PARALLEL MASTER PORT, c'est un port parallèle câblé dans le pic, au même titre que les 3 types de port série. Le port PMP gère automatiquement les signaux WR et RD, il suffit de lire ou écrire le port data.
Ca accélère fortement le pilotage du lcd.

[paulfjujo]

bonjour,

j’appuie sur mon BP la valeur, la valeur envoyé est donc 55 . Au lieu d'effacer 54 et d'ecrire 55 , cela m'écris 5554 ?

dans ton traitement d'interruption, il faut mettre le fameux ZER0 = fin de string

Code : Tout sélectionner


      ..
        if ((Registre == 13) || (Registre == 10) || (i>=5)) // 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[i]=0;  // fin de string  
           }
         else
           {
             Rx_buffer[i]= Registre; // On enregistre la lettre à l'emplacement de l'index dans le buffer
             i++;                    // On incremente l'index pour la lettre suivante
            }
     ...
     
     
     et dans le main
     
         TFT_Write_Text(Rx_buffer, 70, 137);
          Flag_data_OK = 0;            // on reame notre drapeau
          i = 0;                       // on raz l'index
          Rx_buffer[0]=0;           // pointe sur une chaine (string) vide
           RC1IE_bit = 1;              // On autoriser l'INT
      
     
     
      }

nota:
sous C18 MPLAB, il faudrait declarer les variables utilisees dans l'interrupt, comme volatile,
ex: volatile int i;
car modifiée dans le "main" ET dans l'interrupt .,
mais il semble que le compilo MikroC peut gerer cela ..
mais ce serait une bonne habitude .. pour la compatibilité entre versions complios ,( portabilité)

nota:
utiliser de preference les variable unsigned int i,j,k comme variable "calfatoute"
pour des boucles, resultat intermediare ... c'est une vieille habitude issue de la programmation en Fortran !
des noms de variables plus explicites permettent de bien les reperer et ne pas les melanger .
ex :Index_Buffer à la place de i

pourquoi "unsigned int " plutot que "int" ou "signed int" ?
parceque les cas d'utilisation de nombre negatif est rare, et que le unsigned int peut aller jusuqu'à 65535 (au lieu de 32767)


sur XC8 .. je ne sais pas... quelqu'un peut confirmer ou infirmer ?

[Jérémy]

Hummmm.....

Je viens de test mais ca ne veut pas fonctionner comme je le souhaite .

[Jérémy]

Bon y'a du mieux mais , c'est pas top .

Quand j’appuie deux fois très vite sur le BP, donc que j'envoie très vite deux infos sur l'UART , le programme de reception indique une erreur de "buffer saturé".
Le deuxième envoi est donc ignoré en reception et m’affiche la valeur du premier seulement ; par contre coté émission , il est prit en compte et il est affiché sur le LCD de la carte easyPIC .
Par exemple j'envoie très vite 54 et 55 . sur l’écran graphique je vois 54 , et sur le LCD de la carte easyPIC je vois 55.

Comment gérer ce probléme ? Dois-je rendre impossible l’écriture si apres avoir recu un "0" ?

Voici le programme de reception :

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;
char Rx_buffer[10] ;
// 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>=10)) // 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);
          TFT_Rectangle(70,115, 175,135);
          TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
          TFT_Write_Text("reception", 70, 117);
          
          TFT_Rectangle(70,140, 120,150);
          TFT_Set_Font(TFT_defaultFont, CL_YELLOW, FO_HORIZONTAL);
          TFT_Write_Text(Rx_buffer, 70, 137);

          delay_ms(100);

          TFT_Rectangle(70,115, 175,135);
          TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
          TFT_Write_Text("Pas de reception", 70, 117);

          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);
            //  _asm reset;
       }
  }
} 

[Jérémy]

En faisant une tempo a l’émission ( pause de 200ms ) après appui sur le BP , aucun problème. Mais bon ce n'est pas le but , et je n'apprends rien en faisant comme cela .
Peut être devrais-je accusé reception, et autoriser un deuxième envoi qu'une fois reçu l'accusé de reception ?
Je trouve quand même bizarre qu'il faille autant de temps pour vider le buffer. Il doit bien y avoir 50ms entre deux appuis sur le BP. Je vais chercher un peu un facon plus élégante que l'AR et surtout moins contraignante car ca m'oblige a ré-envoyer du texte dans l'autre sens pour dire que la voie est libre

[Guest]

Bonjour
oui mais comme tu es sourd a ce que je dis, je te le répété un peu plus fort (deja parle sur le post UART)

CONTRÔLE DE FLUX il existe deux type hard et soft
tient il en parle ici http://iut-tice.ujf-grenoble.fr/tice-es ... _RS232.pdf
et sur le net plein plein

Tu es confronté a un problème qu'il y a pas si longtemps tu disais t'en "foutre" ou "le µC est la pour ca" , problème de gestion du temps, Tu vois on en reparle.et on va encore en reparler, maintenant perso je peux allez voir du coté de ASM, c'est toi qui voit

A+