Comprendre le bitcoin, l'intelligence artificielle, faire un site web... En 3 minutes en vidéo!

Lecteur carte à puce ^

Forum informatique > Aide GNU/Linux > Lecteur carte à puce ^

<<<1>>>

[Page 1 sur 1 - 2 messages]
Informations Messages

F_R_E_D

Avatar de F_R_E_D
3 messages
Neurone isolé
Neurone isolé

Lien direct Le 03 Avril 2007 à 12h26

Re tout le monde Sourire

Je dois programmer en C++ (Fou ) un lecteur carte à puce "LEXUS 80 DEVELLOPEMENT KIT" via une laisson série rs 232 sous LINUX.
Pas de soucis pour l'ouverture et fermeture du port sous linux(struct termios...), m'en suis sortie j'ai créé deux fonctions pour ceux ci et ça marche.
Cependant si vous vous intéressez a la doc du lecteur, il faut pour chaques fonctionnalités du lecteur créer des fonctions.
Ces fonctions je les ais faite mais ça ne marche pas ( pourtant aucun soucis a la compilation ou quoi.... Fou )

le ".h":
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<termios.h>
#include<unistd.h>
#include<string.h>
#include<termios.h>

#define DEVICE "/dev/ttyS0"

class lecteur_cap
{
struct termios oldserialconf,serialconf;
public:


lecteur_cap(tcflag_t ,tcflag_t,tcflag_t,cc_t ,cc_t );
~lecteur_cap();
int ouverture_port();
int fermeture_port(int *);
int checksum(char *,int);
int status_carte(int *);
void beep(int *);
int config_led(int *,unsigned char);
//int attente_carte(int *);
int alimentation_carte(int *,int);
char lecture_cap(int *,char *);
int ecriture_carte(int *, char *);
};


le ".cpp": violent je vous l'accorde...

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<termios.h>
#include<unistd.h>
#include<string.h>
#include "LCAP.h"

#define ALIM_OFF 0
#define ALIM_ON 1
#define DEVICE "/dev/ttyS0"


lecteur_cap::lecteur_cap(tcflag_t vitesse=B9600,tcflag_t parite=~PARENB,tcflag_t controle=~CRTSCTS,cc_t nb_lire=1,cc_t temps=0 )
{
serialconf.c_cflag = vitesse; /* Vitesse du port */
serialconf.c_cflag = parite; /* Pas de bit de parit&#65533;*/
serialconf.c_cflag &= controle; /* Pas de controle du flux */
serialconf.c_cc[VMIN] = nb_lire; /* Caracteres immediatement disponibles */
serialconf.c_cc[VTIME] = temps; /* indique le temps d&#8217;attente avant l&#8217;envoie du prochain caractère*/
}

lecteur_cap::~lecteur_cap()
{

}

int lecteur_cap::ouverture_port()
{
int filedescriptor;

/* Ouverture en lecture/ecriture du port */
filedescriptor=open(DEVICE, O_RDWR | O_NOCTTY);

/* Si &#65533;hec lors de l'ouverture du port */
if(filedescriptor<0)
{
perror(DEVICE);
return -1; /* Renvoie -1 */
}

/* Sauvegarde de la configuration courante */
tcgetattr(filedescriptor,&oldserialconf);
/* On initialise la structure &#65533;z&#65533;o */
bzero(&serialconf, sizeof(serialconf));

/* Configuration du port s&#65533;ie en renseignant la structure de type termios */
/*serialconf.c_cflag = B9600; // Vitesse du port
serialconf.c_cflag = ~PARENB; // Pas de bit de parit&#65533;
serialconf.c_cflag &= ~CRTSCTS; // Pas de controle du flux
serialconf.c_cc[VMIN] = 1; // Caracteres immediatement disponibles
serialconf.c_cc[VTIME] = 0;*/

/* Vide le tampon d'entr&#65533; et de sortie du port s&#65533;ie */
tcflush(filedescriptor,TCIOFLUSH);
/* Activation de la configuration */
tcsetattr(filedescriptor,TCSANOW,&serialconf);

/* Retourne le descripteur de fichier */
return filedescriptor;
}

int lecteur_cap::fermeture_port(int *filedescriptor)
{
int success;

/* Activation de l'ancienne configuration */
tcsetattr((*filedescriptor),TCSANOW,&oldserialconf);
success=close((*filedescriptor));

/* Si &#65533;hec lors de la fermeture du port renvoie -1 */
if(success<0)
{
perror(DEVICE);
return -1;
}

/* Port s&#65533;ie ferm&#65533;avec succ&#65533;, renvoie 0 */
return 0;
}

int lecteur_cap::checksum(char *trame,int longueur_trame)
{
unsigned char chk=0;
int i;

/* Calcul du checksum */
for(i=0;i < longueur_trame;i++) chk += trame[i];

/* On conserve le poids faible(masque) */
chk = chk & 0xFF;

/* Retourne le poids faible du checksum */
return chk;
}

int lecteur_cap::status_carte(int *filedescriptor)
{
char buffer[75];
char trame_status_lecteur[]={'L',4,'S'};
int chk;
int i;

/*calcul du checksum de la trame*/
chk=checksum(trame_status_lecteur,3);
// tcflush((*filedescriptor),TCIOFLUSH);
i=read((*filedescriptor),buffer,75);
/*envoie de la trame*/
i=write((*filedescriptor),trame_status_lecteur,3);
printf("\n&#65533;at write=%d,trame envoye=",i);
for(i=0;i<=2;i++) printf(" %d",trame_status_lecteur[i]);
/*envoie du checksum*/
i=write((*filedescriptor),&chk,1);
printf("\n&#65533;at write=%d,checksum envoye= %d",i,chk);
/*lit le status du lecteur*/
i=read((*filedescriptor),buffer,75);
printf("\n&#65533;at read=%d,trame renvoye=",i,buffer);
for(i=0;i<=5;i++)
{ printf(" %d",buffer[i]); }
putchar('\n');
if(checksum(buffer,5) == buffer[5])
{ printf("Checksum correct\n"); }
else
{
printf("\nChecksum incorrect\n");
return -1;
}
}


void lecteur_cap::beep(int *filedescriptor)
{
char trame_beep[]={'L',6,'B',255,255};
char buffer[75];
char chk;

/* Calcul du checksum de la trame */
chk=checksum(trame_beep,5);

/* Envoie de la trame */
write((*filedescriptor),trame_beep,5);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lit l'&#65533;at du beep du lecteur */
read((*filedescriptor),buffer,75);
}

int lecteur_cap::config_led(int *filedescriptor,unsigned char mode)
{
char buffer[75];
char trame_led[4];
char chk;

trame_led[0]='L';
trame_led[1]=5;
trame_led[2]='V';
trame_led[3]=mode;

/* Calcul du checksum de la trame */
chk=checksum(trame_led,4);

/* Envoie de la trame */
write((*filedescriptor),trame_led,4);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lit l'&#65533;at des LEDs du lecteur */
read((*filedescriptor),buffer,75);

return 0;
}

int lecteur_cap::alimentation_carte(int *filedescriptor,int mode)
{
char buffer[75];
char trame_alim_on[]={'5',4,'O'};
char trame_alim_off[]={'X',4,'F'};
char chk;

/* Alimentation de la carte */
if(mode==ALIM_ON)
{
/* Calcul du checksum de la trame */
chk=checksum(trame_alim_on,3);

/* Envoie de la trame */
write((*filedescriptor),trame_alim_on,3);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lit l'&#65533;at des LEDs du lecteur */
read((*filedescriptor),buffer,75);

return 1;
}
/* Arr&#65533; de l'alimentation de la carte */
else if(mode==ALIM_OFF)
{
/* Calcul du checksum de la trame */
chk=checksum(trame_alim_off,3);

/* Envoie de la trame */
write((*filedescriptor),trame_alim_off,3);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lit l'&#65533;at de l'alimentation */
read((*filedescriptor),buffer,75);

return 0;
}
}

char lecteur_cap::lecture_cap(int *filedescriptor, char *code_client)
{
char buffer[75];
char trame_lecture[]={'5',6,'L',60,4}; /* Ecriture &#65533;l'adresse 60 */
char chk;
int i;

for(i=0;i<=20;i++) buffer[i]=0;

/* Calcul du checksum de la trame */
chk=checksum(trame_lecture,5);

/* Vide le tampon d'entr&#65533; */
tcflush((*filedescriptor),TCIFLUSH);

/* Envoie de la trame */
write((*filedescriptor),trame_lecture,5);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lecture du contenu de la carte */
read((*filedescriptor),buffer,75);

for(i=4;i<=7;i++) code_client[i-4]=buffer[i];

return buffer[1];
}

int lecteur_cap::ecriture_carte(int *filedescriptor, char *code_client)
{
char buffer[75];
char trame[10];
char chk;
int taille=8;
int i;

/* D&#65533;inition de la trame &#65533;envoyer */
trame[0]='5';
trame[1]=9;
trame[2]='E';
trame[3]=60; /* Ecriture &#65533;l'adresse 60 */
for(i=0;i<=3;i++) trame[4+i]=code_client[i];

/* Calcul de la taille de la cha&#65533;e &#65533;envoyer */
//taille = strlen(trame);

/* Calcul du checksum de la trame */
chk=checksum(trame,taille);

/* Envoie de la trame */
write((*filedescriptor),trame,taille);

/* Envoie du checksum */
write((*filedescriptor),&chk,1);

/* Lit le status du lecteur */
read((*filedescriptor),buffer,75);

if(buffer[1]==5)
{ return 0; }
else
{ return -1; }
}
/* mon petit main()*/

int main()
{
int id;
int alim=0;
int status,i;
char tab[6];

lecteur_cap cap;

printf("\nInitialisation port s&#65533;ie ...");
id=cap.ouverture_port();
sleep(2);

printf("\nLed Vert ...");
cap.config_led(&id,64);
sleep(2);

printf("\nTest Lecteur ...\n ");
status=cap.status_carte(&id);
switch(status)
{
case 0:printf("\n->Pas de carte\n");break;
case 1:printf("\n->Carte non aliment&#65533;\n");break;
case 2:printf("\n->Carte aliment&#65533;\n");break;
case 3:printf("\n->Erreur\n");break;
}
sleep(2);
if ((status==1) && (alim==0))
{
printf("\n Alimentation ON");
status=cap.alimentation_carte(&id,ALIM_ON);
sleep(2);

printf("\n Lecture CARTE\n");
status=cap.lecture_cap(&id,tab);
printf("%d octets lu\n",status);

for(i=0;i<4;i++) printf("%d / %c : ",tab[i],tab[i]);
putchar('\n');
alim=1;
}

printf("\n Alimentation OFF\n");
cap.alimentation_carte(&id,ALIM_OFF);

status=cap.fermeture_port(&id);
printf("status close=%d\n",status);
}

Bon je sais bien que c'est pas évident ce que je demande mais tant quelqu'un la déja fait ou a un lecteur du même type chez soit...
Merci d'avance! :-Pensenoir:

 

Publicité

Arcus

Avatar de Arcus
3003 messages
Geek
Geek
Ancien Combattant
Ancien Combattant

Lien direct Le 03 Avril 2007 à 18h42

espérons que quelqu'un de compétent passe par ici Rougis

 

<<<1>>>

[Page 1 sur 1 - 2 messages]

Forum informatique > Aide GNU/Linux > Lecteur carte à puce ^