Accueil > Forum > > > > besoin d'aide sur communication
 besoin d'aide sur communication
jeudi 11 février 2010 à 10:19:07 |
besoin d'aide sur communication
keast
|
salut tout le monde,
Voila je suis vraiment nul en info et j'ai un problème en ce moment sur un projet.
Je dois piloté un appareil qui celui-ci fonctionne avec des commande ASCII que l'on envoi en RS232.
Je sais que ce sujet a été traité x fois sur ce site mais j'ai besoin d'aide car je ne comprend rien. En effet j'ai téléchargé 2 codes source en C (le seul langage que je connais) et un en C++ qui envoie et récoit une trame ASCII et comme par hasard le seul qui m'envoi les trames correctement c'est celui en C++ (l'appareil répond aux commande).
J'aimerai juste pouvoir utiliser des fonctions qui envoient et recoient des trames en ASCII.
Voici les deux codes sources en C. celui en C++ est un projet complet voici le lien:
projet C++ comm RS232
Je vous remercie de votre aide!
Code C/C++ : /******************************************************************************
TestCOM.c :
fonctions de base pour l'envoi et la réception de donner sur un port
série RS232.
******************************************************************************/
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
/*=============================================================================
Définition de constantes
=============================================================================*/
#define RX_SIZE 4096 /* taille tampon d'entrée */
#define TX_SIZE 4096 /* taille tampon de sortie */
#define MAX_WAIT_READ 5000 /* temps max d'attente pour lecture (en ms) */
/*=============================================================================
Variables globales.
=============================================================================*/
/* Handle du port COM ouvert */
HANDLE g_hCOM = NULL;
/* Délais d'attente sur le port COM */
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 */
57600, /* 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 */
};
/*=============================================================================
Fonctions du module.
=============================================================================*/
BOOL OpenCOM (int nId);
BOOL CloseCOM ();
BOOL ReadCOM (void* buffer, int nBytesToRead, int* pBytesRead);
BOOL WriteCOM (void* buffer, int nBytesToWrite, int* pBytesWritten);
/******************************************************************************
main : point d'entrée du programme.
******************************************************************************/
int main()
{
/* variables locales */
char buffer[256];
int nId, nChoice, nBytesWritten, nBytesRead;
/* demande du numéro du port COM */
printf("Entrez le numero du port COM : ");
scanf("%d", &nId);
/* tentative d'ouverture */
printf("Ouverture et configuration du port COM%d...\r\n", nId);
if(!OpenCOM(nId)) return -1;
printf("...OK\r\n");
/* boucle tant que l'on ne quitte pas */
do
{
/* menu */
printf("\r\n");
printf("1 : Envoyer des donnees.\r\n");
printf("2 : Recevoir des donnees.\r\n");
printf("3 : Quitter.\r\n");
printf("Choix : ");
scanf("%d", &nChoice);
/* enoyer des données */
if(nChoice == 1)
{
printf("\r\n");
printf("Donnees a envoyer :\r\n");
fflush(stdin);
gets(buffer);
printf("\r\n");
printf("Envoi des donnees...\r\n");
if(WriteCOM(buffer, strlen(buffer), &nBytesWritten))
printf("%d octet(s) envoye(s).\r\n", nBytesWritten);
else
printf("Erreur lors de l'envoi.\r\n");
}
/* recevoir des données */
if(nChoice == 2)
{
printf("\r\n");
printf("Reception de donnees...\r\n");
if(ReadCOM(buffer, sizeof(buffer)-1, &nBytesRead))
{
buffer[nBytesRead] = '\0';
printf("%d octet(s) recu(s) :\r\n%s\r\n", nBytesRead, buffer);
}
else
printf("Erreur lors de la réception.\r\n");
}
}while(nChoice != 3);
/* fermeture du port COM et retour */
CloseCOM();
return 0;
}
/******************************************************************************
OpenCOM : ouverture et configuration du port COM.
entrée : nId : Id du port COM à ouvrir.
retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
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;
}
/******************************************************************************
CloseCOM : fermeture du port COM.
retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL CloseCOM()
{
/* fermeture du port COM */
CloseHandle(g_hCOM);
return TRUE;
}
/******************************************************************************
ReadCOM : lecture de données sur le port COM.
entrée : buffer : buffer où mettre les données lues.
nBytesToRead : nombre max d'octets à lire.
pBytesRead : variable qui va recevoir le nombre d'octets lus.
retour : vrai si l'opération a réussi, faux sinon.
-------------------------------------------------------------------------------
Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
COMMTIMEOUTS permet de limiter le temps d'attente si aucun
caractères n'est présent dans le tampon d'entrée.
- la fonction peut donc retourner vrai sans avoir lu de données.
******************************************************************************/
BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead)
{
return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
}
/******************************************************************************
WriteCOM : envoi de données sur le port COM.
entrée : buffer : buffer avec les données à envoyer.
nBytesToWrite : nombre d'octets à envoyer.
pBytesWritten : variable qui va recevoir le nombre d'octets
envoyés.
retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL WriteCOM(void* buffer, int nBytesToWrite, int* pBytesWritten)
{
/* écriture sur le port */
return WriteFile(g_hCOM, buffer, nBytesToWrite, pBytesWritten, NULL);
}
Code C/C++ : // FICHIERS D'INCLUSION
//------------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
// CONSTANTES
//-------------------------------------------------------------------------------
// Codes de retour génériques
#define TRUE 1
#define FALSE 0
// PROTOTYPES
//----------------------------------------------------------------------------
int OuvrirCom(char *NomPort,int Vitesse,int Taille,char *Parite,int StopBits);
int EnvoyerCom (char*Chaine);
int RecevoirCom(char *Chaine,int nCountMax,int *pCountRead);
int MenuPort (char*) ;
int MenuVitesse (int*) ;
int MenuTaille (int*) ;
int MenuParite (char*) ;
int MenuStopBits (int*) ;
int MenuRecevoirEnvoyer () ;
int FermerCom();
// VARIABLES GLOBALES
//-----------------------------------------------------------------------------
DCB g_DCB; // structure dcb du port
HANDLE g_hCom = 0; // handle de la com
int main ()
{
int Sortie1 ;
int SortieVitesse ;
int SortieTaille ;
int SortieParite ;
int SortieStopBits ;
/* Valeur retour menu */
int ValeurMenuPort = 0;
int ValeurMenuVitesse = 0 ;
int ValeurMenuTaille = 0;
int ValeurMenuParite = 0;
int ValeurMenuStopBits = 0;
int ValeurMenuRecevoirEnvoyer = TRUE ;
/* Reels valeurs */
char ValeurPort[10] ;
int ValeurVitesse = 0;
int ValeurTaille = 0 ;
char ValeurParite[10] ;
int ValeurStopBits = 0;
/* Supplement */
//int LongueurPort = 0 ;
while (Sortie1)
{
/*** Initialisation des valeurs de sortie ***/
Sortie1 = TRUE ;
SortieVitesse = TRUE ;
SortieTaille = TRUE ;
SortieParite = TRUE ;
SortieStopBits = TRUE ;
/*** Configuration Port ***/
ValeurMenuPort = MenuPort (ValeurPort) ;
if (ValeurMenuPort == 0)
Sortie1 = FALSE ;
else if (ValeurMenuPort == 3 )
{
sleep(1000) ;
/*** Ouverture COM1 deja parametre ***/
if ( OuvrirCom("COM1", 57600, 8, "Aucune", 1 ) )
{
printf("\n Ouverture du port effectuee.\n") ;
ValeurMenuRecevoirEnvoyer = MenuRecevoirEnvoyer () ;
if (ValeurMenuRecevoirEnvoyer == 0 )
Sortie1 = FALSE ;
else if ( (ValeurMenuRecevoirEnvoyer == 3) || (ValeurMenuRecevoirEnvoyer == 4))
break ;
}
else
printf("\n Erreur ouverture port.\n") ;
}
else if (ValeurMenuPort == 4 )
{
sleep(1000) ;
/*** Ouverture COM2 deja parametre ***/
if ( OuvrirCom("COM2", 9600, 8, "Aucune", 1 ) )
{
printf("\n Ouverture du port effectuee.\n") ;
ValeurMenuRecevoirEnvoyer = MenuRecevoirEnvoyer () ;
if (ValeurMenuRecevoirEnvoyer == 0 )
Sortie1 = FALSE ;
else if ( (ValeurMenuRecevoirEnvoyer == 3) || (ValeurMenuRecevoirEnvoyer == 4))
break ;
}
else
printf("\n Erreur ouverture port.\n") ;
}
else
{
while (SortieVitesse)
{
SortieTaille = TRUE ;
/*** Configuration Vitesse ***/
ValeurMenuVitesse = MenuVitesse (&ValeurVitesse) ;
if (ValeurMenuVitesse == 5)
SortieVitesse = FALSE ;
else if (ValeurMenuVitesse == 0)
{
Sortie1 = FALSE ;
SortieVitesse = FALSE ;
}
else
{
while (SortieTaille)
{
SortieParite = TRUE ;
/*** Configuration Taille ***/
ValeurMenuTaille = MenuTaille (&ValeurTaille) ;
if (ValeurMenuTaille == 5)
SortieTaille = FALSE ;
else if(ValeurMenuTaille == 0)
{
Sortie1 = FALSE ;
SortieVitesse = FALSE ;
SortieTaille = FALSE ;
}
else
{
while (SortieParite)
{
SortieStopBits = TRUE ;
/*** Configuration Parite ***/
ValeurMenuParite = MenuParite (ValeurParite) ;
if (ValeurMenuParite == 4)
SortieParite = FALSE ;
else if (ValeurMenuParite == 0)
{
Sortie1 = FALSE ;
SortieVitesse = FALSE ;
SortieTaille = FALSE ;
SortieParite = FALSE ;
}
else
{
while (SortieStopBits)
{
/*** Configuration Stop Bits ***/
ValeurMenuStopBits = MenuStopBits (&ValeurStopBits) ;
if (ValeurMenuStopBits == 3)
SortieStopBits = FALSE ;
else if (ValeurMenuStopBits == 0)
{
Sortie1 = FALSE ;
SortieVitesse = FALSE ;
SortieTaille = FALSE ;
SortieParite = FALSE ;
SortieStopBits = FALSE ;
}
else
{
SortieVitesse = FALSE ;
SortieTaille = FALSE ;
SortieParite = FALSE ;
SortieStopBits = FALSE ;
/*** Recapitulatif ***/
printf("\nRecapitulatif de la configuration de la liaison serie RS-232.\n") ;
printf("\n Port : %s \n", ValeurPort) ;
printf(" Vitesse : %d bits/s \n", ValeurVitesse) ;
printf(" Taille : %d bits\n", ValeurTaille);
printf(" Parite : %s \n", ValeurParite) ;
printf(" Stop bits : %d bit(s) stop\n", ValeurStopBits) ;
sleep (1000) ;
if ( OuvrirCom(ValeurPort, ValeurVitesse,ValeurTaille, ValeurParite, ValeurStopBits) )
{
printf("\n Ouverture du port effectuee.\n") ;
ValeurMenuRecevoirEnvoyer = MenuRecevoirEnvoyer () ;
if (ValeurMenuRecevoirEnvoyer == 0 )
Sortie1 = FALSE ;
else if ( (ValeurMenuRecevoirEnvoyer == 3) || (ValeurMenuRecevoirEnvoyer == 4))
{
SortieVitesse = FALSE ;
SortieTaille = FALSE ;
SortieParite = FALSE ;
SortieStopBits = FALSE ;
}
}
else
printf("\n Erreur ouverture port.\n") ;
}
}
}
}
}
}
}
}
}
}
system("PAUSE");
return EXIT_SUCCESS;
}
//------------------------------------------------------------------------------
// FONCTION : OuvrirCom
//------------------------------------------------------------------------------
int OuvrirCom(char *NomPort,int Vitesse,int Taille,char* Parite,int StopBits)
{
// On ouvre le port série
g_hCom = CreateFile( NomPort, GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING,NULL);
if(g_hCom == INVALID_HANDLE_VALUE)
{
return FALSE ;
}
else
{
// on vide les tampons d'émission et de réception, mise à 1 DTR
PurgeComm( g_hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
// On paramètre le port série
g_DCB.DCBlength = sizeof(DCB);
//Configuration actuelle
GetCommState(g_hCom, &g_DCB);
//Modification du DCB
g_DCB.BaudRate = Vitesse ;
g_DCB.ByteSize = Taille;
g_DCB.fDtrControl = DTR_CONTROL_ENABLE; // (DISABLE)
// Gestion de la parité parmi paire, impaire et aucune
if (strcmp(Parite,"Aucune")==0)
g_DCB.Parity = NOPARITY;
if (strcmp(Parite,"Paire")==0)
g_DCB.Parity = EVENPARITY;
if (strcmp(Parite,"Impaire")==0)
g_DCB.Parity = ODDPARITY;
// Gestion du Stop Bit
if ( StopBits == 1 )
g_DCB.StopBits = ONESTOPBIT;
//if ( StopBits == 1.5 )
//dcb.StopBits = ONE5STOPBITS;
if ( StopBits == 2 )
g_DCB.StopBits = TWOSTOPBITS;
//Configuration de la liaison serie
SetCommState(g_hCom, &g_DCB);
return TRUE ;
}
}
//----------------------------------------------------------------------------
// FONCTION : EnvoyerCom
//----------------------------------------------------------------------------
int EnvoyerCom(char* Chaine)
{
DWORD NumBytes=0;
int TailleChaine = strlen(Chaine) ;
printf("\n Taille de la chaine : %d \n", TailleChaine) ;
if(g_hCom != NULL)
{
//Emission de la Chaine
if (WriteFile(g_hCom,Chaine, TailleChaine,&NumBytes,NULL)==0)
{
printf ("\n Erreur emission.\n") ;
return FALSE ;
}
else
{
printf("\n Chaine envoyee : %s.\n", Chaine) ;
return TRUE ;
}
}
else
return FALSE ;
}
//---------------------------------------------------------------------------
// FONCTION : RecevoirCom
//---------------------------------------------------------------------------
int RecevoirCom(char *Chaine,int nCountMax, int* pCountRead)
{
COMSTAT Stat;
DWORD Errors;
int nbCarALire;
long NCarLus=0;
int b_Retour ;
if(g_hCom!=NULL)
{
FILE* FFichier ;
if ( (FFichier = fopen ("essai.txt", "w")) == NULL )
printf ("Ouverture fichier impossible\n") ;
else
{
// printf ("Ouverture fichier avec succes\n") ;
fprintf ( FFichier, "Ecriture dans le fichier...") ;
}
//Pour éviter de gérer un time out
Sleep(100);
//Pour connaitre le nombre d'octets dans le buffer d'entrée
ClearCommError(g_hCom,&Errors,&Stat);
nbCarALire=Stat.cbInQue;
//On effectue la lecture si il y a des caractères présents
if( (nbCarALire>0)&&(nbCarALire<=nCountMax) )
{
//Reception de la Chaine
if(ReadFile(g_hCom,Chaine,nbCarALire,&NCarLus,NULL)==0)
{
printf ("\n Erreur reception.\n") ;
return FALSE ;
}
}
//Finition de la Chaine
*pCountRead = NCarLus;
Chaine[NCarLus] = '\0' ;
//Ecriture dans le Fichier preouvert
fprintf ( FFichier,"%s", Chaine) ;
}
else
return FALSE ;
}
//-----------------------------------------------------------------------
// FONCTION : FermerCom
//-----------------------------------------------------------------------
int FermerCom()
{
if(g_hCom!=NULL)
{
CloseHandle(g_hCom);
return TRUE ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuPort
//-----------------------------------------------------------------------
int MenuPort ( char* ValeurPort )
{
int Choix1 ;
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Entrez l'adresse du port : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - COM1 -\n") ;
printf ("\t- 2 - COM2 -\n") ;
printf ("\t- 3 - COM1 PAR DEFAUT -\n") ;
printf ("\t- 4 - COM2 PAR DEFAUT -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decider de quitter le programme, aurevoir..\n\n") ;
return Choix1 ;
break;
case 1:
printf("\n Vous avez selectionne le port COM1.\n") ;
strcpy (ValeurPort, "COM1") ;
return Choix1 ;
case 2:
printf("\n Vous avez selectionne le port COM2.\n") ;
strcpy (ValeurPort, "COM2") ;
return Choix1 ;
case 3:
printf("\n Vous avez selectionne le port COM1 deja parametre.\n") ;
printf(" -- Informations parametrage --\n") ;
printf(" Port : COM1 \n") ;
printf(" Vitesse : 9600 bits/s \n") ;
printf(" Taille : 8 bits\n");
printf(" Parite : Aucune \n") ;
printf(" Stop bits : 1 bit stop\n") ;
return Choix1 ;
case 4:
printf("\n Vous avez selectionne le port COM1 deja parametre.\n") ;
printf(" -- Informations parametrage --\n") ;
printf(" Port : COM2 \n") ;
printf(" Vitesse : 9600 bits/s \n") ;
printf(" Taille : 8 bits\n");
printf(" Parite : Aucune \n") ;
printf(" Stop bits : 1 bit stop\n") ;
return Choix1 ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuVitesse
//-----------------------------------------------------------------------
int MenuVitesse (int *ValeurVitesse)
{
int Choix1 ;
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Entrez la vitesse en bits/s : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - 2400 -\n") ;
printf ("\t- 2 - 4800 -\n") ;
printf ("\t- 3 - 9600 -\n") ;
printf ("\t- 4 - 57600 -\n") ;
printf ("\t- 5 - Retour -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decide de quitter le programme, aurevoir..\n\n") ;
return Choix1 ;
break;
case 1:
case 2400:
printf("\n Vous avez selectionne une vitesse de 2400 bits/s.\n") ;
*ValeurVitesse = 2400 ;
return Choix1 ;
case 2:
case 4800:
printf("\n Vous avez selectionne une vitesse de 4800 bits/s.\n") ;
*ValeurVitesse = 4800 ;
return Choix1 ;
case 3:
case 9600:
printf("\n Vous avez selectionne une vitesse de 9600 bits/s.\n") ;
*ValeurVitesse = 9600 ;
return Choix1 ;
case 4:
case 19200:
printf("\n Vous avez selectionne une vitesse de 57600 bits/s.\n") ;
*ValeurVitesse = 57600 ;
return Choix1 ;
case 5:
printf("\n Vous avez decide de revenir au menu precedent.\n") ;
return Choix1 ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuTaille
//-----------------------------------------------------------------------
int MenuTaille ( int* ValeurTaille)
{
int Choix1 ;
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Entrez la taille de la donnee : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - 5 bits -\n") ;
printf ("\t- 2 - 6 bits -\n") ;
printf ("\t- 3 - 7 bits -\n") ;
printf ("\t- 4 - 8 bits -\n") ;
printf ("\t- 5 - Retour -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decide de quitter le programme, aurevoir..\n\n") ;
return Choix1 ;
break;
case 1:
printf("\n Vous avez selectionne une taille de 5 bits.\n") ;
*ValeurTaille = 5 ;
return Choix1 ;
case 2:
printf("\n Vous avez selectionne une taille de 6 bits.\n") ;
*ValeurTaille = 6 ;
return Choix1 ;
case 3:
printf("\n Vous avez selectionne une taille de 7 bits.\n") ;
*ValeurTaille = 7 ;
return Choix1 ;
case 4:
case 8:
printf("\n Vous avez selectionne une taille de 8 bits.\n") ;
*ValeurTaille = 8 ;
return Choix1 ;
case 5:
printf("\n Vous avez decide de revenir au menu precedent.\n") ;
return Choix1 ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuParite
//-----------------------------------------------------------------------
int MenuParite (char* ValeurParite)
{
int Choix1 ;
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Entrez la parite desiree : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - Aucune -\n") ;
printf ("\t- 2 - Paire -\n") ;
printf ("\t- 3 - Impaire -\n") ;
printf ("\t- 4 - Retour -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decide de quitter le programme, aurevoir..\n\n") ;
return Choix1 ;
break;
case 1:
printf("\n Vous avez selectionne la presence d'aucune parite.\n") ;
strcpy (ValeurParite,"Aucune" ) ;
return Choix1 ;
case 2:
printf("\n Vous avez selectionne la presence d'une parite paire.\n") ;
strcpy (ValeurParite,"Paire" ) ;
return Choix1 ;
case 3:
printf("\n Vous avez selectionne la presence d'une parite impaire.\n") ;
strcpy (ValeurParite,"Impaire" ) ;
return Choix1 ;
case 4:
printf("\n Vous avez decide de revenir au menu precedent.\n") ;
return Choix1 ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuStopBits
//-----------------------------------------------------------------------
int MenuStopBits ( int* ValeurStopBits)
{
int Choix1 ;
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Entrez le nombre de bit(s) stop : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - 1 bit stop -\n") ;
printf ("\t- 2 - 2 bits stop -\n") ;
printf ("\t- 3 - Retour -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decide de quitter le programme, aurevoir..\n\n") ;
return Choix1 ;
break;
case 1:
printf("\n Vous avez selectionne la presence d'un bit stop.\n") ;
*ValeurStopBits = 1 ;
return Choix1 ;
case 2:
printf("\n Vous avez selectionne la presence de deux bits stop.\n") ;
*ValeurStopBits = 2 ;
return Choix1 ;
case 3:
printf("\n Vous avez decide de revenir au menu precedent.\n") ;
return Choix1 ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
//-----------------------------------------------------------------------
// FONCTION : MenuRecevoirEnvoyer
//-----------------------------------------------------------------------
int MenuRecevoirEnvoyer ()
{
int Choix1 ;
int Sortie = TRUE ;
int SortieRetour ;
while (Sortie)
{
printf ("\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t------- ** Liaison Serie RS-232 ** -------\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t- -\n") ;
printf ("\t- Que voulez-vous faire : -\n") ;
printf ("\t- -\n") ;
printf ("\t- 1 - Envoyer -\n") ;
printf ("\t- 2 - Recevoir -\n") ;
printf ("\t- 3 - Fermer le port -\n") ;
printf ("\t- 4 - Retour -\n") ;
printf ("\t- 0 - Quitter -\n") ;
printf ("\t- -\n") ;
printf ("\t----------------------------------------------\n") ;
printf ("\t Votre Choix : ");
scanf ("%d", &Choix1) ;
system("cls") ;
switch(Choix1)
{
case 0:
printf ("\n Vous avez decide de quitter le programme, aurevoir..\n") ;
if (FermerCom())
printf ("\n Fermeture du port avec succes.\n\n") ;
SortieRetour = 0 ;
Sortie = FALSE ;
return SortieRetour ;
break;
case 1:
printf("\n Vous avez selectionne l'envoi de donnees sur le port.\n") ;
char *Chaine ;
Chaine = malloc (128) ;
printf("\n Veuillez saisir votre message: ") ;
scanf("%s", Chaine) ;
if ( EnvoyerCom(Chaine) )
printf (" Trame envoyee correctement.\n") ;
else
printf(" Erreur envoi trame.\n") ;
break ;
case 2:
printf("\n Vous avez selectionne la reception de donnees sur le port.\n") ;
printf ("\n Pour sortir du mode reception, veuillez entrer la lettre 'q'.\n") ;
/*** Reception boucle infini -> sortir en entrant le caractere 'q' ***/
char UnCaractere = ' ' ;
char Chaine1[30] = " Ordre Plateau 1 Ok " ;
char Chaine2[30] = " Ordre Plateau 2 Ok " ;
char Chaine3[30] = " Ordre Plateau 3 Ok " ;
char Chaine4[30] = " Ordre Plateau 4 Ok " ;
char Chaine5[30] = " Ordre Plateau 5 Ok " ;
char Chaine6[30] = " Ordre Plateau 6 Ok " ;
char Chaine7[30] = " Ordre Plateau 7 Ok " ;
char Chaine8[30] = " Ordre Plateau 8 Ok " ;
while ( (UnCaractere != 'Q') && (UnCaractere != 'q') )
{
printf (" ") ;
char ChaineRecue[100] ;
int nbMaxCar = 100 ;
int nbCarRecus ;
if ( RecevoirCom(ChaineRecue, nbMaxCar, &nbCarRecus ) )
{
if ( nbCarRecus != 0 )
{
printf (" Trame recue correctement.\n") ;
//printf ("Nombre de caractere recus : %d\n", nbCarRecus) ;
if (strcmp (ChaineRecue, "Plateau 1") == 0 )
EnvoyerCom(Chaine1) ;
else if (strcmp (ChaineRecue, "Plateau 2") == 0 )
EnvoyerCom(Chaine2) ;
else if (strcmp (ChaineRecue, "Plateau 3") == 0 )
EnvoyerCom(Chaine3) ;
else if (strcmp (ChaineRecue, "Plateau 4") == 0 )
EnvoyerCom(Chaine4) ;
else if (strcmp (ChaineRecue, "Plateau 5") == 0 )
EnvoyerCom(Chaine5) ;
else if (strcmp (ChaineRecue, "Plateau 6") == 0 )
EnvoyerCom(Chaine6) ;
else if (strcmp (ChaineRecue, "Plateau 7") == 0 )
EnvoyerCom(Chaine7) ;
else if (strcmp (ChaineRecue, "Plateau 8") == 0 )
EnvoyerCom(Chaine8) ;
else
printf (" Message recu : %s\n", ChaineRecue ) ;
}
}
else
printf("\n Erreur envoi trame.\n") ;
UnCaractere = getchar() ;
}
break ;
case 3:
printf("\n Vous avez decide de fermer le port de communication.\n") ;
if (FermerCom())
printf ("\n Fermeture du port avec succes.\n\n") ;
else
printf("\n Fermeture du port echouee.\n\n") ;
Sortie = FALSE ;
return SortieRetour ;
break ;
case 4:
printf("\n Vous avez decide de revenir au menu precedent.\n") ;
if (FermerCom())
printf ("\n Fermeture du port avec succes.\n\n") ;
else
printf("\n Fermeture du port echouee.\n\n") ;
Sortie = FALSE ;
return SortieRetour ;
break ;
default:
system("cls");
printf("\n Mauvaise touche, essayer de nouveau !! \n") ;
break ;
}
}
}
|
|
Cette discussion est classée dans : port, int, printf, false, if
 Répondre à ce message
 Sujets en rapport avec ce message
Communication RS232 : Pb de vitesse [ par arb ]
Bonjour Je me suis insipiré du code de ymca2003 (Code source N°22441) pour faire un petit programme qui envoie le contenu d'un fichier via une liais
Communication RS232 : Pb de vitesse [ par arb ]
Bonjour Je me suis insipiré du code de ymca2003 (Code source N°22441) pour faire un petit programme qui envoie le contenu d'un fichier via une liais
Gestion de plusieurs ports RS232 [ par dissezfr ]
Bonjour à tous d'abordJ'ai récupéré un code sur le site permettant de géré un port série, j'aimerai piloter 8 (voir +) ports série avec un seul ordina
recherche comment faire fonctionner ce code via une interface graphique (pilotage port //) [ par cedpic ]
voici le code que j ai creer qui marche tres bien en mode console mais je souhaiterais les piloter par une interface graphique en remplacent les bouto
Probleme : Sudoku en C [ par seth59222 ]
Bonsoir, voila je suis actuellement en première année d'info, donc assez novice et je viens de créer ce petit bout de programme en C qui consiste a ré
rien ne s'affiche a l'execution(les tubes ordinaires) [ par brekiano ]
bonsoir, svp chui débutant dans la programmation systeme sous unix.j'ai fait ce programme qui affiche normalement le résultats de ce pipes : ]$ ps
Table de hachage avec patronyme [ par guitoontruant ]
Bonjour, Désolé, j'avais d'abord poster dans les discussions libres.Voilà je dois créer une table de hashage de patronymes par le biais de N entrées,
Segmentation fault sur un tableau de char [ par MaxSoldier ]
Bonsoir tout le monde !Je me suis mis au C/C++ sous linux il y a quelques jours et j'ai de nombreuses erreur de dépassement de tampon (segmentation fa
aide pour une liaison serie [ par punch95 ]
J'ai trouvé un source c pour une liaison serie d'un beck sc12 et j'aimerai que l'on me commente le source si c possible merci./***********************
Aide pour un programme,création variable [ par pirana ]
bonjour à vous tous ... Voila je suis un débutant en C... j'ai récupéré ce code sur le site et j'aimerai me simplifié la vie...mais je n'y arrive pas
 Livres en rapport
|
Derniers Blogs
 IMAGINE CUP 2012, MAKE A SIGN EN FINALEIMAGINE CUP 2012, MAKE A SIGN EN FINALE par junarnoalg
Voilà qui est fait, la nouvelle est officielle ! L'équipe belge "Make a Sign" va au pays des kangourous défendre son projet dans la catégorie Software Design. http://www.imaginecup.com/CompetitionsContent/Competition/WorldwideFinalists.aspx V...
Cliquez pour lire la suite de l'article par junarnoalg KINECT 1.5 IS OUT !KINECT 1.5 IS OUT ! par Vko
La version 1.5 du Kinect For Microsoft vient tout juste de sortir ! Plein de nouveautés: Tracking de squelette en Near Mode Détection en position assise Détection faciale avec un SDK dédié Documentation et des guideline (enfin) Un out...
Cliquez pour lire la suite de l'article par Vko LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) par richardc
Mise à jour des Web API du 14 Mai
Réservez dès maintenant votre journée du 20 juin pour le Windows Azure Dev Camp 2012 à Paris
Mise à jour de Team Foundation Service
MechCommander 2 sur Windows 8
Entity Framework 5 Release Candidate e...
Cliquez pour lire la suite de l'article par richardc REACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITERREACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITER par Groc
Une mauvaise utilisation de rx lors de l'écriture d'une couche d'accès à des services peut conduire à des cas embarassants avec des erreurs mal gérées, des appels qui ne partent lorsqu'ils le devraient, et même des résultats incorrects . le tout nuis...
Cliquez pour lire la suite de l'article par Groc SHAREPOINT BLOG SITE, PROBLèME D'ARCHIVESSHAREPOINT BLOG SITE, PROBLèME D'ARCHIVES par junarnoalg
Dernièrement, nous avons migré le site
myTIC
vers un nouveau serveur SharePoint 2010. Dans les contenus que nous vouloins récupérer, nous avions un certain nombre de blogs.
Nous avons utilisé les commandes Power...
Cliquez pour lire la suite de l'article par junarnoalg
Logiciels
 sDEVIS-FACTURES vlPRO (8.1.0.3)SDEVIS-FACTURES VLPRO (8.1.0.3)sDEVIS-FACTURES vlPRO a été mis au point pour les particuliers, créateurs, entrepreneurs, artisa... Cliquez pour télécharger sDEVIS-FACTURES vlPRO 974 Application Server (12.2.4.6)974 APPLICATION SERVER (12.2.4.6)Développez de puissantes applications dans un environnement de 'cloud computing', clusterisé, séc... Cliquez pour télécharger 974 Application Server vPicture (1.4.2.1)VPICTURE (1.4.2.1)Avec vPicture, hébergez vos images facilement et rapidement.
vPicture est un utilitaire simple, ... Cliquez pour télécharger vPicture Easy-Planning (2.2.1.6)EASY-PLANNING (2.2.1.6)Easy-Planning permet de créer des plannings sous la représentation de diagrammes et est adapté au... Cliquez pour télécharger Easy-Planning COM-BACKUP (2.0)COM-BACKUP (2.0)
COM-BACKUP est un logiciel de sauvegarde qui permet de planifier les sauvegardes de vos dossiers ...
Cliquez pour télécharger COM-BACKUP
|