IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

Traiter en continue


Sujet :

Langage C++

  1. #1
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut Traiter en continue
    Bonjour,
    Je dois traiter en continue des trames sur port serie.
    Je simule cela avec hyperterminal en le mettant sur mon port 1.

    J'arrive à traiter une trame par une trame, en gros je dois relancer le programme à chaque fois !
    Mais je voudrais les traiter en continue, je mets 20 trames dans hyperterminal, je veux qu'il me traite les 20 trames en continue sans relancer le programme !

    Mon programme possède une classe WM918, pour les méthodes décapsulations et récupération de la trame et une autre pour traiter le port serie

    Je pense que cela est possible avec un thread mais je n'ai pas d'idée de comment traiter ce problème

  2. #2
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mars 2011
    Messages
    618
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2011
    Messages : 618
    Par défaut
    Salut,

    Avec ma boule de cristal, je vois que tu as une fonction qui traite une trame. Il suffit de faire un for(int i =0; i < 20; i++) pour traiter tes 20 frames...

    Plus sérieusement, il nous faudrait un peu plus de code

  3. #3
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    Exact je vais poster en virant les parties qui se ressemblent.


    Ma classe pour afficher mes résultats dans mon IHM

    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
    //---------------------------------------------------------------------------
    __fastcall TAnalyse_Trames::TAnalyse_Trames(TComponent* Owner)
            : TForm(Owner)
    {
            bool TrameRecue=false;
            WM918 Station("com1:", "4800,n,8,1");
            float MesureTempV=0;
            int MesureTempE=0;
            double MesureDirVent;
     
            //Réception d'une trame
            TrameRecue=Station.RecupData();
     
            if(TrameRecue==true)
                    Station.DecapsuleTrame();
     
            MesureTempV =Station.LitTempVent(1);
            TemperatureVent->Text=MesureTempV;
     
            MesureTempE=Station.LitTempEau(1);
            TemperatureEau->Text=MesureTempE;
    }
    Ma classe pour traiter les trames
    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
    //Constructeur
    WM918::WM918(String NPort,String Conf)
    {
            TemperatureVent=0;
            TemperatureEau=0;
     
            //initialisation des attributs de la classe WM918
            NomPort=NPort;
            Config=Conf;
     
            NbTypeTraite=0; // reinitialisation avant une nouvelle analyse
     
            //instanciation d'un objet RS232
            LNavylec = new RS232(NomPort, Config);
    }
    //---------------------------------------------------------------------------
     
    //Destructeur
    WM918::~WM918()
    {
            delete LNavylec;
    }
    //---------------------------------------------------------------------------
     
    int WM918::MesuresTraitees()
    {
            return NbTypeTraite;
    }
    //---------------------------------------------------------------------------
     
    bool WM918::RecupData()
    {
            bool RecupOk=false;
            const int TAILLETRAME=14;
            DWORD NbCar=0;
     
            AnsiString Trame="";
     
            TrameBrute="";
            Compteur=0;
     
            LNavylec->OuvrirPort(Erreur);
     
            while(LNavylec->ReadBuffer(Trame,Erreur))
            {
                    NbCar = Trame.Length();
     
                    if(NbCar>0)
                    {
                            RecupOk=true;
                            Compteur=Compteur+NbCar;
                            TrameBrute=TrameBrute+Trame;
                    }
     
                    if(Compteur>=TAILLETRAME)
                    {
                            LNavylec->FermerPort(Erreur);
                            return RecupOk;
                    }
            }
     
            return RecupOk;
    }
    //---------------------------------------------------------------------------
     
    bool WM918::DecapsuleTrame()
    {
            bool            OperationTerminee=false;
     
            int             PositionInitiale=0,
                            PositionCourante=0;
     
            String          Inter="",
                            TempVentBrute="",
                            TemperatureEauBrute="";
            int             TEau=0;
            float           TempV=0;
     
     
            PositionInitiale=TrameBrute.Pos("$");
            PositionCourante=PositionInitiale+4;
            Inter=TrameBrute[PositionCourante];
     
            //TRAME TEMPERATURE DE L'AIR EXTERIEUR - girouette2
            if(Compteur==18& Inter=="D")
            {
                    TempVentBrute=TrameBrute.SubString((PositionCourante+5),5);
                    TempV=DecapsuleTemperatureVent(TempVentBrute);
                    TemperatureVent=TempV;
            }
     
     
            //TRAME TEMPERATURE DE L'EAU - bateau2
            if(Inter=="T")
            {
                    //if(Compteur==14)
            TemperatureEauBrute=TrameBrute.SubString((PositionCourante+3),2);
                    TEau=DecapsuleTemperatureEau(TemperatureEauBrute);
                    TemperatureEau=TEau;
     
            }
     
            OperationTerminee=true;
     
            return OperationTerminee;
    }
    //---------------------------------------------------------------------------
     
    float WM918::DecapsuleTemperatureVent(String TempVentBrute)
    {
            char    Negatif;
            int     Diz,
                    Uni,
                    Dixi;
            float   Resultat;
     
            Negatif=(TempVentBrute[1]  & 0xff);
            Diz=(TempVentBrute[2] & 0x0f);
            Uni=(TempVentBrute[3] & 0x0f);
            Dixi=(TempVentBrute[5] & 0x0f);
     
            if(Negatif==45)
                    Resultat=-((Diz*10)+Uni+(Dixi*0.1));
            else
                    Resultat=(Diz*10)+Uni+(Dixi*0.1);
     
            return Resultat;
    }
    //---------------------------------------------------------------------------
     
    int WM918::DecapsuleTemperatureEau(String TemperatureEauBrute)
    {
            char    Negatif;
            int     Diz,
                    Uni;
            int     Resultat;
     
            Negatif=(TemperatureEauBrute[1] & 0xff);
            Uni=(TemperatureEauBrute[2] & 0x0f);
     
            if(Negatif!=45)
            {
                    Diz=(TemperatureEauBrute[1] & 0x0f);
                    Resultat = (Diz*10)+Uni;
            }
            else
                    Resultat = -Uni;
     
            return Resultat;
    }
    //---------------------------------------------------------------------------
     
    float WM918::LitTempVent(float MesureTempV)
    {
            float Res;
            Res = TemperatureVent;
            return Res;
    }
    //---------------------------------------------------------------------------
     
    int WM918::LitTempEau(int MesureTempE)
    {
            int Resultat;
            Resultat = TemperatureEau;
            return Resultat;
    }

    Il reste la trame qui s'occupe du port serie !

    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
    //Constructeur
     
    RS232::RS232()
    {
            NomPort="Com1";
            ConfigPort="4800,N,8,1";
            EtatLigne= Fermee;
    }
     
    RS232::RS232(AnsiString NPort)
    {
            NomPort=NPort;
            ConfigPort="4800,N,8,1";
            EtatLigne= Fermee;
    }
     
    RS232::RS232(AnsiString NPort,AnsiString CPort)
    {
            NomPort=NPort;
            ConfigPort=CPort;
            EtatLigne= Fermee;
    }
    RS232::~RS232()
    {
    }
     
    bool RS232::OuvrirPort(DWORD &ErreurLigne)
    {
            bool PortOpenned=false;
            if(EtatLigne!=Ouverte)
            {
                    Com=CreateFile(NomPort.c_str(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
                    BuildCommDCB (ConfigPort.c_str(),&ParamPort);
                    SetCommState(Com,&ParamPort);
                    if(Com !=INVALID_HANDLE_VALUE)
                    {
                            EtatLigne=Ouverte;
                            PortOpenned = true;
                    }
                    else
                    {
                            ErreurLigne=GetLastError();
                            PortOpenned=false;
                    }
            }
            return PortOpenned;
    }
     
    bool RS232::FermerPort(DWORD &ErreurLigne)
    {
            bool test=false;
            if(EtatLigne==Ouverte)
            {
                    test = CloseHandle(Com);
                    ErreurLigne=GetLastError();
                    EtatLigne=Fermee;
            }
            return test;
    }
     
    bool RS232::ReadBuffer(AnsiString &Buf ,DWORD &ErreurLigne )
    {
            bool BufReaded = false;
            char c;
            int i;
            DWORD NbrCar;
            if(EtatLigne==Ouverte)
            {
                    ClearCommError(Com, &ErreurLigne, &StatutPort);
                    i = StatutPort.cbInQue;
                    while(i!=0)
                    {
                            BufReaded = ReadFile(Com, &c, 1, &NbrCar, NULL);
                            Buf = Buf + c;
                            i--;
                    }
            }
            return NbrCar;
    }
     
    bool RS232::ReadChar(char &Carac ,DWORD &ErreurLigne )
    {
            bool ReadCh=false;
            char c=Carac;
            AnsiString Buf;
            int i;
            DWORD NbrCar;
            if(EtatLigne==Ouverte)
            {
                    ClearCommError(Com, &ErreurLigne, &StatutPort);
                    i = StatutPort.cbInQue;
                    while(i!=0)
                    {
                            ReadCh = ReadFile(Com, &c, 1, &NbrCar, NULL);
                            Buf = Buf + c;
                            i--;
                    }
            }
            return ReadCh;
    }
     
    bool RS232::SendString(AnsiString &chaine,DWORD &ErreurLigne)
    {
            bool SendSt=false;
            AnsiString ch=chaine;
            unsigned long NbrCarWrite;
            if(EtatLigne==Ouverte)
            {
                    SendSt = WriteFile( Com, ch.c_str(), ch.Length(), &NbrCarWrite, NULL );
            }
            return SendSt;
    }
     
    bool RS232::SetConfig(AnsiString config)
    {
            bool test=false;
            if(Com != INVALID_HANDLE_VALUE)
            {
                    ConfigPort=config;
                    test=true;
            }
            return test;
    }
     
    bool RS232::SetCom(AnsiString NPort)
    {
            bool test=false;
            if(Com != INVALID_HANDLE_VALUE)
            {
                    NomPort=NPort;
                    test=true;
            }
            return test;
    }

    je vois pas comment utiliser un thread, quand j'en place un à chaque fois le programme plante ou ne prend pas en compte les nouvelles trames

  4. #4
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    Tu dois juste avoir un thread qui tourne en boucle et qui récupère les trames :
    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
    MaTrame trame;
    int iTimeout = 100;// temps d'attente entre chaque tentative
    while( ! bEnded )
    {
    	if( RecevoirUneTrame( & trame ) )
    	{
    		// ici on a reçu une trame
    		TraiterTrame( & trame );
    	}
    	else
    	{
    		//RAF
    	}
    	Sleep( iTimeout );//Pour laisser la main
    }
    Ton thread possède bien entendu le contexte de connexion.

    [EDIT]
    Avec le code de ton main j'aurais certainement écrit un code plus proche du tien
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  5. #5
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    déjà merci

    j'avais tenter un truc comme ça (moins élaboré)

    au niveau de ce passage
    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
    while(LNavylec->ReadBuffer(Trame,Erreur))
            {
                    NbCar = Trame.Length();
     
                    if(NbCar>0)
                    {
                            RecupOk=true;
                            Compteur=Compteur+NbCar;
                            TrameBrute=TrameBrute+Trame;
                    }
     
                    if(Compteur>=TAILLETRAME)
                    {
                            LNavylec->FermerPort(Erreur);
                            return RecupOk;
                    }
            }
    Mais étant donné que je lance mon programme en mode pas à pas pour coller ma trame dans hyperterminal quand j'arrive à ce passage
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    while(LNavylec->ReadBuffer(Trame,Erreur))
    cela ne donne rien de bien concluant

    toi tu placerais ton code dans la partie IHM ?

  6. #6
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    ton ReadBuffer ne doit pas être la condition d'arrêt (je suppose que cette fonction retourne le nombre d'octets lus).
    En fait le bEnded que j'ai utilisé doit être mis à true à un autre endroit de ton appli, par exemple quand tu dois la fermer tu mets bEnded à true et tu attends la fin de ton thread avant de quitter l'appli
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  7. #7
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    Je vois pas comment mettre en pause pour que la trame soit prise en compte

    si je colle pas la trame dans hyperterminal au bon moment rien ne fonctionne

    c'est peut-être tout con mais j'ai pas d'idée

  8. #8
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    Tu n'as normalement pas à mettre en pause.
    Pour lire en continu, il faut que tu scrutes continuellement si des données arrivent.
    Donc ton thread tourne en boucle en essayant à chaque tour de boucle de lire ce qu'il peut y avoir dans le buffer de comm.
    S'il n'y a rien (ReadBuffer qui renvoie 0 ou qqchose dans le genre), il n'y a aucun traitement à effectuer, on Sleep pour laisser la main pendant un temps (et ne pas surcharger le processeur inutilement) puis on recommence.
    donc dans ta boucle tu ne dois pas avoir de return sinon tu termines ton thread et ensuite tu ne pourras plus rien lire.
    Tout ton traitement doit donc être fait dans le thread.
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  9. #9
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    Je vois pas comment faire aussi

  10. #10
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    Je pensais avoir été clair ...

    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
    MaTrame Trame;
    int iTimeout = 100;// temps d'attente entre chaque tentative
    bool bEnded = false;
    int iNbRead;
    int iNbTotal = 0;
    // Il faut scruter en boucle
    while( ! bEnded )
    {
    	// Un tour de boucle : 
    	LNavylec->ReadBuffer( Trame, Erreur );// On scrute l'arrivée de données
    	iNbRead = Trame.Length();// On regarde si on a reçu des données
     
    	if( iNbRead > 0 )
    	{
    		// Des données sont arrivées, on les ajoute au buffer courant
    		iNbTotal += iNbRead;
    		TrameBrute=TrameBrute+Trame;// L'a pô compris cette ligne (ajout au buffer courant ? Où est défini l'opérateur '+' sur une trame ?)
    	}
     
    	if( iNbTotal >= TAILLETRAME )
    	{
    		// On a enfin reçu une trame complète (je suppose ?), on la traite
    		// On retire la taille de la trame au décompte total
    		iNbTotal -= TAILLEFRAME;
    		// TODO : Retirer les données du buffer courant
    	}
     
    	Sleep( iTimeout );
    }
     
    LNavylec->FermerPort(Erreur);
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  11. #11
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    J'avais testé un truc du genre sans le sleep et j'ai le meme résultat en faites je ne sors jamais de la boucle donc il traite pas la trame qu'il a reçu
    si j’agrandis tout plante

    au début j'avais tenté de mettre le return dans la boucle mais au final la boucle ne sert à rien

  12. #12
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    Le traitement de la trame peut être fait de plusieurs façons.
    1 - Tu peux faire le traitement dans le thread de réception (dans le if( iNbTotal >= TAILLETRAME ))
    2 - Tu peux faire le traitement dans un thread à part (par exemple dans le thread principal de ton application) en faisant bien attention de protéger ta trame avec au moins des sections critiques pour les accès concurrents entre threads, ou en gérant une pile de trames reçues (pile qui sera protégée contre les accès concurrents, évidemment)
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  13. #13
    Membre actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    52
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 52
    Par défaut
    merci pour cette réponse très rapide

    1/ ça va faire une méga grosse fonction et ça me retire une fonction de faire ça, ça fait pas bourrin ?
    2/ Le problème c'est que comment faire pour mettre un thread à part si je ne sors pas de la boucle

  14. #14
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    Euh ... Normalement la boucle est dans un thread à part (qui ne fait que ce traitement).

    1 - Effectivement ça fait une grosse fonction qui fait tout, je ne ferais pas comme ça.
    2 - Il suffit que ton thread de traitement connaisse ait connaissance soit de la pile de trames (via un pointeur, par exemple, je suis pas fan), soit de la classe gérant cette pile (je préfère, permet de protéger la pile via les accesseurs)
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

Discussions similaires

  1. Un langage pour lire, traiter et écrire de gros fichiers
    Par March' dans le forum Langages de programmation
    Réponses: 19
    Dernier message: 07/04/2003, 15h26
  2. L'instruction continue ?
    Par Patrick PETIT dans le forum C
    Réponses: 11
    Dernier message: 10/03/2003, 08h05
  3. Traiter les caractères spéciaux
    Par ricola dans le forum Langage
    Réponses: 2
    Dernier message: 20/02/2003, 09h23
  4. [VB6] attendre un événement pour continuer l'exécution
    Par Argonz dans le forum VB 6 et antérieur
    Réponses: 21
    Dernier message: 12/11/2002, 13h08
  5. [langage] Continuer a parser une ligne
    Par D[r]eadLock dans le forum Langage
    Réponses: 5
    Dernier message: 30/09/2002, 18h49

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo