Forum TI-Planet.org

Donc j'ai ecrit ce code pour faire un chat avec le port serie de la calculette:

Code: Tout sélectionner

#include <os.h>
//#include <nspireio/nspireio.h>
#include <nspireio/uart.hpp>
#include <nspireio/console.hpp>

int key_already_pressed = 0;
int is_uart_data = 0;
char oldinput[100] = {0};
char voidlist[100] = {0};

int main(void)
{
   assert_ndless_rev(874);
   //clrscr();
   nio_console csl;
   nio_init(&csl,NIO_MAX_COLS,NIO_MAX_ROWS,0,0,NIO_COLOR_WHITE,NIO_COLOR_BLACK,TRUE);
   nio_set_default(&csl);
   nio_color(&csl,NIO_COLOR_BLACK,NIO_COLOR_WHITE);
   nio_printf("Nspire UART Chat by Samy. Compiled the %s At %s\n",__DATE__,__TIME__);
   nio_color(&csl,NIO_COLOR_WHITE,NIO_COLOR_BLACK);
   nio_puts("Press any ESC to exit and CTRL to send msg...\n");
   while(!isKeyPressed(KEY_NSPIRE_ESC)){
      if(isKeyPressed(KEY_NSPIRE_CTRL) && !key_already_pressed){
         nio_printf(">");
         char input[100] = {0};
         nio_getsn(input,100);
         uart_printf(input);
         key_already_pressed = 1;
      }
      if(!any_key_pressed())
         key_already_pressed = 0;
      if(uart_ready()) {
         is_uart_data = 1;
      }
      if(uart_ready()) {
         char input[100] = {0};
         uart_getsn(input,100);
         if(strcmp(oldinput,input) != 0) {
            if(input != voidlist) {
               nio_puts(input);
               strcpy(oldinput,input);
               strcpy(input,voidlist);
            }
         }
      }
   }
   nio_puts("Tests finished.");
   nio_free(&csl);   
   return 0;
}



Le seul petit problème c'est que le code envoie des caratere a l'infinit sur le port serie(par exemple si j'envoie LLLLLLLLLLLLLLLLLLLLLLLL Le port serie et l'afichage vas continuellement envoyer des L et pareil avec d'autre lettre)
Sinon si je peut envoyer et recevoir normalement a part que la console serie et l'ecrant de la Ti sont flood par cette lettre.

Est-ce quelqu'un peut me corriger cela sa fait un bon moment que je cherche .
Merci d'avance

Je dirais que c'est a cause de la partie de la ligne 35 a la ligne 45:

Code: Tout sélectionner

      if(uart_ready()) {
         char input[100] = {0};
         uart_getsn(input,100);
         if(strcmp(oldinput,input) != 0) {
            if(input != voidlist) {
               nio_puts(input);
               strcpy(oldinput,input);
               strcpy(input,voidlist);
            }
         }
      }

En fait, tu verifies juste que uart_ready() renvoie une valeur non nul. Or, il renverra une valeur non nul en permanence s'il n'y a pas de probleme.

Il faudrait que tu rajoutes un test:tu affiches seulement si tu n'as pas encore affiche.

Donc tu creer une variable au debut, comme int dispInput = 0;

Et ensuite, dans le if de la ligne 35:

Code: Tout sélectionner

if(uart_ready() && !dispInput)
         char input[100] = {0};
         uart_getsn(input,100);
         if(strcmp(oldinput,input) != 0) {
            if(input != voidlist) {
               nio_puts(input);
               strcpy(oldinput,input);
               strcpy(input,voidlist);
            }
         }
         dispInput = 1;
      }

Je ne sais pas si ca peut etre ca, je ne suis pas le mieux place en C pour Nspire.

J'espere avoir ete clair, et que je n'ai pas dit de betise.

Salut.


Je ne sais pas si c'est le même problème, mais ça y ressemble énormément lorsque je tente d'échanger des messages entre 2 TI-Nspire :
viewtopic.php?f=43&t=20578&p=222832#p222772

A partir du moment où il y a eu au moins 1 échange de données, la fonction uart_ready() renvoie alors toujours vrai et donc la calculatrice réceptrice continue de lire sans fin le dernier caractère émis.

J'ai regardé dans https://github.com/compujuckel/nspire-i ... ire-uart.c , histoire de voir si j'avais raté quelque chose et si il y avait par exemple une fonction pour vider le buffer à appeler une fois lu, mais non apparemment il n'y a rien d'autre...

Après avoir essayer la réponse de " Ti64CLi++" je reçois seulement un message de 100 lettre (taille du buffer) et je ne recois plus rien d'autre.
De plus le message est envoyer sur la console ET sur la calculette ce qui ne deverrait jamais arriver

Oui, je n'avais pas compris en quoi ça résolvait le problème.

Dans mon code que je t'ai lié, j'ignore les caractères successifs identiques, faute de mieux pour le moment.

Mais j'ai la désagréable impression que uart_ready() ne se comporte pas correctement.

Je suis desole pour ma method, je pensais que ca pouvait marcher.
Apparement, j'ai dit des betises

Pour information (même si ça ne change pas le comportement uart, je crois), le bon repo est celui-ci: https://github.com/Vogtinator/nspire-io
Celui de compujuckel n'a plus été updaté depuis 2014.

Et sinon, tu comprends le problème du uart_getc() qui continue à retourner en boucle le dernier caractère reçu ? (ce qui implique vu le code que tu as lié que la fonction uart_ready() utilisée en interne continuer à renvoyer vrai après la fin de la transmission)
Voir mon post avec le code : viewtopic.php?f=43&t=20578&p=222832#p222772
Car je suis complètement coincé pour le moment.

Une histoire d'interruptions à activer/désactiver peut-être ?

Prenons l'exemple d'un programme de chat, même si ce n'est pas mon cas, où chaque utilisateur envoie des messages d'1 caractère.
Je lis que selon son code, uart_getchar() fait une sorte d'accusé réception en retournant le caractère lu avec uart_putchar() :
https://github.com/Vogtinator/nspire-io ... ire-uart.c

Je ne comprends pas comment cela peut marcher.
Si la calculatrice qui a émis le message se met ensuite à utiliser uart_getchar() pour lire une éventuelle réponse, elle va récupérer non pas la réponse tapée par l'utilisateur d'en face mais l'accusé réception qu'elle va à son tour renvoyer... d'où boucle infinie.

Perso je sais pas, mais selon Vogtinator (puisqu'il est le mainteneur de nspire-io maintenant), "getchar actually sends the received char back", et " "if(*inptr!=oldc) {" makes no sense ".
C'est peut-être un peu utile déjà, mais bon, il est sur IRC si t'as des détails à lui demander

Pareil pour @TurtleForGaming

Edit: je suppose que tu viens de te rendre compte du premier point, oui. Pourquoi ça fait ça, par contre... bonne question ?