Variables de struct dans un tableau - C

#include "FOSSIL.H"
#include "CLIB.H"
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "primsolclimat_server.h"

//*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+*-+
int main()
{
	printf( "-- PRIMSOL CLIMAT - L.BERNARD - 2008  --\n\n");

	initialiser();
   communicationSocket();
   analyserTrame();
	return 0;
}

void initialiser()
{
	// initialisation baudrate ------------------------------------

 	fossil_setbaud(0,9600, FOSSIL_PARITY_NO, 8, 1);
   pfe_enable_pio (10,5);  // initialise pio10 en sortie au niveau bas
	pfe_enable_pio (9,1);   // initialise pio9 en entrée pour qu'il soit capable
   								// de lire avant d'émettre
	sleep(1);

   // purge des buffers entrée et sortie
   fossil_purge_output( 0 );
   fossil_purge_input( 0 );

   retStatu1 = fossil_status_request ( 0 );

   if ((retStatu1 && 0x40) == 1 )     // test du bit 6 Buffer vide
   {
   	printf( "\rLe buffer est vide\n")  ;
   }
   else
   {
     	printf( "\rProbleme, le buffer devrait etre vide\n");
   }
}

void huge creerSocket(void)
{
/*1 Initialisation de la socket locale d'écoute                       */
/*2 Création de la socket locale d'écoute                             */
/*3 Attachement des paramètres de la socket locale d'écoute           */
/*4 Mise en écoute de la socket locale d'écoute                       */
/*5 Acceptation et mise en attente de connexion d'un client           */
/*6 Réception du message de l'application cliente                     */
/*7 Envoi d'un message à l'application cliente                        */
/*8 Fermeture des sockets d'écoute et de communication                */
   //1
   parametreListenSocket.sin_family = AF_INET;
   parametreListenSocket.sin_port = htons(PORT);
   parametreListenSocket.sin_addr.s_addr = 0;
   //2
// Création de la socket
   ListenServerSocket = opensocket(SOCK_STREAM, &Erreur);
   //3
   Retval = bind(ListenServerSocket, (const struct sockaddr far *)&parametreListenSocket , &Erreur);
   //4
//mise en écoute de la socket d'ecoute
   Retval = listen(ListenServerSocket, 1, &Erreur);
// Envoie d' "Hello world !\r\n" à n'importe quelle connection
	while(1)
	{
		if((CommServerSocket = accept(ListenServerSocket, (struct sockaddr *)&parametreCommSocket, &Erreur)) != 0)
		{
			send(CommServerSocket, &trame, 50, MSG_BLOCKING, &Erreur);
		}
	}
}

void communicationSocket(void)
{
   RTX_Create_Task(&creerSocketId, &creerSocketDefBlock);
}

void huge timeout(void)
{
timer =0;
   printf("Chronometre :");
	do
   {
      RTX_Sleep_Time(1000);
   	timer++;
      printf("%i, ",timer);
   }while((timer!=30) && (flag!=1));
   if(flag==1)
   {
      printf("\nMerci de verifier que la station est bien sous tension et qu'elle est connectee a la carte par un cable croise NULL MODEM ");
	}

}

void analyserTrame()
{
// reception et analyse de la trame-----------------------------------------
	do
  	{
   flag = 0;
   RTX_Create_Task(&timeoutId, &timeoutDefBlock);
   i = 0;
   dummy = fossil_getbyte_wait ( 0 ); // le getbyte_wait récupere les octets
         										     //envoyés par liaison RS232
   flag = 1;
   RTX_Delete_Task(timeoutId);
   meteobuffer[i] = dummy;

   if(meteobuffer[0]==0xff)   // ON TESTE SI ON A RECU L'EN-TETE FF 1 FOIS
   {
      printf( "\n<%x>",meteobuffer[i]) ;  // On affiche le premier octet recu
      i++;
   	dummy = fossil_getbyte_wait ( 0 );
	   meteobuffer[i] = dummy;
      printf( "<%x>",meteobuffer[i]) ;   // On affiche le deuxieme octet recu
      if(meteobuffer[1]==0xff)   // ON TESTE SI ON A RECU FF    2 FOIS
      {//si on a recu <ff> <ff>, on analyse le troisieme octet pour définir le type de mesure
      	i++;
         dummy = fossil_getbyte_wait ( 0 );
         meteobuffer[i] = dummy;


      	printf( "<%x>",meteobuffer[i]) ;   // On affiche le 3eme octet recu

         switch (meteobuffer[2])             // en fonction de meteobuffer[2]
         {
         ///////////////////////  VENT  ///////////////////////////
      	case 0:
         // on en deduit que c'est le vent
         j = 10;

         // boucle pour récupérer les mesures du vent
         do
         {
           	i++;
           	dummy = fossil_getbyte_wait ( 0 );
         	meteobuffer[i] = dummy;
   
      		printf( "<%x>",meteobuffer[i]) ;   // On affiche l'octet recu
         }while (i < j);
         //printf( "\n Grandeur mesuree : "<< grandeur << "\n\n";
         printf( "\nC'est le vent\n");
         //////////////////////// Rafales et vitesse moyenne ////////
         capteur_station.vrafvent2 = (meteobuffer[5]&0xf0)>>4;
         capteur_station.vrafvent = meteobuffer[6]&0x0f+((meteobuffer[6]&0xf0)>>4)*10;
         /////////////// Direction du vent exprimee en ° //////////////
         capteur_station.dvent = (meteobuffer[4]&0x0f)+((meteobuffer[4]&0xf0)>>4)*10
         +(meteobuffer[5]&0x0f)*100;

         printf( "Vitesse des rafales : %i,%i\nDirection du vent : %i\n", capteur_station.vrafvent,capteur_station.vrafvent2,capteur_station.dvent );
         break;

         ///////////////////////  PLUIE  ///////////////////////////
      	case 1:
         j = 15;
         // on en deduit que c'est la pluie
         // boucle pour récupérer les mesures de la pluie
         do
         {
         	i++;
            dummy = fossil_getbyte_wait ( 0 );
         	meteobuffer[i] = dummy;
       //conversion en hexadecimal
     			printf( "<%x>",meteobuffer[i]) ;   // On affiche l'octet recu
         }while (i < j);
         printf( "\nC'est la pluie\n");
         //////////////////////// pluviometrie en mm/h  ///////////////
         capteur_station.pluv = (meteobuffer[4]&0x0f)+((meteobuffer[4]&0xf0)>>4)*10+(meteobuffer[5]&0x0f)*100;

         printf( "Pluviometrie : %i mm/h\n", capteur_station.pluv) ;
         break;

         ///////////////////////  THERMO, HYGRO  ///////////////////////
         case 3:
         j =8;
         // on en deduit que c'est la temperature et l'hygrometrie
         // boucle pour récupérer les mesures
         do
         {
         	i++;
            dummy = fossil_getbyte_wait ( 0 );
         	meteobuffer[i] = dummy;
       //conversion en hexadecimal
     			printf( "<%x>",meteobuffer[i]) ;  // On affiche l'octet recu
         }while (i < j);

         //printf( "\n Grandeur mesuree : " << grandeur <<"\n\n" ;
         printf( "\nC'est la temperature et l'hygrometrie\n");
         capteur_station.signe =(meteobuffer[5]&0x0f)>>7;
         if (capteur_station.signe==0)
         {
         	signe = "+";
         }
         else
         {
            signe = "-";
         }
         capteur_station.temp =((meteobuffer[4]&0xf0)>>4)+(meteobuffer[5]&0x0f)*10+((meteobuffer[5]&0x30)>>4)*100;
         capteur_station.temp2 =(meteobuffer[4]&0x0f);
         printf( "Temperature : %s %i,%i Degres Celsius\n", signe, capteur_station.temp, capteur_station.temp2 );

         capteur_station.hygr =(meteobuffer[6]&0x0f)+((meteobuffer[6]&0xf0)>>4)*10;
         printf( "Hygrometrie : %i pourcent\n", capteur_station.hygr );
         break;

         case 6:
         j =13;
         // on en deduit qu'on ne traite pas cette grandeur
         // boucle pour récupérer les mesures
         do
         {
         	i++;
            dummy = fossil_getbyte_wait ( 0 );
         	meteobuffer[i] = dummy;
         }while (i < j);
         printf( "\nOn ne traite pas cette grandeur\n");

         break;

         case 14:
         j =4;
			// on en deduit qu'on ne traite pas cette grandeur
         // boucle pour récupérer les mesures
         do
         {
         	i++;
            dummy = fossil_getbyte_wait ( 0 );
         	meteobuffer[i] = dummy;
         }while (i < j);
         printf( "\nOn ne traite pas cette grandeur\n");

         break;

         default:
         // on en deduit que c'est une grandeur que l'on ne traite pas
         printf( "\nOn ne traite pas cette grandeur\n");
         break;
         };  // fin switch case
     	}
     	else
     	{
     		printf("\nDesynchronisation de la trame a partir du deuxieme octet. La station meteo se synchronise. Si le processus dure plus d'une minute, merci de redemarrer la station meteo.\n");
      }// fin else (if recup2 != ff)
   }
   else
  	{
   	printf("\nDesynchronisation de la trame des le 1er octet. La station meteo se synchronise. Si le processus dure plus d'une minute, merci de redemarrer la station meteo.\n");
   } // fin else (if recup != ff)
   // création de la trame
   sprintf(trame, "%2i%2i%3i%2i%2i%2i%2i%3i",
   capteur_station.vrafvent ,
   capteur_station.vrafvent2 ,
   capteur_station.dvent ,
   capteur_station.temp ,
   capteur_station.temp2 ,
   capteur_station.signe ,
   capteur_station.hygr ,
   capteur_station.pluv
   );

 ;


} // fin do-while general
while(1);
// L'application grâce à une boucle infinie ecoute toujours le port Serie EXT du DK51
}

#ifndef PRIMSOLSERVER_H
#define PRIMSOLSERVER_H
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <dos.h>
#include <windows.h>

/******************************************************************************
* Constants
******************************************************************************/
#define TASKSTACKSIZE  2048  // Size of stack for created tasks in bytes
#define PORT           4000

/******************************************************************************
* Prototypes
******************************************************************************/
void initialiser(void)  ;
void communicationSocket(void)  ;
void huge creerSocket(void) ;
void huge timeout(void) ;
void analyserTrame(void);

/******************************************************************************
* Global variables
******************************************************************************/

 /*/////////////////////////////////////////////////////////////////////////////
				variables pour la fonction d'analyse de la trame
/////////////////////////////////////////////////////////////////////////////*/
int retStatu1;
int i;
int j;
int a;

unsigned char dummy;
unsigned char meteobuffer[16];
unsigned char Var[2];
unsigned char * grandeur ;
char* signe ;

// structure de stockage des mesures
struct capteur_station_tag
{
   int vrafvent;  // vitesse des rafales du vent
   int vrafvent2; // rafales du vent 0.1 digit
   int dvent;  	// direction du vent exprimee en °C
	int temp;   	// temperature
   int temp2;   	// temperature 0.1 digit
   int signe;  	// signe temperature
	int hygr;   	// hygrometrie
   int pluv;   	// pluviometrie
}capteur_station;

/*/////////////////////////////////////////////////////////////////////////////
variables pour le thread de vérification de communication avec la station météo
/////////////////////////////////////////////////////////////////////////////*/

int timeoutId;  // ID du thread timeout qui verifie la reception de messages dans un delai acceptable
int timer;
int flag;

unsigned int timeoutStack[TASKSTACKSIZE/sizeof(unsigned int)];
                                 // pile

TaskDefBlock timeoutDefBlock = {
                               timeout,         // Function to be executed in the task
                               {'T','I','M','E'},  // Nom de la tache
                               &timeoutStack[TASKSTACKSIZE/sizeof(unsigned int)],
                                                   // Top of stack
                               TASKSTACKSIZE,      // Size of the stack
                               0,                  // Not supported
                               26,                 // Normal priority
                               0,                  // Time slice (not needed here)
                               0, 0, 0, 0          // Mailbox depth (not needed here)
                             };  // Information on task 1

/*/////////////////////////////////////////////////////////////////////////////
	variables pour le thread de création de la communication socket
/////////////////////////////////////////////////////////////////////////////*/

int creerSocketId;  // ID du thread de creation de la communication par socket

unsigned int creerSocketStack[TASKSTACKSIZE/sizeof(unsigned int)];
                                 // pile

TaskDefBlock creerSocketDefBlock = {
                               creerSocket,        // fonction qui va etre lancee par le thread
                               {'S','O','C','K'},  // Nom de la tache
                               &creerSocketStack[TASKSTACKSIZE/sizeof(unsigned int)],
                                                   // Top of stack
                               TASKSTACKSIZE,      // Size of the stack
                               0,                  // Not supported
                               26,                 // Normal priority
                               0,                  // Time slice (not needed here)
                               0, 0, 0, 0          // Mailbox depth (not needed here)
                             };  // Information on task 1


/*/////////////////////////////////////////////////////////////////////////////
					variables pour la communication  par socket
/////////////////////////////////////////////////////////////////////////////*/

// descripteurs de sockets (ecoute et comm)
   int ListenServerSocket;
   int CommServerSocket;
// variable de traitement
   int Erreur;
   int Retval;
   char trame[9];        // represente la trame que l'on va envoyer au client

// Enregistrements des parametres des sockets
	struct sockaddr_in parametreListenSocket;
   struct sockaddr_in parametreCommSocket;

#endif

Float trame[9]
struct 
{
     int variable0
     int variable1
     …
     float variable7
     int variable8
}mastruct;

trame[0] = mastruct.variable0;
trame[1] = mastruct.variable1 ;
...
trame[7] = mastruct.variable7 ;
trame[8] = mastruct.variable8 ;

char *pBuf=new char[256];
	int BufSize = 256;
...
...
// reçoit la trame du serveur
	Receive(pBuf,BufSize);
...
...	
sscanf(pBuf, "%2%2%3%2%2%2%2%3", vrafvent1,vrafvent2,dvent,temp1, temp2,signe,hygr,pluv);
...

int BufSize = 256;
char *pBuf=new char[BufSize];

int BufSize = 256;
char *pBuf=new char[BufSize];
...
...
// reçoit la trame du serveur
	Receive(pBuf,BufSize);
...
...

sscanf(pBuf, "%2i%2i%3i%2i%2i%2i%2i%3i", &vrafvent1,&vrafvent2,&dvent,&temp1, &temp2,&signe,&hygr,&pluv);

// création de la trame
   sprintf(trame, "%2i%2i%3i%2i%2i%i%2i%3i",
   capteur_station.vrafvent ,
   capteur_station.vrafvent2 ,
   capteur_station.dvent ,
   capteur_station.temp ,
   capteur_station.temp2 ,
   capteur_station.signe ,
   capteur_station.hygr ,
   capteur_station.pluv
   );

char trame[5];

trame[0] = capteur_station.vrafvent + capteur_station.vrafvent2/10 ;
trame[1] = capteur_station.dvent ;

switch(capteur_station.signe)
{
    case 0:
    trame[2] = capteur_station.temp + capteur_station.temp2/10;
    break;
    case 1:
    trame[2] = -capteur_station.temp - capteur_station.temp2/10;
    break;
};

trame[3] = capteur_station.hygr  ;
trame[4] = capteur_station.pluv  ;

int CMeteo::Run()
{
	int BufSize = 256;
	char *pBuf=new char[BufSize];
	m_IPSrv = "192.168.1.56";
	m_Port = 4000;

	int vrafvent1=0;
	int vrafvent2=0;
	
	float vrafvent=0;

	int dvent=0;
	int temp1=0;
	int temp2=0;

	float temp=0;

	int signe=0;
	int hygr=0;
	int pluv=0;

	//m_pCommSocket->setDoc(m_pDonnees); // transfert de l'adresse du pointeur m_pDonnees à la classe CCommSocket
	// client,cree un socket par default
	m_pCommSocket.Create();
	// ouvre la connexion sur le serveur
	m_pCommSocket.Connect(m_IPSrv,m_Port);
	// reçoit la trame du serveur
	m_pCommSocket.Receive(pBuf,BufSize);
	// ferme le socket connecte
	Sleep(1);
	m_pCommSocket.Close();
	
	Sleep(1);
	vrafvent = pBuf[0];
	dvent	 = pBuf[1];
	temp	 = pBuf[2];
	hygr	 = pBuf[3];
	pluv	 = pBuf[4];
	Sleep(1);
	m_pDonnees->m_pVerrouMeteo.Lock();                  // simple verrou
	m_pDonnees->acquisitionReelleMeteo[0]= temp;                      // acquisitionReelleMeteo[] est le tableau 
	m_pDonnees->acquisitionReelleMeteo[1]= (float)hygr;               //      qui sert à afficher dans l'IHM.
	m_pDonnees->acquisitionReelleMeteo[2]= (float)pluv;               // On y accède par le pointeur 
	m_pDonnees->acquisitionReelleMeteo[3]= vrafvent;                 // m_pDonnees declare avant comme ceci
	m_pDonnees->acquisitionReelleMeteo[4]= (float)dvent;            // CNomdeProjetDoc * m_pDonnees;
	m_pDonnees->m_pVerrouMeteo.Unlock();
	
	delete[]pBuf;


	return (0);
}