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

**hicham_taybi** · 29/04/2022, 17h23

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 :

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
 
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

**laurent.delaon** · 29/04/2022, 19h47

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.

**hicham_taybi** · 29/04/2022, 19h57

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

Code :

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

writeln(ser.RecvString(1000))

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

**jurassic pork** · 30/04/2022, 01h47

Hello,

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 :

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
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 :

Nom : ConsoleAppUbuntu.png
Affichages : 378
Taille : 154,4 Ko

Nom : ConsoleAppUbuntu.png
Affichages : 378
Taille : 154,4 Ko

Ami calmant, J.P

**hicham_taybi** · 30/04/2022, 02h46

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

**jurassic pork** · 30/04/2022, 11h46

Hello,

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

**hicham_taybi** · 30/04/2022, 13h33

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.

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

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

Lazarus Pascal

Vue hybride

Discussions similaires

Partager

Partager