[C] Lecteur port série windows.h (readFile()) + SDL

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : [C] Lecteur port série windows.h (readFile()) + SDL

fab@c++

Bonjour,

Pour un de mes projets, je réalise un script utilisant la SDL, et lisant des données issues d'un de mes ports série (envoyées par une carte arduino). Or, il semble qu'il est ait un conflit entre la SDL et les fonctions telles que readFile().

Voici mon code sans mon code du main afin qu'il soit moins lourd :

Code :

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#include <SDL/SDL.h>
#define RX_SIZE 500000 /* taille tampon d'entrée */
#define TX_SIZE 500000 /* taille tampon de sortie */
#define MAX_WAIT_READ 2500 /* temps max d'attente pour lecture (en ms) */
HANDLE g_hCOM = NULL;
COMMTIMEOUTS g_cto =
{
MAX_WAIT_READ, /* ReadIntervalTimeOut */
0, /* ReadTotalTimeOutMultiplier */
MAX_WAIT_READ, /* ReadTotalTimeOutConstant */
0, /* WriteTotalTimeOutMultiplier */
0 /* WriteTotalTimeOutConstant */
};
/* Configuration du port COM */
DCB g_dcb =
{
sizeof(DCB), /* DCBlength */
9600, /* BaudRate */
TRUE, /* fBinary */
FALSE, /* fParity */
FALSE, /* fOutxCtsFlow */
FALSE, /* fOutxDsrFlow */
DTR_CONTROL_ENABLE, /* fDtrControl */
FALSE, /* fDsrSensitivity */
FALSE, /* fTXContinueOnXoff */
FALSE, /* fOutX */
FALSE, /* fInX */
FALSE, /* fErrorChar */
FALSE, /* fNull */
RTS_CONTROL_ENABLE, /* fRtsControl */
FALSE, /* fAbortOnError */
0, /* fDummy2 */
0, /* wReserved */
0x100, /* XonLim */
0x100, /* XoffLim */
8, /* ByteSize */
NOPARITY, /* Parity */
ONESTOPBIT, /* StopBits */
0x11, /* XonChar */
0x13, /* XoffChar */
'?', /* ErrorChar */
0x1A, /* EofChar */
0x10 /* EvtChar */
};
BOOL OpenCOM (int nId);
BOOL CloseCOM ();
BOOL ReadCOM (void* buffer, int nBytesToRead, int* pBytesRead);
void pause();
int main(int argc, char *argv[]){
SDL_Init(SDL_INIT_VIDEO); // Initialisation de la SDL
SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
pause(); // Mise en pause du programme
SDL_Quit(); // Arrêt de la SDL
return EXIT_SUCCESS; // Fermeture du programme
}
BOOL OpenCOM(int nId){
/* variables locales */
char szCOM[16];
/* construction du nom du port, tentative d'ouverture */
sprintf(szCOM, "COM%d", nId);
g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
if(g_hCOM == INVALID_HANDLE_VALUE){
printf("Erreur lors de l'ouverture du port COM%d", nId);
return FALSE;
}
/* affectation taille des tampons d'émission et de réception */
SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
/* configuration du port COM */
if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb)){
printf("Erreur lors de la configuration du port COM%d", nId);
CloseHandle(g_hCOM);
return FALSE;
}
/* on vide les tampons d'émission et de réception, mise à 1 DTR */
PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
EscapeCommFunction(g_hCOM, SETDTR);
return TRUE;
}
BOOL CloseCOM(){
/* fermeture du port COM */
CloseHandle(g_hCOM);
return TRUE;
}
BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead){
return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
}
void pause()
{
int continuer = 1;
SDL_Event event;
while (continuer){
SDL_WaitEvent(&event);
switch(event.type){
case SDL_QUIT:
continuer = 0;
}
}
}

Lorsque que je n'utilise pas la SDL, aucun problème, mais quand je l'utilise, il m'empêche d'utiliser cette fonction
Voici mon erreur :

Publicité

xilebo

noone

Bonsoir,

L'erreur est pourtant claire. Le compilateur te dit qu'il ne peut pas convertir int * en DWORD *. Il faut donc que tu changes le prototype de ta fonction ReadCOM en utilisant un DWORD * plutot qu'un int * pour le 3eme paramètre.

fab@c++

Salut,

j'ai trouvé beaucoup mieux que ça. Mon code est en C++. Je le passe en C, et je n'ai plus besoin de convertir

lilight

Bonjour,

Je tente de réaliser un programme en C qui envoi et recoit des données via un port série. Cependant je ne trouve rien qui m'aide vraiment sur internet.
fab@c++ pourrait tu poster ton code afin que je puisse voir un exemple qui fonctionne ?

Merci.

fab@c++

Salut,

Mon code récupère une chaîne qu'il stocke dans un fichier texte. Voici le genre de chaîne que je récupère via le port série :

Code :

111111111111111111111111111111111111111111111111 196 202 179 255 1111111111111111111111111111111111111111111111111111111111111111111111 197 201 181 255 1111111111111111111111111111111111111111111111

Et voici mon code c++ . Attention, il possède une partie SDL. Si t'as des questions, n'hésite pas à poster

Code :

#include <conio.h>
#include <string.h>
#include <windows.h>
#include <SDL/SDL.h>
#define RX_SIZE 16000
#define TX_SIZE 16000
#define MAX_WAIT_READ 1000
HANDLE g_hCOM = NULL;
COMMTIMEOUTS g_cto ={
MAX_WAIT_READ,0,MAX_WAIT_READ,0,0
};
DCB g_dcb ={
sizeof(DCB),9600,TRUE,FALSE,FALSE,FALSE,DTR_CONTROL_ENABLE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,RTS_CONTROL_ENABLE,FALSE,0,0,0x100,0x100,8,NOPARITY,ONESTOPBIT,0x11,0x13,'?',0x1A,0x10
};
BOOL OpenCOM (int nId);
BOOL CloseCOM ();
static BOOL ReadCOM (void* buffer, int nBytesToRead, int* pBytesRead);
int main(int argc, char *argv[]){
//SDL ici
SDL_Surface *ecran = NULL, *rectangle_1 = NULL, *rectangle_2 = NULL, *rectangle_3 = NULL, *rectangle_4 = NULL;
SDL_Rect position_1, position_2, position_3, position_4;
SDL_Init(SDL_INIT_VIDEO);
ecran = SDL_SetVideoMode(480,480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
rectangle_1 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
rectangle_2 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
rectangle_3 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
rectangle_4 = SDL_CreateRGBSurface(SDL_HWSURFACE, 240,240, 32, 0, 0, 0, 0);
position_1.x = 0; position_1.y = 240;
position_2.x = 240; position_2.y = 240;
position_3.x = 0; position_3.y = 0;
position_4.x = 240; position_4.y = 0;
SDL_WM_SetCaption("electronic eye", NULL);
//fin SDL
static const unsigned short int nId=4; //relatif à l'affichage
static unsigned char buffer[200]; //le buffer qui contient la chaîne récupérée via le port série
static int nBytesRead;
static unsigned short int i=0;
static unsigned short int sensor[10] = {0};
static unsigned char sensor_1[1];
static unsigned char sensor_3[]="1111111111 ";
FILE *fichier = NULL;
if(!OpenCOM(nId)) return -1;
while(1) { //boucle de la SDL
if(ReadCOM(buffer, sizeof(buffer)-2, &nBytesRead)){ //ON lit le port série
buffer[nBytesRead] = '\0';
fichier = fopen("test.txt", "w+" ); //on enregistre dans le fichier
fputs(buffer, fichier);
fclose(fichier);
fichier = fopen("test.txt", "r+" );
if (fichier != NULL){ // on récupère et on affiche
fscanf(fichier, "%s %d %d %d %d", &sensor_1[0], &sensor[0], &sensor[1], &sensor[2], &sensor[3]);
fclose(fichier);
if(sensor[0]>255 || sensor[0]<0 || sensor[0]==111) sensor[0]=((sensor[1]+sensor[2]+sensor[3])/3);
if(sensor[1]>255 || sensor[1]<0 || sensor[1]==111) sensor[1]=((sensor[0]+sensor[2]+sensor[3])/3);
if(sensor[2]>255 || sensor[2]<0 || sensor[2]==111) sensor[2]=((sensor[1]+sensor[0]+sensor[3])/3);
if(sensor[3]>255 || sensor[3]<0 || sensor[3]==111) sensor[3]=((sensor[1]+sensor[2]+sensor[0])/3);
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, sensor[0],sensor[0],sensor[0]));
SDL_FillRect(rectangle_1, NULL, SDL_MapRGB(ecran->format, sensor[0],sensor[0],sensor[0]));
SDL_BlitSurface(rectangle_1, NULL, ecran, &position_1);
SDL_FillRect(rectangle_2, NULL, SDL_MapRGB(ecran->format, sensor[1],sensor[1],sensor[1]));
SDL_BlitSurface(rectangle_2, NULL, ecran, &position_2);
SDL_FillRect(rectangle_3, NULL, SDL_MapRGB(ecran->format, sensor[2],sensor[2],sensor[2]));
SDL_BlitSurface(rectangle_3, NULL, ecran, &position_3);
SDL_FillRect(rectangle_4, NULL, SDL_MapRGB(ecran->format, sensor[3],sensor[3],sensor[3]));
SDL_BlitSurface(rectangle_4, NULL, ecran, &position_4);
SDL_Flip(ecran);
}
}
i++;
}
CloseCOM();
SDL_Quit();
return 0;
}
BOOL OpenCOM(int nId){
char szCOM[16];
sprintf(szCOM, "COM%d", nId);
g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
if(g_hCOM == INVALID_HANDLE_VALUE){
printf("Erreur lors de l'ouverture du port COM%d", nId);
return FALSE;
}
SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb)){
printf("Erreur lors de la configuration du port COM%d", nId);
CloseHandle(g_hCOM);
return FALSE;
}
PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
EscapeCommFunction(g_hCOM, SETDTR);
return TRUE;
}
BOOL CloseCOM(){
CloseHandle(g_hCOM);
return TRUE;
}
static BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead){
return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
}

lilight

Merci pour ton code, je suis débutante en C et n'y connais pas grand chose, c'est donc un peu compliquer pour moi...

Je suis en stage et je cherche à communiquer via les ports séries de windows avec un calibrateur et un multimètre, je voudrais donc pouvoir à la fois lire et écrire sur les ports. Je dois envoyer des commandes du type "MEAS?" pour que l'appareil me revoie la valeur mesurée.
En attendant de trouver une solution pour utiliser les port séries directement en c j'utilise l'hyperterminal que j'ouvre avec mon programme et ou j'écris virtuellement des commandes, mais cette solution me semble un peu lourde puisqu'elle nécessite l'ouverture de plusieurs fenêtres.
Pourrait tu m'expliquer à quoi sert la SDL.
Si je comprend bien il me suffit de retirer tout ce qui concerne la SDL pour pouvoir utiliser les ports séries ?

Merci d'avance pour votre aide.

fab@c++

Mon programme avait pour but d'afficher un écran à partir de données récupérées par des capteurs d'une carte arduino. La SDL sert juste à l'affichage. On peut donc enlever toutes les partie relatives à l'affichage en SDL pour pouvoir exécuter ce programme en mode console.
Pour ma part, j'ai beaucoup cherché pour la lecture sur le port, mais je ne sais pas trop comment écrire. je pense, ce code utilisant la lib windows.h, qu'il suffit de s'intéresser à cette lib pour s'avoir comment écrire sur un port série.

Voilà

lilight

Merci de ta réponse je vais essayer et ca, et te tiens au courant du résultat ;-)

lilight

J'ai fait des tests du coup mais je rencontre un problème.
J'ai ajouter la partie écriture que j'ai trouvé sur le net faite sur le même modèle que ta partie lecture, mais quand j'envoi des données au calibrateur et il ne semble pas les recevoir, de même pour la lecture, il ne renvoi rien. J'ai vérifier les paramètres baudrate, databits, stopbit qui sont bon mais je ne sais pas a quoi correspondent les autres.
Quel compilateur utilisais tu ? Peut tu me dire à quoi sert le "static" tout a la fin pour la lecture du port ?

FORUM HardWare.fr

Programmation

[C] Lecteur port série windows.h (readFile()) + SDL

Sujets relatifs
Procédure d'installation sur windows	[Divers / Windows] Comment cacher la fenêtre de console ?
[C#] savoir si un processus est en train de réfléchir, possible ?	Fonction en language C
[Divers / Ada ] Utiliser un bibliothèque partagé (inpout32.ddl)	[Divers/Ada] Ecrire pour un afficheur LCD sur Gnu/Linux et Windows
[Ada/Asm] Accéder au port parallèle avec Ada sur Gnu/Linux (résolu)	[C] Puissance 4 arbres de possibilité
[C][Gnu] info utilisation memoire, processeur et swap [résolu]	[Windows/PostgreSQL) Importer base sur un autre ordinateur ?
Plus de sujets relatifs à : [C] Lecteur port série windows.h (readFile()) + SDL

Page générée en 0.099 secondes