[Linux] Synaser : problème de lecture du port série

Version imprimable

Bonjour,
J'ai un problème pour la lecture sur le port série avec le composant Synaser Linux : je ne reçois rien sur le port mais l'envoi se fait sans problème.

Code:

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
 
program testport;
{$mode objfpc}{$H+}
uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes, SysUtils,synaser,DateUtils,baseunix;
 
var
  ser: TBlockSerial;
begin
  ser := TBlockSerial.Create;
  try
    ser.Connect('/dev/ttyD00'); 
    Sleep(250); 
    ser.config(9600, 8, 'N', 1, False, False);
    ser.LinuxLock:=False
    repeat
       writeln(ser.RecvString(1000));
    until keypressed;
  finally
    ser.free;
  end;
end;

Merci pour votre aide

29/04/2022, 19h47
laurent.delaon

bonsoir,

tu envoies: c'est tout ce que tu fais avec ton programme.
Il faut lire le tampon de reception pour "avoir " les caractères reçus.

essai plutôt :
https://github.com/JurassicPork/TLazSerial

il y a des exemples.
29/04/2022, 19h57
hicham_taybi

Merci pour votre réponse,
Mais c'est que je fait avec :

Code:

writeln(ser.RecvString(1000))

J'affiche ce que je reçois sur le port

1 pièce(s) jointe(s)

Hello,

Citation:

Envoyé par laurent.delaon

essai plutôt :
https://github.com/JurassicPork/TLazSerial
.

Le souci c'est qu'il est en mode console et que TLazserial ne fonctionne pas en mode console.
Voici un exemple en mode console qui utilise un thread pour recevoir ce qui arrive sur le port série dans la fenêtre console. Il y a aussi un timer qui peut envoyer des caractères sur le port série. Il est désactivé dans l'exemple.

Code:

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
program consoleapp;
 
 
{$mode objfpc}{$H+}
 
 
uses
  {$IFDEF UNIX}
   cthreads, baseunix,
  {$ELSE}
  Windows,//registry,
{$ENDIF}
  Classes, SysUtils, CustApp, crt
  { you can add units after this },
  fpTimer, synaser;
 
 
type
  TConsoleApp = class;
   { TComPortReadThread }
  TComPortReadThread=class(TThread)
  public
    MustDie: boolean;
    Owner: TConsoleApp;
  protected
    procedure CallEvent;
    procedure Execute; override;
  published
    property Terminated;
  end;
 
 
  { TConsoleApp }
 
 
  TConsoleApp = class(TCustomApplication)
  protected
    procedure DoRun; override;
  public
    CurPos : integer;
    FTempStr: String;
    Timer1: TFPTimer;
    SynSer: TBlockSerial;
    OnRxData: TNotifyEvent;
    ReadThread: TComPortReadThread;
    constructor Create(TheOwner: TComponent); override;
    destructor Destroy; override;
    procedure Timer1Exec( Sender : TObject );
    procedure DeviceOpen(Port: String);
    procedure DeviceClose;
    function ReadData: string;
    procedure SerialRxData(Sender: TObject);
  end;
 
 
  { TComPortReadThread }
 
 
  procedure TComPortReadThread.CallEvent;
  begin
    if Assigned(Owner.OnRxData) then begin
      Owner.OnRxData(Owner);
    end;
  end;
 
 
  procedure TComPortReadThread.Execute;
  begin
    try
      while not MustDie do begin
        if Owner.SynSer.CanReadEx(100) then
          Synchronize(@CallEvent);
      end;
    finally
      Terminate;
    end;
 
 
  end;
 
 
{ TConsoleApp }
 
 
procedure TConsoleApp.Timer1Exec( Sender : TObject );
begin
  writeln( datetimetostr(now) + ' -> I am alive !');
end;
procedure TConsoleApp.DeviceOpen(Port: String);
begin
  SynSer.Connect(Port);
  if SynSer.Handle=INVALID_HANDLE_VALUE then
    raise Exception.Create('Could not open device '+ SynSer.Device);
  SynSer.Config(9600,8,'N',0,false,false);
 
 
  // Launch Thread
  ReadThread := TComPortReadThread.Create(true);
  ReadThread.Owner := Self;
  ReadThread.MustDie := false;
//  ReadThread.Resume;   --> deprecated
  ReadThread.Start;
end;
procedure TConsoleApp.DeviceClose;
begin
  // flush device
  if SynSer.Handle<>INVALID_HANDLE_VALUE then begin
    SynSer.Flush;
    SynSer.CloseSocket;
 //   FSynSer.Purge;
  end;
 
 
  // stop capture thread
  if ReadThread<>nil then begin
    ReadThread.FreeOnTerminate:=false;
    ReadThread.MustDie:= true;
    while not ReadThread.Terminated do begin
    Sleep(1000);
    end;
    ReadThread.Free;
    ReadThread:=nil;
  end;
 
 
  // close device
  if SynSer.Handle<>INVALID_HANDLE_VALUE then begin
    SynSer.Flush;
    SynSer.CloseSocket;
  end;
end;
 
 
 
 
function TConsoleApp.ReadData: string;
begin
  result:='';
  if SynSer.Handle =INVALID_HANDLE_VALUE then
    Writeln('can not read from a closed port.');
//  if FRcvLineCRLF then
//  result:=SynSer.RecvString(0)
//  else
  result:=SynSer.RecvPacket(0);
end;
procedure TConsoleApp.SerialRxData(Sender: TObject);
var Str : string;
begin
  Str :=  ReadData;
  CurPos := Pos( Char(10) ,Str);
  if CurPos = 0 then begin
    FTempStr := FTempStr + Str;
  end
  else begin
    FTempStr := FTempStr + Copy( Str, 1, CurPos-1);
    Writeln(FtempStr);
    FTempStr := Copy(Str,CurPos +1, Length(Str) - CurPos);
  end;
 
 
end;
 
 
procedure TConsoleApp.DoRun;
var port: string;
begin
   // parse parameters
  if HasOption('p', 'port') then  port := getOptionValue('p', 'port')
  else port := '/dev/ttyUSB0';
  DeviceOpen(port);
  SynSer.SendString('hello' + CRLF);
  timer1.StartTimer;
  repeat
  begin
    // writeln(datetimetostr(now));
    // SynSer.SendString(datetimetostr(now) + CRLF);
    sleep(100);
 
 
    // don't forget to call CheckSynchronize to let threads
    // have the chance to do something
    CheckSynchronize;
 
 
  end;
 
 
  until keypressed;
  Terminate;
end;
 
 
 
 
constructor TConsoleApp.Create(TheOwner: TComponent);
begin
  inherited Create(TheOwner);
  StopOnException:=False;
end;
 
 
destructor TConsoleApp.Destroy;
begin
  inherited Destroy;
end;
 
 
var
  Application: TConsoleApp;
 
 
begin
  Application:=TConsoleApp.Create(nil);
  Application.Title:='ConsoleApp';
  Application.Timer1 := TFPTimer.Create(nil);
  Application.Timer1.Enabled := False;
  Application.Timer1.interval := 10000;
  try
  Application.SynSer := TBlockSerial.Create;
 
 
  except
     on E : Exception do begin
       Writeln(E.ClassName + ' error raised, with message : ' + E.Message);
     end;
  end;
  Application.Timer1.onTimer := @Application.Timer1Exec;
  Application.OnRxData := @Application.SerialRxData;
  try
  Application.Run;
  finally
  writeln('fin de programme');
  Application.DeviceClose;
  Application.Free;
  end;
end.

Testé sous Ubuntu 20.04 Lazarus 2.2 avec des données qui arrivent sur le port série provenant de mon simulateur GPS série :

Pièce jointe 618273

Ami calmant, J.P

30/04/2022, 02h46
hicham_taybi

Merci pour votre réponse
Mais je crois que ce n'est pas le fait de ne pas recevoir CRLF à la fin de la trame reçue qui cause problème pour mon programme, mais que la trame que je reçois peut ne pas contenir CRLF.
Y a-t-il une solution à ce problème : de recevoir la trame quelle que soit la fin ?
Merci
30/04/2022, 11h46
jurassic pork

Hello,

Citation:

Envoyé par hicham_taybi

Mais je crois le faite de ne pas recevoir CRLF à la fin de la trame reçu qui cause problème pour mon programme, mais le problème que la trame que je reçois peut ne pas contenir CRLF.
Y a t il une solution à ce problème: de recevoir la trame quelque soit la fin .
Merci

D'où viennent les données qui sont envoyées dans le port série ? Normalement si ce ne sont pas des chaînes avec CRLF il y a toujours des délimiteurs (début, fin) ou alors ce sont des trames à longueurs fixes. Sinon il est pratiquement impossible d'exploiter les données.
Ami calmant, J.P
30/04/2022, 13h33
hicham_taybi
Bonjour,
Merci pour votre réponse.
Les donnée d'un automate d'analyse médicale qui envoie ENQ, ACK , NAK et d'autres...

Exemple :
- automate envoie ENQ
- je dois répondre ACK
- c'est après qu'il envoie les trames.
Citation:

LECTURE :<ENQ>
ECRITURE :<ACK>
LECTURE :<STX>1H|\^&|||Automate^^|||||||QR|1394-97|20220426141339<CR>P|10|||||||||||||||||||||||||||||||||<CR>O|10|||LIPA^LIP||20220426135751|||||1^LIP<SP>Contro^044820004^20210630^44.600000^M^3.000000^41.864748^SMPE,EXT|||||||||U/L|||||F|||||<CR>L|11|N<CR><ETX>22<CR><LF>
ECRITURE :<ACK>
LECTURE :<EOT>

Merci
30/04/2022, 13h57
jurassic pork

il y a l'air d'avoir un STX en début et un CRLF à la fin. As-tu essayé mon programme en reception ?
30/04/2022, 14h20
hicham_taybi

Merci pour votre réponse,
Je dois recevoir avant tout ENQ ; après je dois répondre par ACK c'est après que je reçois les trames qui se terminent par CRLF .
Comme ça ENQ ne sera jamais reçu car il attend CRLF à la fin.

Pour ton exemple je vais le tester.

Merci
30/04/2022, 14h59
tourlourou

Bonjour,
Les caractères de contrôle <ENQ>, <STX> et autres ne sont-ils pas des octets à lire dans RecvByte plutôt qu'à attendre avec RecvString comme des chaînes ?
30/04/2022, 15h55
hicham_taybi

Citation:

Envoyé par hicham_taybi

Merci pour votre réponse,
Je doit recevoir avant tout ENQ après je doit répondre par ACK c'est après que je reçoit les trames qui se terminent par CRLF .
comme ça ENQ ne sera jamais reçu car il attend CRLF à la fin.

Pour ton exemple je vais le tester

Merci

Je viens de tester ton exemple : je reçois s'il y a CRLF à la fin, autrement non.
Je crois que la solution c'est de mettre la propriété FRcvLineCRLF à false mais cette propriété n'existe pas pour Synaser comme dans LazSerial.
30/04/2022, 15h58
hicham_taybi

Citation:

Envoyé par tourlourou

Bonjour,
Les caractères de contrôle <ENQ>, <STX> et autres ne sont-ils pas des octets à lire dans RecvByte plutôt qu'à attendre avec RecvString comme des chaînes ?

Merci pour votre réponse, est-ce que je peux utiliser RecvByte pour recevoir les chaînes aussi ?

Merci

Citation:

Envoyé par hicham_taybi

Je viens de tester ton exemple je reçois si il y a CRLF à la fin autrement non.

C'est normal à cause de ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure TConsoleApp.SerialRxData(Sender: TObject);var Str : string;
begin
  Str :=  ReadData;
  CurPos := Pos( Char(10) ,Str);
  if CurPos = 0 then begin
    FTempStr := FTempStr + Str;
  end
  else begin
    FTempStr := FTempStr + Copy( Str, 1, CurPos-1);
    Writeln(FtempStr);
    FTempStr := Copy(Str,CurPos +1, Length(Str) - CurPos);
  end;
end;

pour afficher les caractères reçus en Hexa tu peux essayer ceci :

Code:

1
2
3
4
5
6
7
8
9
10
procedure TConsoleApp.SerialRxData(Sender: TObject);
var S,HexaS : string;
    i : integer;
begin
  S := ReadData;
  for I := 1 to Length(S) do begin
    HexaS := HexaS + InttoHex(Ord(S[I]),2)+ ' ';
  end;
  Writeln(HexaS);
end;

01/05/2022, 01h10
hicham_taybi

Bonsoir,
Merci pour votre aide ça marche maintenant.
Merci beaucoup