identification par carte a bande magnetique + langage C

[DADYCOKE]

Bonjour les amis,
voila j'ai une carte a bande magnetique qui envoi 10 chiffre par stdin (emulation de clavier) lorsqu'on la passe sur le lecteur.
Pour etre plus clair si j'ouvre un fichier.txt et que je connecte le lecteur de carte a mon pc via usb, quand je passe une carte alors le code de la carte apparait sur le fichier comme si je l'avai saisi par le clavier.
Mon but est d'ecrire un petit code en C qui va declenché un programme des qu'il recoit le code.
Je suis allé voir du coté des mecanismes des entrées sorties en C ainsi que les tampons d'entrée sortie. Mais j'arrive pas a contourné la saisie de la touche Entree . j'essai d'utiliser

fgets(buff,sizeof(buff),stdin)

merci de votre aide
-----

[DADYCOKE]

j'ai fait un truc qui marche mais je ne sais pa si c'est bien de faire ou on peut le faire autrement .
Voila comme je suis sous linux je passe le terminal en mode brut ( raw ) et j utilise fgets

  int main()
{
  printf("identif\n");
  char buff[9];
  mode_raw(1);
  fgets(buff,sizeof(buff),stdin);
  mode_raw(0);
  printf("%s\n",buff);
  return 0;
}

void mode_raw(int activer)
{
    static struct termios cooked;
    static int raw_actif = 0;
 
    if (raw_actif == activer)
        return;
 
    if (activer)
    {
        struct termios raw;
 
        tcgetattr(STDIN_FILENO, &cooked);
 
        raw = cooked;
        cfmakeraw(&raw);
        tcsetattr(STDIN_FILENO, TCSANOW, &raw);
    }
    else
        tcsetattr(STDIN_FILENO, TCSANOW, &cooked);
 
    raw_actif = activer;
}

[balhrog]

bonjour à toi,

pourquoi n'essayes tu pas avec getchar(), cela me semblerais plus simple et plus sur à mettre en oeuvre.

[DADYCOKE]

getchar() va attendre egalement la touche Entree

[A voir en vidéo sur Futura]

[Jack]

stdin étant un flux d'entrée, je feris ceci:

#define BUFFSIZE 20
unsigned char buf[BUFFSIZE];
int nbCar;

nbCar = fread(buf, sizeof(unsigned char), BUFFSIZE, stdin);

Ainsi tu auras recueilli tes données dans le buffer et nbCar indiquera combien ont été lus.

A+

[DADYCOKE]

j'ai essayé ta methode Jack mais la aussi le programme attend que l'on valide avec la touche Entree.

#include <stdio.h>
#include <stdlib.h>

#define BUFFSIZE 10

unsigned char buf[BUFFSIZE];

int main()
{
  buf[9] = '\0';
  int nbCar = 0;
  while(nbCar == 0)
    nbCar = fread(buf, sizeof(unsigned char), BUFFSIZE, stdin);
  printf("%d\n",nbCar);
  return 0;
}

[kwariz]

Bonjour,

je ne pense pas que mélanger un accès bufferisé (via le stream stdin) et un mode non canonique soit une bonne idée. Il serait préférable d'utiliser le descripteur de fichier associé à stdin et des appels à read pour lire caractères par caractères. Un peu comme dans l'exemple donné dans la doc de la glibc.

[DADYCOKE]

d accord, je vais voir ca, Merci a tous

[Jack]

j'ai essayé ta methode Jack mais la aussi le programme attend que l'on valide avec la touche Entree.

Je ne vois pas pourquoi fread() attendrait un RETURN. fread lit dans stdin et ramasse tout ce qui s'y trouve.
Tu as dû de tromper quelque part.

A+

[Jack]

Essaie ce code sur un PC et tu verras bien que les caractères entrés au clavier s'affichent au fur et à mesure:

int main (void){
	char buf[10];
	int nbCar;
	for(;;) {
		nbCar = fread(buf, sizeof(char), 10, stdin);
		if (nbCar)
			for (int i=0; i<nbCar; i++)
				printf("%c", buf[i]);
	}
	return 0;
}

[DADYCOKE]

je viens de l'essayer mais comme je vous le disais je dois valider ma saisie avec la touche Entree ( return) pour que le printf affiche le contenu du buffer.

on parle bien du printf

for (int i=0; i<nbCar; i++)
printf("%c", buf[i]);

[kwariz]

Essaie ce code sur un PC et tu verras bien que les caractères entrés au clavier s'affichent au fur et à mesure:

int main (void){
    char buf[10];
    int nbCar;
    for(;;) {
        nbCar = fread(buf, sizeof(char), 10, stdin);
        if (nbCar)
            for (int i=0; i<nbCar; i++)
                printf("%c", buf[i]);
    }
    return 0;
}

Tant que c'est bufferisé tu vas avoir du mal ... les caractères sont affichés car le terminal est en mode echo mais il ne sont pas traités à la volée :

#include <stdio.h>

int main (void){
  char buf[10];
  int nbCar;
  for(;;) {
    nbCar = fread(buf, sizeof(char), 10, stdin);
    if (nbCar)
      for (int i=0; i<nbCar; i++)
    printf("%c(%d)", buf[i], buf[i]);
  }
  return 0;
}

fread n'aura accès au buffer de stdin que lorsqu'il sera plein ou si il est flushé par un retour chariot.

La seule solution est de passer le terminal en mode non canonique et d'utiliser des read sur le descripteur de fichier de stdin.

[kwariz]

Pour donner un exemple ce petit programme largement pompé de l'exemple dont j'ai donné le lien :
Il affiche (sans vérifier un débordement ...) le caractère suivant le caractère entré sans bufferisation

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
     
/* Use this variable to remember original terminal attributes. */
     
struct termios saved_attributes;
     
void
reset_input_mode (void)
{
  tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
}
     
void
set_input_mode (void)
{
  struct termios tattr;
  char *name;
     
  /* Make sure stdin is a terminal. */
  if (!isatty (STDIN_FILENO))
    {
      fprintf (stderr, "Not a terminal.\n");
      exit (EXIT_FAILURE);
    }
     
  /* Save the terminal attributes so we can restore them later. */
  tcgetattr (STDIN_FILENO, &saved_attributes);
  atexit (reset_input_mode);
     
  /* Set the funny terminal modes. */
  tcgetattr (STDIN_FILENO, &tattr);
  tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
  tattr.c_cc[VMIN] = 1;
  tattr.c_cc[VTIME] = 0;
  tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
}
     
int
main (void)
{
  char c;
     
  set_input_mode ();
     
  while (1)
    {
      read (STDIN_FILENO, &c, 1);
      if (c == '\004')          /* C-d */
    break;
      else {
    c++;
    write (STDOUT_FILENO, &c, 1);
      }
    }
     
  return EXIT_SUCCESS;
}

[Jack]

les caractères sont affichés car le terminal est en mode echo mais il ne sont pas traités à la volée :

Hé oui, je me suis laissé abuser par l'affichage.

[Chanur]

Bonjour,
A ma connaissance, il existe 2 solutions pour saisir des données sur l'entrée standard sans être bloqué par l'attente du retour chariot :
- Sous Windows, utiliser les fonctions déclarées dans conio.h : getch, cscanf, etc.
- Sous linux, la manipulation des propriétés de l'entrée stantard, comme par exemple cette implémentation de getch() :

#include <termios.h>
#include <unistd.h>
int getch (void)
{
    struct termios initial_settings,new_settings;
    int ch;
    tcgetattr(0,&initial_settings);
    new_settings=initial_settings;
    new_settings.c_lflag&=~ICANON;
    new_settings.c_lflag&=~ECHO;
    new_settings.c_lflag&=~ISIG;
    new_settings.c_oflag&=~NL0;
    new_settings.c_oflag&=~CR0;
    new_settings.c_oflag&=~TAB0;
    new_settings.c_oflag&=~BS0;
    new_settings.c_cc[VMIN]=1;
    new_settings.c_cc[VTIME]=0;
    cfsetospeed(&new_settings,B230400);
    cfsetispeed(&new_settings,0);
    tcsetattr(0,TCSANOW,&new_settings);
    read(0,&ch,1);
    tcsetattr(0,TCSANOW,&initial_settings);
    return ch;
}