1. retval = send (sd, sendbuf, strlen (sendbuf), 0, &error);

/******************************************************************************
*                                 Inclusion fichiers header
******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <clib.h>
#include <dos.h>
#include "I2C_API.H"
#include <conio.h>
 
 
/******************************************************************************/
/*                             Declaration des constantes                            */
/*******************************************************************************/
 
 
#define TM_PORT_ECHO                    5100    /* PORT utilisé pour connection*/
#define TM_CLIENTPORT_ECHO              5100   /* PORT utilisé pour connection*/
#define TM_TCPECHOBUF_CLIENT_SENDSIZE    83    /*Longueur maximale requête d'envoie */
#define TM_TCPECHOBUF_CLIENT_RECVSIZE    100   /*Longueur maximale resultat requête en retour*/
#define I2CINT     0xAA
#define TCP_ECHO_CLIENT_DEBUG
#define PRINT_DATA
 
/******************************************************************************/
/*                             Declaration variables globales                        */
/******************************************************************************/
char sendbuf[TM_TCPECHOBUF_CLIENT_SENDSIZE ]="select Produit,PrixVente,Rayon from PrixSouhaite where CodeBarre IN ('123456789')\r"; /*buffer d'envoie*/
char recvbuf[TM_TCPECHOBUF_CLIENT_RECVSIZE ];   /*buffer de reception*/
 
char destIPStr[17];
unsigned long destIPAddr;
char resultsql[100];    //chaine de caractère qui contiendra le resultat de la requête SQL
                                // il fera la jonction entre les fonctions socket et affichage
 
 
/******************************************************************************/
/*                          Fonction socket()                                 */
/******************************************************************************/
 
void socket()
{
   struct sockaddr_in   addr;
 
   int sd;
   int i;
   int error;
   int retval;
   int j=1;
   BIOS_Set_Focus(FOCUS_APPLICATION);
 
   strcpy(destIPStr,"192.168.0.33" );
 
   printf("\r\nClient:  Dest. IP: %s ,  Port %d\r\n",destIPStr,TM_PORT_ECHO);
   #ifdef TCP_ECHO_CLIENT_DEBUG
   printf("\r\nOuverture socket...\n" );
   #endif
   //API call open socket
   retval = opensocket( SOCK_STREAM, &error );
 
   if(retval == API_ERROR)  /*boucle d'erreur de connection*/
   {
      printf("\r\nOuverture socket echoue: %d", error);
      goto TCP_CLIENT_DONE;
   }
   else
   {
      sd = retval;
   }
 
 
   /**********************************************************************/
   //Connection à l'API, établie la connection au serveur TCP            */
   /**********************************************************************/
   // convertie le port du serveur dans le bon ordre de byte
   addr.sin_family =  PF_INET;
   retval = htons( TM_PORT_ECHO );
   addr.sin_port =  retval;
   //Convertion de l'addresse IP en chaine de charactère
   retval = inet_addr( (char *)destIPStr, &destIPAddr );
 
   if(retval == API_ERROR)
   {
      goto TCP_CLIENT_DONE;
   }
   else
   {
     addr.sin_addr.s_addr =  destIPAddr;
   }
 
   //appel de la fonction connection
   retval = connect( sd, (const struct sockaddr *)&addr, &error );
 
   if(retval == API_ERROR)  /*boucle d'erreur connection socket */
   {
     if(error==261)  //connection refused from server host
     {
      printf("\r\nConnection refusee depuis %s",destIPStr);
     }
     else
     {
        printf("\r\nConnection socket échouee: %d",error);
     }
      goto TCP_CLIENT_DONE;
   }
 
   printf("\r\nConnecte avec %s\r\n",destIPStr);
 
   while(j=1)   //loop forever
   {
         /**************************************************************/
         /*         Envoie des données sur le serveur                  */
         /**************************************************************/
 
       //send
        retval = send( sd,sendbuf, strlen (sendbuf), 0, &error);
 
        if(retval == API_ERROR)
        {
            #ifdef TCP_ECHO_CLIENT_DEBUG
             printf("\r\nTCPClient: Senderror %d",error);
            #endif
          goto TCP_CLIENT_DONE;
 
       }
 
       #ifdef PRINT_DATA
         printf("\r\nTCPClient:\r\nSending :\r\n" );
         for(i=0;i<strlen (sendbuf);i++)
         {
             printf("%c",(char)sendbuf[i]);
 
         }
       #endif
 
         /*****************************************************************/
         /*                   Attente de 1 seconde                        */
         /*****************************************************************/
       api_sleep(100);
 
 
         /*******************************************************************/
         /* Attend la reponse du serveur et appel la fonction de reception  */
       /*******************************************************************/
       
         do
         {
 
               //recv
             retval = recv( sd, recvbuf,TM_TCPECHOBUF_CLIENT_RECVSIZE,
                            MSG_TIMEOUT, 10000L, &error );
 
               if(retval == API_ERROR)
               {
                  #ifdef TCP_ECHO_CLIENT_DEBUG
                   printf("\r\nTCPclient: Recverror %d",error);
                  #endif
             
               }
               else
               {
                  if( retval > 0)    //data received
                  {
                #ifdef PRINT_DATA
                       printf("\r\nTCPClient\r\nReceived:\r\n" );
                      for(i=0;i<retval;i++)
                        {
                          printf("%c",(char)recvbuf[i]);
                      resultsql[i]=recvbuf[i];
                        }//for(i=0;i<outregs.x.ax;i++)
                #endif
              }
              else
              {
                #ifdef TCP_ECHO_CLIENT_DEBUG
                    printf("\r\nTCPclient: Nothing received" );
                    #endif
              }
              }//elseif(retval == API_ERROR)
              /*****************************************************************/
              //Check, if there is more data available at the socket ?
              /*****************************************************************/
                retval = GetWaitingBytes( sd, &error );
 
       api_sleep(100);
 
      }//Tant que des données sont disponibles
 
       while((retval != API_ERROR && retval > 0) );
 
   }//while(1)   //BOUCLE INFINIE
 
   /*************************************************************/
   /* La fermeture de la connection ne devrait pas avoir lieu,  */
   /* si il s'est bien connecté                                 */
   /*************************************************************/
 
 
TCP_CLIENT_DONE:
   //close socket
   printf("\r\nConnection fermee \r\n" );
   retval = closesocket( sd, &error );
 
   #ifdef TCP_ECHO_CLIENT_DEBUG
   if(retval==API_ERROR)
   {
       printf("\r\nFermeture socket échouee: %d",error);
   }
   #endif
 
}
 
 
/******************************************************************************/
/* Declarations de fonctions pour fonction affichage()                        */
/* Fonction i2C_init (void) -> initialise le bus I2C                          */
/* Fonction I2C_scan -> scan le bus I2C à la recherche des @ des composants   */
/******************************************************************************/
 
void I2C_init (void)     /*initialisation bus i2c+ fixation DATA et CLOCK sur PIN1 et PIN0*/
{
  union  REGS  inregs;      //registre servant à passer les parametres NOYAU>APP
  union  REGS  outregs;     //registre servant à passer les parametres APP>NOYAU
 
 
  inregs.h.ah = 0x80;
 
  int86(I2CINT,&inregs,&outregs);
 
}
 
unsigned char I2C_scan (unsigned char start_addr, unsigned char end_addr)
{
 union  REGS  inregs;     //registre servant à passer les parametres APP>NOYAU
 union  REGS  outregs;    //registre servant à passer les parametres NOYAU>APP
 
 
 inregs.h.ah = 0x81;                  // scan des péripheriques en sortie
 inregs.h.al = start_addr;            // du bus i2c et retour  de l'adresse
 inregs.h.cl = end_addr;              // dans une variable
 int86(I2CINT,&inregs,&outregs);
 
 return outregs.h.al;
 
}
 
  int I2C_transmit_block (unsigned char slave,const char far * buffer, int length)
{
     union  REGS  inregs;                  // Transmission d'un bloc de donnée
     union  REGS  outregs;                 //contenue dans le buffer a l'adresse trouvé
     struct SREGS sregs;                   //pendant le scan. retourne charactere a si
                                       //le message est bien transmis
     inregs.h.ah = 0x83;
     inregs.h.al = slave & 0xFE;
     inregs.x.cx = length;
     sregs.es    = FP_SEG(buffer);
     inregs.x.bx = FP_OFF(buffer);
     int86x(I2CINT,&inregs,&outregs,&sregs);
 
         if (outregs.x.flags & 0x01)
      {
           return outregs.h.al;
      }
    printf("le buffer est compose de  : %s\n",buffer);
 return 'a';
}
 
    int I2C_transmit_char (unsigned char slave, char c)
{
    union  REGS  inregs;    //registre servant à passer les parametres APP>NOYAU
     union  REGS  outregs;   //registres servant à recevoir les parametres NOYAU>APP
     inregs.h.ah = 0x82;      //n° du service
     inregs.h.al = slave & 0xFE;         //adresse de l’esclave I2C
     inregs.h.cl = c;             //valeur à ecrire
     int86(I2CINT,&inregs,&outregs); //n° IT et passage/récupération des paramètres
     if (outregs.x.flags & 0x01)
    {
        return (int)outregs.h.al & 0x00FF; //récuperation du code d’erreur éventuel
    }
    return c;
 
 }
 
 
/*******************************************************************/
/*                         Fonction affichage                                      */
/*******************************************************************/
 
void affichage (void)
 {
         char    *separateur = { "|" };     // Le séparateur
      char     *buffer;     //buffer qui contiendra le resultat de la requete
      char *pointeur;
         char z;
      int w=0,y,a,x;
      char *tabnom;     //tableau nom qui sera envoyé par i2C a l'afficheur
      char *tabprix;    //tableau prix qui sera envoyé par i2C a l'afficheur
      char *tabrayon;   //tableau rayon qui sera envoyé par i2C a l'afficheur
        unsigned char  clearscreen[1]={12};   //efface l'écran et place le curseur
      unsigned char  nom[9]={'A','R','T','I','C','L','E','=',' '};
      unsigned char  sautligne[1]={13};    //saut de ligne
      unsigned char  symbeuro[10]={27,128,135,136,158,144,158,136,135,128}; //construction symbole €
      unsigned char  appeleuro[1]={128};  //appel symbole euro de la case memoire 128
      unsigned char  prix[9]={'P','R','I','X',' ',' ',' ','=',' '};
      unsigned char  rayon[9]={'R','A','Y','O','N',' ',' ','=',' '};
        unsigned char  hidecursor[1]={4};  //cache le curseur
      buffer = strdup ( resultsql );
 
      /********************************************/
      /* Initialisation I2C                       */
      /********************************************/
 
      I2C_init();
 
        /********************************************/
      /* Scan bus I2C ->reception adresse esclave */
      /********************************************/
 
      z=I2C_scan(0x00,0xFF);
      printf("l'adresse slave est: %c\n",z);
 
      /*******************************************************************/
      /* Decomposition resultat requete en 3 éléments, nom,prix et rayon */
      /*******************************************************************/
 
      if (buffer !=NULL)
      {
             tabnom = strtok( buffer, separateur  );
         }
 
          if( buffer != NULL )
         {
             // Cherche les autres separateur
             tabprix = strtok( NULL, separateur  );
             tabrayon= strtok( NULL, separateur  );
         }
 
 
        printf("resultat boucle nom : %s\n",tabnom);
        printf("resultat boucle prix : %s\n",tabprix);
        printf("resultat boucle rayon : %s\n",tabrayon);
 
       /*******************************************************************/
       /* Envoie des données sur l'afficheur esclave par bus I2C          */
       /*******************************************************************/
 
      I2C_transmit_block (z,clearscreen,1);
      I2C_transmit_block (z,clearscreen,1);
      I2C_transmit_block (z,nom,9);
      I2C_transmit_block (z,tabnom,strlen(tabnom));
      I2C_transmit_block (z,sautligne,1);
      I2C_transmit_block (z,prix,9);
         I2C_transmit_block (z,tabprix,strlen(tabprix));
      I2C_transmit_block (z,symbeuro,10);
      I2C_transmit_block (z,appeleuro,1);
      I2C_transmit_block (z,sautligne,1);
         I2C_transmit_block (z,rayon,9);
      I2C_transmit_block (z,tabrayon,strlen(tabrayon));
      I2C_transmit_block (z,hidecursor,1);
 
 }
 
 
 
 
 /****************************************************************/
 /* Fonction main()                                              */
 /****************************************************************/
 
 int main(void)
 {
   printf("debut du programme" );
 
   while(1)  //boucle infinie -> mise a jour
   {
   socket();          //appel fonction socket
   api_sleep(100);    //temporisation pour bon retour de resultat de la requête
   affichage();       //appel fonction affichage
   api_sleep(10000);  //temporisation suivant temps entre mise a jour
   }
   printf("fin du programme" );  //ne doit pas apparaitre sauf erreur
   return 0;
 }