Sujet Précédent Sujet Suivant

Liaison RS232 avec un DK50

mastergay Messages postés 4 Date d'inscription vendredi 1 décembre 2000 Statut Membre Dernière intervention 12 mars 2008 - 5 mars 2008 à 14:40
franciscohdz Messages postés 2 Date d'inscription vendredi 4 novembre 2011 Statut Membre Dernière intervention 8 novembre 2011 - 8 nov. 2011 à 15:16
Bonjour, je m'apelle julien et je suis en BTS IRIS 2eme année. Pour mon projet, j'ai besoin d'établir une liaison entre une station meteo ( de type oregon scientifique ) et un DK50 ( microcontroleur de marque BECK ).

Ma question est simple : Pourquoi je ne reçois rien ??

- La station emmet en continue les infos ( vérifier avec Borland C++ Builder, j'y arrive avec les ansistring )
- J'utilise le language C .
- Le passage par HyperTerminal est obligé pour débuguer

Normalement, je devrais avoir au moin 1 octet transmit !! ( CF capture d'écran a la fin )
et le buffer d'entrée devrais contenir des infos..

Je vous join mon source ainsi que quelques infos pour comprendre le fonctionnement.

J'espere vraiment être clair.

***************************************************************************

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

int main()
{
   //******* Variable pour le  RS232 *******************************************
   short port = 0 ;   //  port: 0=EXT, 1=COM
   short baud = 9600; //  Vitesse de transfert
   short parite = 0 ; //  0,1,2,3,4
   short bits = 8 ;   //  7 ou 8
   short stop = 1 ;   //  1 ou 2   short flow 1 ;   //  0 rien -- 1 = RTS/CTS -- 2 = XON/XOFF
   short mode = 1 ;   //  0: disable receiver - 1: enable receiver
   int buffer232, retStatu1, retStatu2  ;
   unsigned int nombreOctetTransmit ;
   unsigned char buffer[10] = "123456789"  ;
   //*****************************************************************

   printf("\r\n-- Appli DK50 projet 2008  --\r\n");
   printf("\r\n-                           -\r\n");

      // init fossil --------------------
      if( fossil_init( port ) != 0x1954 )     // code drivers fossil
      {
        printf("\r\nInit fossil ERREUR\r\n");
      }
   sleep(1);
      // init baudrate ------------------------------------
   printf("\r- initialisation baud rate --\r\n");
      fossil_set_extctrl( port, baud, parite, bits, stop );

   printf("\r--   baud rate initialise  --\r\n");

   sleep(1);

      // init flow control
      if (flow)
      {
        printf("\r-Flow control utilise:%s-\r\n", (flow==1) ? "RTS/CTS" : "XON/XOFF");
   sleep(1);
    if (flow == 0) // Ancun      ( Pas de control de flux )
      fossil_set_flowcontrol( port, FOSSIL_FLOWCTRL_OFF );        // ici 0x0

   if (flow == 1) // RTS/CTS      (CTS transmet /RTS recoit)
      fossil_set_flowcontrol( port, FOSSIL_FLOWCTRL_RTSCTS );        // ici 0x2

    if (flow == 2) // XON/XOFF
        fossil_set_flowcontrol( port, FOSSIL_FLOWCTRL_XONXOFF_SEND_RECV ); // 0x9
      }

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

   retStatu1 = fossil_status_request ( port );
   printf("Etat du buffer : ");   if (retStatu1 96 || retStatu1 64)
   {
       printf("\r Le buffer a ete vide \r\n")  ;
   }
   else
   {
         printf("\r Probleme, le buffer devrait etre vide\n");
   }

   // réception des trames dans le buffer rs232 */*/*/*/*/*/*/*/*/*/*/

   printf("\r--- Reception d'une trame ---\r\n");

   fossil_enable_receiver ( port, 1 );
   sleep(1) ;
   nombreOctetTransmit = fossil_readblock ( port, buffer, bits );
    printf("\r%i octets on ete transmit !\r\n",nombreOctetTransmit );

   buffer232 = fossil_getbyte ( port ); // fossil_getbyte[_wait]
   printf("\r**** buff    : %i\n",buffer,buffer);
   printf("\r**** buff232 : %i\n",buffer232, buffer232);
   sleep(1);

   retStatu2 = fossil_status_request ( port );
   printf("\rEtat du buffer : ");
   sleep(1);   if (retStatu2 96 || retStatu2 64)
   {
   printf("Buffer vide\r\n")  ;
   }
    else
   {
  
   printf("\r Le buffer contient: %i", buffer232);
   }

   fossil_enable_receiver ( port, 0 );
   printf("\r\n-                          -\r\n");
   printf("\r\n-------- Fin Appli ---------\r\n");

}

---------------

-----------------------------------

Vraiment , je pense avoir tout dit, mais je suis sur qu'il manque des infos, je passe souvent ici, si quelqu'un peut m'aider je lui paye un coup a boire Merci d'avance et bonne journée a vous ! :) 
                                                                                                                                                                    Ju

13 réponses

Réponse 1 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
6 mars 2008 à 11:02
SISKOZED
0
Réponse 2 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
6 mars 2008 à 11:05
salut, je suis aussi éleve en iris 2 et j'ai le même projet que toi. Je n'ai pas encore de réponse à ta question, je plache dessus en ce moment mais tu peux déjà me contacter sur mon mail. Je te tiens au courant de mes avancées.

leny@frid.fr
0
Réponse 3 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
7 mars 2008 à 08:56
salut,

J'ai une question, dans ton programme, tu parametre la vitesse de transfert à 9600; or apres tu te connecte en 19200. Sais-tu pourquoi ?

Sinon connais tu la structure de la trame envoyée par la station météo, je n'ai pas encore réussi à la visualiser ? J'ai essayé avec 3 hyperterminaux différents qui affichent en héxa mais sans succès.

Bon courage
0
Réponse 4 / 13
mastergay Messages postés 4 Date d'inscription vendredi 1 décembre 2000 Statut Membre Dernière intervention 12 mars 2008
11 mars 2008 à 10:25
Si je me connecte a 19200 bauds c'est pour avoir acces au DK50 via le Port COM .

Ensuite je parametre ( enfin je pense ) le port EXT a 9600 bauds pour recup les

info de la station meteo !

n'hésite pas a m'envoyer un mail, car je passe ici que en cours :s
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 13
mastergay Messages postés 4 Date d'inscription vendredi 1 décembre 2000 Statut Membre Dernière intervention 12 mars 2008
11 mars 2008 à 10:27
Sinon jai un doc papier avec la structure de la trame que j'avais recup en premiere année , c'est pas simple du tout, mais avant de décoder , il faudrais arriver a recevoir quelque chose et le stocker dans un tableau!
0
Réponse 6 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
12 mars 2008 à 09:19
j'ai réussi à récupérer la trame de la station et je l'ai traduit en héxa grace a un editeur hexa. Je suis maintenant en train de l'étudier et je fais un programme c++ pour recevoir les trames et les analyser. J'ajouterais une fonction ensuite pour les décapsuler et les enregistrer dans un tableau.
0
Réponse 7 / 13
mastergay Messages postés 4 Date d'inscription vendredi 1 décembre 2000 Statut Membre Dernière intervention 12 mars 2008
12 mars 2008 à 15:28
Salut, j'ai avancer aussi mais je n'arrive toujours pas avec la station, tu branche le PC sur le port COM et la station sur EXT ???

La j'étudie comment se connecter a une BDD via le DK50 pour stocker les infos ! C'est quazi-fini ! :)

Envoi moi un mail pour rep, si on arrive a trouver la solution on la postera sur le forum !
0
Réponse 8 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
8 avril 2008 à 11:14
Salut, j'ai réussi à récupérer et analyser les trames qui arrivent. Voici le code. Pour des explications plus poussées, vous pouvez me joindre sur mon mail leny@frid.fr

/////////////////////////////////////////////////////////// programme développé sous borland pour carte SC12 ou SC13 avec module DK51
//////////////////////////////////////////////FICHIER PRINCIPAL  /////////////////     METEO.CPP

//***** APPLI DK50         AUTHOR : Leny FRID ; DATE : 03/08 ***********


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


int main()
{
   int retStatu1;
   int i = 0;
   int j = 0;
   int a = 0;
   unsigned char dummy;
   unsigned char meteobuffer[16];
   char* grandeur ;
   char* signe;


   // init fossil --------------------
     if( fossil_init( 0 ) != 0x1954 )     // code drivers fossil
   {                                      // il faut le mettre avant le
  printf("\r\nInit fossil ERREUR\r\n");  // printf "appli dk50 projet 2008"
   }
   sleep(1);
   //initialisation liaison dk51 - station
   fossil_set_flowcontrol( 0, 1 );


   printf("\r\n-- PRIMSOL CLIMAT - L.BERNARD - 2008  --\r\n");
   printf("\r\n-                           -\r\n");


   // init 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 empty
   {
    printf("\rLe buffer est vide\n")  ;
   }
   else
   {
      printf("\rProbleme, le buffer devrait etre vide\n");
   }


   // reception et analyse de la trame-----------------------------------------


    do
    {
      i = 0;
   dummy = fossil_getbyte_wait ( 0 ); // le getbyte récupere les octets
                        //envoyés par liaison RS232
         meteobuffer[i] = dummy;


         if(meteobuffer[0]==0xff)   // ON TESTE SI ON A RECU FF     1 FOIS
         {
          printf( "\n<%2x> ", meteobuffer[i] );  // On affiche l'octet recu
          i++;
          dummy = fossil_getbyte_wait ( 0 );
          meteobuffer[i] = dummy;
            printf( "<%2x> ", meteobuffer[i] );  // On affiche l'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( "<%2x> ", meteobuffer[i] );  // On affiche l'octet recu


             switch (meteobuffer[2])             // en fonction de meteobuffer[2]
             {
               ///////////////////////  VENT  ///////////////////////////
          case 0:
                  // on en deduit que c'est le vent
                  grandeur = "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( "<%2x> ", meteobuffer[i] );  // On affiche l'octet recu
              }while (i < j);
                  printf( "\n Grandeur mesuree : %s\n\n", grandeur);
                  //////////////////////// Rafales et vitesse moyenne ////////
                  capteur_station.vrafvent = ((meteobuffer[5]&0xf0)>>4)+(meteobuffer[6]&0x0f)*10+((meteobuffer[6]&0xf0)>>4)*100;
                  capteur_station.vmoyvent = (meteobuffer[7]&0x0f)+( (meteobuffer[7]&0xf0)>>4)+(meteobuffer[8]&0x0f)*10;
                  /////////////// Direction du vent exprimee en ° //////////////
                  capteur_station.dvent = (meteobuffer[4]&0x0f)+((meteobuffer[4]&0xf0)>>4)*10
                  +(meteobuffer[5]&0x0f)*100;


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


      break;


                  ///////////////////////  PLUIE  ///////////////////////////
          case 1:
                  j = 15;
                  // on en deduit que c'est la pluie
                  grandeur = "C'est la pluie";


                  // boucle pour récupérer les mesures de la pluie
                  do
              {
               i++;
               dummy = fossil_getbyte_wait ( 0 );
             meteobuffer[i] = dummy;
               printf( "<%2x> ", meteobuffer[i] );  // On affiche l'octet recu
              }while (i < j);
                  printf( "\n Grandeur mesuree : %s\n\n", grandeur);


                  //////////////////////// 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 =7;
                  // on en deduit que c'est la temperature et l'hygrometrie
                  grandeur = " temperature et de l'hygrometrie";


                  // boucle pour récupérer les mesures
                  do
              {
               i++;
               dummy = fossil_getbyte_wait ( 0 );
             meteobuffer[i] = dummy;
               printf( "<%2x> ", meteobuffer[i] );  // On affiche l'octet recu
              }while (i < j);
                  printf( "\n On a la mesure de la%s\n\n", grandeur);


                  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 °C\n",signe,capteur_station.temp,capteur_station.temp2);


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


                  break;


                  default:
                  // on en deduit que c'est une grandeur que l'on ne traite pas
                  j = 0;
                  grandeur = "grandeur non geree, trame suivante";
                  printf( "\n Grandeur mesuree : %s\n\n", grandeur);
                  break;
           };  // fin switch case
         }// fin if recup ff une deuxieme fois
      } // fin if recup ff une premiere fois
      } // fin do-while general
      while(a==0);


}
/////////////////////////////////////////////////////////////////////////////////////INCLUDE FILE    METEO.H

//*****************************************************************************/
// Programme primsol climat, par Leny FRID, Avril 2008
//*****************************************************************************/
#ifndef _METEO_H_
#define _METEO_H_
/*****************************************************************************/
/*****************************************************************************/
/*
 * definitions Structure
 */
/*****************************************************************************/
struct capteurs_station_tag
{
   int vmoyvent;  // vitesse des rafales du vent
   int vrafvent;  // vitesse moyenne du vent
   int dvent;  // direction du vent exprimee en °C
 int temp;   // temperature
   int temp2;   // temperature
   int signe;  // signe temperature
 int hygr;   // hygrometrie
 int pluv;   // pluviometrie
}capteur_station ;


#endif /* __METEO_H__ */

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ne pas oublier de bien parametrer le projet.

Plateform = "dos (standard)",
"no exceptions" pour les librairies,
cocher "class librairy" dans frameworks,
 "none" pour match support.

Puis dans les Options --> project, il faut sélectionner un processeur 80186, nécessaire pour l'R-TOS du dk51
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ne pas oublier aussi d'inclure le fichier CLIB2001.lib qui inclut direct tous les fichiers nécessaires (fossil.h, fossil.cpp, api etc...)

Profitez, ca marche !

Maintenant, je me concentre sur la communication avec le programme principal. Je vais utiliser les sockets.
SISKOZED
0
Réponse 9 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
5 mai 2008 à 11:09
Voici le programme sur la cible RTOS (carte sc13)
Il gère la communication par socket mais je suis en train de créer la trame à envoyer au client.





<hr />
#include "FOSSIL.H"
#include "CLIB.H"
#include "prims_srv.h"
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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 de la trame à n'importe quelle connection
 while(1)
 {
  if((CommServerSocket = accept(ListenServerSocket, (struct sockaddr *)&parametreCommSocket, &Erreur)) != 0)
  {
       printf("RETVAL ::::: %f ::::::",trame);
   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.vrafvent = (meteobuffer[5]&0xf0)>>4;
         capteur_station.vrafvent2 = (meteobuffer[6]&0x0f)*10+((meteobuffer[6]&0xf0)>>4)*100;
         capteur_station.vmoyvent = (meteobuffer[7]&0x0f)+( (meteobuffer[7]&0xf0)>>4)+(meteobuffer[8]&0x0f)*10;
         /////////////// Direction du vent exprimee en ° //////////////
         capteur_station.dvent = (meteobuffer[4]&0x0f)+((meteobuffer[4]&0xf0)>>4)*10
         +(meteobuffer[5]&0x0f)*100;


         printf( "Vitesse moyenne du vent : %i \nVitesse des rafales : %i\nDirection du vent : %i\n", capteur_station.vmoyvent, capteur_station.vrafvent,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/cm2\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 : %c %i,%id Degres Celsius\n",capteur_station.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)


strcpy (trame[0], trame[1]);
strcpy (vmoyvent, capteur_station.vmoyvent);
trame[1] = capteur_station.vrafvent;
trame[2] = capteur_station.vrafvent2 ;
trame[3] = capteur_station.dvent ;
trame[4] = capteur_station.temp ;
trame[5] = capteur_station.temp2 ;
trame[6] = capteur_station.signe ;
trame[7] = capteur_station.hygr ;
trame[8] = capteur_station.pluv ;


 


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


<hr />
Voici le .h





<hr />
#ifndef PRIMS_SRV_H
#define PRIMS_SRV_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 vmoyvent;  // vitesse des rafales du vent
   int vrafvent;  // vitesse moyenne 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][1000];;        // represente la trame que l'on va envoyer au client
   char* tramebuffer;


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


#endif





<hr />




SISKOZED
0
Réponse 10 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
20 mars 2009 à 13:59
Bonjour,

mon projet a l'air de concerner pas mal de personnes vu le nombre de mails que je recois, je partage donc mes fichiers avec quiconque le veut.
Voici mes dossiers de conception préliminaire et détaillé, de réalisation et d'intégration.
bon courage à tous
SISKOZED
0
Réponse 11 / 13
cs_siskozed Messages postés 11 Date d'inscription jeudi 25 janvier 2007 Statut Membre Dernière intervention 20 mars 2009
20 mars 2009 à 14:11
voici l'adresse du fichier téléchargable : http://www.gigaup.fr/?g=O31WIS4C5D
SISKOZED
0
Réponse 12 / 13
franciscohdz Messages postés 2 Date d'inscription vendredi 4 novembre 2011 Statut Membre Dernière intervention 8 novembre 2011
8 nov. 2011 à 15:09
0
Réponse 13 / 13
franciscohdz Messages postés 2 Date d'inscription vendredi 4 novembre 2011 Statut Membre Dernière intervention 8 novembre 2011
8 nov. 2011 à 15:16
bonjour je suis un étudiant a l'iut de saint-dié-des vosges je prépare ma licence professionnelle, et j'aurai besoin pour mon projet un programme sous borland C++ qui peut décoder la trame NMEA délivrer par un récepteur GPS fastrax up501, pour l'executer sur une carte DK50 (beck). Merci à vous d'avance
Amicalement, Francisco
0

Discussions similaires

connection avec une balance via rs 232
cs_mat1x -
Whismeril -

9 réponses
Protocole série rs232
cmoilastar -
za3za3 -

30 réponses
lecture de bits sur port RS232 (Rx) et ecriture reciproque sur Tx
bimaonethc -
panoramix591 -

7 réponses
Balance RS232
pitufo2804 -
cs_Jack -

7 réponses
Excel et RS232 ...
fouding69 -
julienexam -

6 réponses
Rejoignez-nous