Discussion :

[L-F-an]

Bonjour à tous,

Encore une problématique sur le port série...
J'utilise le port série pour communiquer avec une machine industrielle. Pour cela je me sers évidement de la librairie QextSerialPort.
Mon port s'ouvre et est bien configuré, j'arrive à faire marcher l'appli en émission et réceptions de données.

Cependant j'ai un petit (gros?) problème...

Pour le dialogue avec un équipement particulier, mon appli doit vérifier la présence d'un caractère dans les trames reçues et lui en renvoyer un autre afin d'avoir en permanence la certitude que le dialogue est établit. (A la manière d'une poignée de main en réseau)

C'est ici que les choses se gâtent!
Je réceptionne bien la trame envoyée par l'équipement et je détecte le caractère qui nécessite un acquittement.

Lorsqu'il est détecté je fais un write() sur le port série pour envoyer le caractère d'acquittement. Pourtant ce caractère ne part pas tout de suite.

L'équipement me renvoie une demande d'acquittement, puis deux... Puis coupe le dialogue.
A ce moment, mon appli répond avec les 3 acquittements demandés quelques secondes plus tôt.

J'ai donc plusieurs questions:

1. La librairie QextSerialPort permet elle un full-duplex total? (D'après ce que j'avais lu, oui, mais bon ne sait-on jamais...)

2. La fonction write() héritant de QIOdevice est-elle instantanée?

3. Je sais que le port série a un buffer intégré qui se vide après un certain temps ou un certain remplissage, savez-vous ou l'on pourrait régler ce paramètre?

4. Vous avez d'autres idées ?

Je viens demander votre aide parce que je ne sais pas si je dois chercher du côté de la librairie QextSerialPort ou modifier mon code (je préférerais nettement la deuxième solution pour être honnête)

Merci d'avance...

[Gulish]

Je ne connais pas la lib QextSerialPort, mais n'y a t'il pas une méthode de flush ? Dans un peu près tous les drivers d'interfaces réseaux où il y a un buffer d'écriture, tu as ce genre de commande pour forcer l'écriture du buffer sur le support.

Donc s'il y a une fonction de ce type, essaie de l'appeler juste après ton write.

G.

[L-F-an]

En fait, la lib QExtSerialPort dérive que QIODevice.
Donc effectivement elle possède une méthode de flush.
J'ai bien essayé de le placer après mon write pour forcer l'écriture, mais les trames arrivent toujours après.
J'ai très peur que la lib ne soit pas full-duplex

[Sopalinou]

En effet j'ai peur que la communication ne soit pas full duplex (sans certitude), sinon est-il possible de revoir ton code pour implémenter une communication en half-duplex ?

[L-F-an]

Non j'ai vraiment besoin d'une communication full.
Le signal ReadyRead() serait-il défectueux?
Dans ce cas il faudrait que je mette quelques QTimer un peu partout dans mon code ce que je redoute totalement

[keltharak]

En effet cela risque de compliquer ton code si tu n'es pas à l'aise avec les Qtimers

[dourouc05]

Il faut aussi remarquer ce post : http://www.developpez.net/forums/d0-m5367987/a/a/. Il existe une autre bibliothèque, QSerialDevice, pour cela, encore maintenue et plus orientée Qt.

[haraelendil]

Oui et avec celle la il y a un vrai signal readyRead qui marche.

[L-F-an]

D'accord, merci pour l'info sur cette librairie j'avoue que j'en ignorais l'existence.
Je vais peut-être m'orienter vers celle-ci.
Cependant, qu'est-ce qui me garantie qu'elle est full-duplex?

Car QextSerialPort fonctionne, ses signaux aussi.
C'est juste que je n'arrive pas à établir un dialogue qui répond de manière instantanée.
J'ai impression que mon automate occupe le port et ne laisse pas répondre.

Pourtant un port série a une broche d'émission, et une broche de réception.
Donc le full ne devrait pas poser de problème. (Toujours selon moi...)

Pour info, la dernière version de QExtSerialPort a été trouvée ici : http://code.google.com/p/qextserialport/
et date de 2009 il me semble.

[L-F-an]

Je crois avoir mis le doigt dessus.
Dans la librairie, la fonction write et la fonction read gèrent un mutex.
Forcément pendant l'écriture on bloque le mutex et on le débloque à la fin, idem pour la lecture.
Je pense que cette utilisation est normale mais croyez vous dans ce cas que mon automate ne rende pas la communication?
Et dans ce cas si vous aviez une astuce pour le forcer à "lacher prise" ...

[L-F-an]

Pour les intéressés : Le test de la nouvelle librairie QSerialDevice est positif.
Les changements à faire sont minimes puisque QExtSerialPort et QSerialDevice sont basées toutes deux sur IODevice.
Elle est régulièrement maintenue et je vérifierai très prochainement si elle est parfaitement multi-plateformes.
C'est donc une librairie externe très intéressante !

Par contre pour mon soucis de full-duplex, toujours dans le noir.
J'ai changé la librairie (De QExtSP à QSD) et récemment mis en place deux threads : un pour la réception et un pour l'émission.
Mais je n'arrive toujours pas à écrire sur le port pendant ma réception. J'ai le même problème.

Mais maintenant je n'ai plus d'idée

[Gulish]

Es tu sûr que le problème soit dû à l'accès à ton port ? C'est peut être tes threads qui ne sont pas bien crées, et qui ne parallélisent en fait pas les opérations.

Le code de tes threads et de leur déclaration pourrait sans doute nous aider à t'aider .

G.

[L-F-an]

Merci pour ton soutien Gulish

J'ai donc une classe GestionPortSerie :

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
#include "GestionPortSerie.h"
 
GestionPortSerie::GestionPortSerie(QString Nom,AbstractSerial::BaudRate Bps,AbstractSerial::DataBits Nb_Bits_Donnees,AbstractSerial::StopBits Bits_Stop,AbstractSerial::Parity Parite,AbstractSerial::Flow Controle_Flux)
{
    //Récupération des informations en paramètres (récupérées précédement dans le XML)
    this->NomSerial = Nom;
    this->F_Bps = Bps;
    this->F_Nb_Bits_Donnees = Nb_Bits_Donnees;
    this->F_Bits_Stop = Bits_Stop;
    this->F_Parite = Parite;
    this->F_Controle_Flux = Controle_Flux;
    //Déclaration du nom du port en constante
    const QString NomPort = this->NomSerial;
 
    //Paramétrage du port série
    AbstractSerial *portSerie = new AbstractSerial();
    portSerie->setDeviceName(NomPort);
    portSerie->open(AbstractSerial::ReadWrite);
    portSerie->setFlowControl(Controle_Flux);
    portSerie->setParity(Parite);
    portSerie->setDataBits(Nb_Bits_Donnees);
    portSerie->setStopBits(Bits_Stop);
    portSerie->setBaudRate(Bps);
    portSerie->setCharIntervalTimeout(50);
 
    this->port = portSerie;
 
 
 
    //Initialisation et lancement des deux threads
    //Réception
      m_ThreadReception = new ThreadReception(port);
      m_ThreadReception->start();
 
 
    //Envoi
      m_ThreadEnvoi = new ThreadEnvoi(port);
      m_ThreadEnvoi->start();
 
 
 
}
 
GestionPortSerie::~GestionPortSerie()
{
    delete port;
}

Ma Classe de thread de réception :

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
 
ThreadReception::ThreadReception(AbstractSerial *addressSerialPort) : extSerialPort(addressSerialPort)
{
    stopped=false;
}
 
ThreadReception::~ThreadReception()
{
    if (isRunning())
    {
        stopReceiving();
        wait();
    }
}
 
void ThreadReception::stopReceiving()
{
    stopped = true;
}
 
void ThreadReception::run()
{
    int numBytes=0;
    char data[1024];
    QByteArray dataReceived;
 
    forever
    {
        if (stopped)
        {
            stopped = false;
            break;
        }
        numBytes = extSerialPort->bytesAvailable();
        if (numBytes > 0)
        {
 
            mutexReceive.lock();
 
            extSerialPort->read(data, numBytes);
            data[numBytes]='\0';
 
            dataReceived = data;
            qDebug()<<"Donnees dans le thread de reception: ";
            qDebug()<<data<<endl;
 
            mutexReceive.unlock();
 
            emit newDataReceived(dataReceived);
        }
    }
}

Ma classe de thread d'envoi :

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
 
ThreadEnvoi::ThreadEnvoi(AbstractSerial *addressSerialPort) : extSerialPort(addressSerialPort)
{
    dataToSend.clear();
    stopped=false;
}
 
ThreadEnvoi::~ThreadEnvoi()
{
    if (isRunning())
    {
        stopSending();
        wait();
    }
}
 
 
void ThreadEnvoi::addDataToSend(QByteArray dataToAdd)
{
    QMutexLocker locker(&mutexSend);
    for (int i=0; i<dataToAdd.size(); i++)
 
        dataToSend.enqueue(QByteArray(1,dataToAdd.at(i)));
 
    qDebug()<<"Donnees dans le thread de emission ";
    qDebug()<<dataToSend<<endl;
 
    if (!isRunning())
        start();
}
 
void ThreadEnvoi::stopSending()
{
    stopped=true;
}
 
void ThreadEnvoi::run()
{
    QByteArray byteArray;
 
    forever
    {
        if (dataToSend.isEmpty() || stopped)
        {
            stopped = false;
            break;
        }
        mutexSend.lock();
        byteArray = dataToSend.dequeue();
        mutexSend.unlock();
 
        extSerialPort->write(byteArray, 1);
        extSerialPort->flush();
    }
}
 
//Slot permettant d'utiliser la fonction d'envoi de données.
void ThreadEnvoi::transfererDonnee(QByteArray donnee){
    addDataToSend(donnee);
}

Ces deux threads sont connectés à la lecture de mon XML par les lignes suivantes :
(un_Serial et m_Serial sont deux objets GestionPortSerie créés auparavant)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
//Connexion entre les deux threads réception et envoi des deux ports séries
             connect(un_serial->m_ThreadReception,SIGNAL(newDataReceived(QByteArray)),m_serial->m_ThreadEnvoi,SLOT(transfererDonnee(QByteArray)));
             connect(m_serial->m_ThreadReception,SIGNAL(newDataReceived(QByteArray)),un_serial->m_ThreadEnvoi,SLOT(transfererDonnee(QByteArray)));

J'ai une création de deux objets car mon appli sert à prolonger une liaison série. (Elle récupère un flux série et renvoie un flux série)

Désolé pour l'avalanche de code
En espérant que ça vous aide...

[bi_turbo]

.... récemment mis en place deux threads : un pour la réception et un pour l'émission.
Mais je n'arrive toujours pas à écrire sur le port pendant ma réception.

Sous µ$oft Je m'y suis essayé avant de me résoudre au fait que les actions sont unique. ouverture- lecture ou écriture -fermeture.
Donc la lecture et l ecriture ne peut pas se faire en même temps . Amha.

Encore moins ouverture- lecture ou écriture -fermeture en simultané sur des port differents.
Le souci se posait au niveau de la configuration de CreateFile[A |W] ou un truc de ce genre.

Hope

[Gulish]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ThreadReception::ThreadReception(AbstractSerial *addressSerialPort) : extSerialPort(addressSerialPort)

Qu est ce que extSerialPort ? Si tu as les headers en passant, ça serait pas plus mal.

Sinon, je suppose que tes deux classes de thread dérivent de QThread ? Si tu n'as pas trop d'expérience avec Qthre, je te renvoie à une discussion sur le multithreading. En lisant les 2 articles citées dans la discussion, tu trouveras une manière simple de faire des threads qui marchent.

Après, j'avoue que je n'ai pas lu en détail ce que tu as fait. Et si tu as un doute sur tes automates, tu peux toujours essayer entre 2 pc.

G.

[L-F-an]

Re,
Merci pour les réponses et pour le lien.
Je vais regarder ça maintenant.
Comment simuler l'occupation d'une communication avec un pc qui nécessite une réponse?
Car entre deux pc mon programme fonctionne.
bi_turbo, si il n'est pas possible de lire et écrire en parallèle, il doit bien exister un moyen de bloquer la lecture pendant l'ecriture? non?

Voici les headers:

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
 
#ifndef GESTIONPORTSERIE_H
#define GESTIONPORTSERIE_H
 
#include "abstractserial.h"
#include "EcouteurPortSerie.h"
#include <QThread>
#include <QQueue>
#include <QMutex>
#include <QDebug>
 
 
class ThreadReception;
class ThreadEnvoi;
 
class GestionPortSerie: public QObject
{
 
private:
 
    EcouteurPortSerie *EcouteurSerie;
    QString NomSerial;
    AbstractSerial *port;
    AbstractSerial::BaudRate F_Bps;
    AbstractSerial::DataBits F_Nb_Bits_Donnees;
    AbstractSerial::StopBits F_Bits_Stop;
    AbstractSerial::Parity F_Parite;
    AbstractSerial::Flow F_Controle_Flux;
 
 
public:
    GestionPortSerie(QString Nom,AbstractSerial::BaudRate Bps,AbstractSerial::DataBits Nb_Bits_Donnees,AbstractSerial::StopBits Bits_Stop,AbstractSerial::Parity Parite,AbstractSerial::Flow Controle_Flux);
    ~GestionPortSerie();
    QString RecupNomSerial();
    EcouteurPortSerie* RecupEcouteurPort();
    ThreadReception *m_ThreadReception;
    ThreadEnvoi *m_ThreadEnvoi;
 
 
};
#endif // GESTIONPORTSERIE_H
 
//THREAD RECEPTION
class ThreadReception : public QThread
{
    Q_OBJECT
 
public:
    ThreadReception(AbstractSerial *addressSerialPort);
    ~ThreadReception();
    void stopReceiving();
 
protected:
    void run();
 
private :
        QMutex mutexReceive;
AbstractSerial *extSerialPort;
bool stopped;
 
signals:
void newDataReceived(QByteArray dataReceived);
};
 
 
//THREAD ENVOI
class ThreadEnvoi : public QThread
{
    Q_OBJECT
 
public:
    ThreadEnvoi(AbstractSerial *addressSerialPort);
    ~ThreadEnvoi();
    void addDataToSend(QByteArray dataToAdd);
    void stopSending();
 
protected:
    void run();
 
private:
    QMutex mutexSend;
    AbstractSerial *extSerialPort;
    QQueue<QByteArray> dataToSend;
    bool stopped;
 
public slots:
    void transfererDonnee(QByteArray donnee);
};

[L-F-an]

Bonjour,

Voici quelques mois que j'ai résolu mon problème et je me suis rendu compte que je n'avais pas donné de suite sur le forum.
Je ne sais pas si je l'ai déjà dit donc pour cloturer ce topic je précise quelques infos pour faciliter la recherche des futures personnes susceptibles de travailler sur le port série.
Dèjà, bien utiliser la librairie qSerialDevice qui à ce jour est la meilleure proposée pour Qt.
Elle est totalement multi plate forme et full duplex. Son utilisation est intuitive et je n'ai à ce jour, constaté aucun problème.
Mes soucis venaient d'autre chose, qui ne dépendaient pas de mon application.
Parfois, on s'obstine à remettre en cause son code alors que la vérité est ailleurs (enfin, seulement parfois dans mon cas ! )

a+