Bonjour à tous,

J'ai réaliser un serveur qui enregistre ce que lui envoi le client puis écoute le port suivant. Je m'explique, j'ai 24 cartes en mode client possédant toute un module ethernet qui envoi leur données sur un port (entre 50001 et 50024). Le serveur écoute le port 50001 puis accepte la connexion, enregistre les données et enfin passe au port 50002 ... Jusqu'au port 50024 puis il revient au port 50001. Le processus est beaucoup trop long et j'aimerai utiliser le multithreading. Malheureusement, je n'y arrive pas.
Voici mon code de base :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
#pragma hdrstop
#include <condefs.h>
 
//---------------------------------------------------------------------------
#pragma argsused
#include <winsock2.h>                         // Librairie servant aux sockets
#pragma comment(lib, "ws2_32.lib")
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <iostream>
#include <string>
 
using namespace std;
 
int main()
{
    FreeConsole();                                            // Permet de cacher la console pendant l'execution du programme
    SOCKET val;                                               // Prend la valeur du retour du accept()
    char buff[70];                                            // Tableau où l'on va enregistrer ce qu'on reçoit
    int num_sondes_micro;                                     // Variable où l'on va enregistrer la correspondance entre les lettres et les sondes(voir abcd[][] dans pilotes.cpp)
                                                              // Exemple : A => 0, B => 1 , ...
    int tab_lue[12*12*10] = {0};                                    // Tableau où on enregistre les valeurs des sondes
   // int tab_lue[10] = {0};
    int valeur_sonde;                                         // Où l'on met la valeur de la sonde que l'on vient de lire
    string valeur_sonde_str;
    int compt = 0;
    int p;
    string lignetxt, contenu;
    int j = 0;
    int numero_port_micro = 50001;
    int var_pont = 0;                                         // Variable que l'on va ajouter à num_sonde_micro pour chaque changement de pont (pour positionner les valeurs dans le tableau)
 
    while(1)
    {
 
    WSADATA WSAData;                                          // Utilisée pour le démarrage de WSAStartup()
    WSAStartup(MAKEWORD(2,0), &WSAData);                      // Pour prévenir l'ordinateur que nous allon utiliser des sockets
 
 
    SOCKET sock;                                              // Variable pour définir le socket
    SOCKADDR_IN sin;                                          // La struct du SOCKADDR contient les informations techniques du socket
    sin.sin_addr.s_addr = htonl(INADDR_ANY);                  // Définie l'adresse serveur, si on code pour un client, sin.sin_addr.s_addr = inet_addr("127.0.0.1");
    sin.sin_family		= AF_INET;                    // Définie le type de socket, AF_INET pour internet
    sin.sin_port		= htons(numero_port_micro);   // Définie le port où le serveur est en écoute
    sock = socket(AF_INET,SOCK_STREAM,0);                     // Création du socket
    bind(sock, (SOCKADDR *)&sin, sizeof(sin));                // Attache le socket au port et à l'adresse définie plus haut
 
    listen(sock, SOMAXCONN);                                  // On écoute le port sur le socket
 
        int sizeof_sin = sizeof(sin);                         // calcule la taille de sin
        val = accept(sock, (SOCKADDR *)&sin, &sizeof_sin);    // Permet d'accepter la connexion
        if(val != INVALID_SOCKET)                             // Si on nous retourne autre chose que INVALID_SOCKET
        {
                // Fonctions à éxécuter sur le socket.
               recv(val, buff, sizeof(buff), 0);              // On reçoit les valeurs du module EZL et on les place dans buff
 
 
                ofstream fichier("test_micro.txt", ios::out | ios::binary);  // ouverture en écriture avec effacement du fichier ouvert
 
        if(fichier)                            // Si le fichier s'ouvre
        {
                for(int i = 0; i<70; i++){     // pour i allant de 0 à 70,
                       if((buff[i] == ';')||(buff[i] == ' ')||(buff[i] == '0')||(buff[i] == '1')||(buff[i] == '2')||(buff[i] == '3')||(buff[i] == '4')||(buff[i] == '5')||(buff[i] == '6')||(buff[i] == '7')||(buff[i] == '8')||(buff[i] == '9')||(buff[i] == 'A')||(buff[i] == 'B')||(buff[i] == 'C')||(buff[i] == 'D')||(buff[i] == 'E')||(buff[i] == 'F')||(buff[i] == 'G')||(buff[i] == 'H')||(buff[i] == 'I')||(buff[i] == 'J')){
                               fichier << buff[i];                     // On enregistre le caractère lu dans le fichier texte
                       }
 
                }   //fin for
                fichier.close();
       }     // fin if(fichier)
       else{
                cerr << "Impossible d'ouvrir le fichier !" << endl;
                return 0;
       }   // fin else
 
 
 
//***********à cette étape, nous avons enregistrer les caractères dans le fichier txt**************//
/**Maintenant, il faut le parcourir pour faire correspondre les lettres et les valeurs aux sondes**/
 
         ifstream fichier2("test_micro.txt", ios::in);                               // on ouvre en lecture
         if(fichier2){                                                               // si l'ouverture a fonctionnée
 
                while (!fichier2.eof()){                                             // eof est le flag de fin de fichier il se met a 1 quand on a atteint la fin du fichier.
                 getline(fichier2,lignetxt);                                         // On recupere une ligne du fichier sous la forme d'un string
                  for(j; j < 70/*lignetxt.length()*/; j++) {                         // ligne[j] renvoie le caractère placer a la j ème position; allant jusqu'à 80 pour avoir les 10 valeurs
 
                        switch(lignetxt[j]){                                         // On fait la correspondance entre les lettres et les sondes (voir abcd[][] colonne n dans pilotes.cpp)
                                case 'A':                        // S1
                                        num_sondes_micro = 0;
                                        compt++;
                                        break;
                                case 'B':                        // S2
                                        num_sondes_micro = 1;
                                        compt++;
                                        break;
                                case 'C':                        // S3
                                        num_sondes_micro = 2;
                                        compt++;
                                        break;
                                case 'D':                        // S4
                                        num_sondes_micro = 4;
                                        compt++;
                                        break;
                                case 'E':                        // S5
                                        num_sondes_micro = 5;
                                        compt++;
                                        break;
                                case 'F':                        // S6
                                        num_sondes_micro = 6;
                                        compt++;
                                        break;
                                case 'G':                        // HG
                                        num_sondes_micro = 3;
                                        compt++;
                                        break;
                                case 'H':                        // HD
                                        num_sondes_micro = 7;
                                        compt++;
                                        break;
                                case 'I':                        // TG
                                        num_sondes_micro = 8;
                                        compt++;
                                        break;
                                case 'J':                        // TD
                                        num_sondes_micro = 9;
                                        compt++;
                                        break;
                                /*case ' ':
                                        buff[i] = '0';
                                        break; */
                                defaut:
 
                        }   //fin switch
 
                  if(compt == 1){
                        p = j + 1;
                        valeur_sonde_str = lignetxt.substr(p,9);
                        valeur_sonde = atoi(valeur_sonde_str.c_str());           // Conversion string -> int
                        compt = 0;
                        j += 6;
                        tab_lue[num_sondes_micro + var_pont] = valeur_sonde;         // On enregistre la valeur de la sonde dans tab_lue suivant la sonde
                  }
 
 
                  }   //fin for
                }   // fin while
 
                fichier2.close();
                j = 0;
                numero_port_micro++;
                var_pont += 10;                 // On incrémente de 10 car il y a 10 valeurs à placer dans le tableau
                if(var_pont >= 239){              // Si on est au pont n°24, on repasse au 1
                     var_pont = 0;
                }
 
         }    // fin if(fichier2)
         else{
                cerr << "Impossible d'ouvrir le fichier !" << endl;
                return 0;
         }   // fin else
    }  // fin if(val != INVALID_SOCKET)
 
 
 
    closesocket(sock);      // Ferme le socket sock
    closesocket(val);       // Ferme le socket val
    WSACleanup();           // Met fin à l'utilisation de la DLL Winsock 2
   // return 0;
 }    // fin while
} // fin main()
Je suis sous C++ builder 4

Merci !