RS485 / Serport im Process nutzen

1
2
Page 1 of 2

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 11:27 · #1

Hallo,

ich möchte ein SLAVE am RS485 im Polling-Verfahren abfragen (alle 300-500ms)

Code

XMEGA (Master)            RS485-Slave
1.Telegramm senden           >>>
2. Ackn vom Slave            <<<
3. Antwort Empfangen         <<<     Mit Nutzdaten
4. CheckSum. prüfen ACKN     >>>>
5. Quittung senden           >>>>
6. ACKN vom Slave            <<<<
Und nach 500ms wieder an die 1.

Da ich in meiner Steuerung bereits 4 Prozesse am laufen habe, sollen diese bei der Kommunikation nicht zu stark unterbrochen werden, es könnte auch passieren, das der Teilnehmer mal nicht antwortet (Leitungsbruch, defekt, Adressierungsfehler usw)

Mit welcher Methode geht man am besten daran ohne die anderen Prozesse zu blockieren?

Das schreiben sollte ja kein Thema sein, aber das lesen eben

Mit SerStatC0 kann ich ja abfragen ob überhaupt Daten im Empfangsspeicher liegen, bevor ich SerInp verwende. Im Handbuch ist die Rede das man bei Prozessen oder Tasks lieber WaitPipe nutzen sollte. Oder sollte man im Prozess lieber den Timeout nutzen?

Ich möchte halt vermeiden, das ich hier irgendwelche Teile blockiere nur weil er Daten empfängt.

Gibt es ein Demo zu der Verwendung von WaitPipe / FlushBuffer im Prozess?

Administrator

Gender:
Location: Germany
Age: 24
Homepage: e-lab.de
Posts: 5558
Registered: 03 / 2002

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 13:32 · #2

Hallo Thorsten,

das WaitPipe ist optimal dafür. Der beteiligte Prozess wird solange schlafen gelegt bis im RxBuffer etwas angekommen ist.

rolf

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 17:40 · #3

Quote by rh

Hallo Thorsten,

das WaitPipe ist optimal dafür. Der beteiligte Prozess wird solange schlafen gelegt bis im RxBuffer etwas angekommen ist.

rolf

Hallo rolf,

das heisst der ganze Process wird dann schlafen gelegt?

Das heisst man sollte dann das Senden vom Master in einen getrennten Process ablaufen lassen, oder man weckt den Process wieder auf und startet nach einem TimeOut von vorne!
Kann ich den Process mit Waitpipe abbrechen und von vorne starten? Das müsste ja dann von einem anderen Process veranlasst werden, da der eigentliche Process ja noch schläft.
Richtig?

Nachtrag

Habe gerade gesehen, das ich die Funktion

Code

Function WaitPipe (pipe1 : pipe [; timeout: word]) : boolean;

mit einem Timeout ausstatten kann.

Hier könnte ich ja einfach die Rückmeldung abfragen, wenn FALSE dann starte von neuem...

Thorsten

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 19:12 · #4

Hallo rolf,

gab es nicht mal eine Funktion, wo ich die Anzahl der empfangenen Bytes im RxBufferC0 abfragen konnte?

Ich meine irgendwo mal sowas gelesen zu haben, aber im Handbuch ist nichts zu finden.

Thomas.AC

Benutzer

Gender: n/a
Age: 43
Posts: 308
Registered: 07 / 2013

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 19:53 · #5

Ja, mit waitPipe + timeout geht das.
Und mit PipeStat müsste sich die Anzahl empfangener Bytes abfragen lassen.

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 28.03.2018 - 20:32 · #6

Quote by Thomas.AC

Ja, mit waitPipe + timeout geht das.
Und mit PipeStat müsste sich die Anzahl empfangener Bytes abfragen lassen.

Klasse, habe immer wieder im Handbuch der Treiber gesucht. Stand aber im Compiler-Handbuch.

Danke

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 29.03.2018 - 11:41 · #7

Hallo rolf,

mache ich was falsch? Ich habe den Prozess wie die anderen auch angelegt, aber er wird nicht abgearbeitet? Er springt noch nicht mal in den Prozess rein. Da ich ihn ja nicht besondert deklariert habe, sollte der doch einen Autostart machen.

Code

Process ReadZKS(128,128:iData,4);
var
Temp: byte;
rxCnt : byte;
xi : integer;
strOutDiag   : STRING[30];
Begin
     DebugOut('Start..'); // dieser Text wird NIE ausgegeben, also wird der Process auch nicht gestartet

if isSysTimerZero(ZKSTimer) then
  SetSysTimer( ZKSTimer, 500 );
    DebugOut('ReadZKS');

// Lösche Speicher
for xi:= 0 to 79 do
   outZKS[xi]:= $00;
  endfor;

// Daten vorbereiten
outZKS[0]:= $10; // DLE
outZKS[1]:= $02; // STX
...
outZKS[79]:= $06; // Zähler für weitere Bearbeitung

  zksBCC2( outZKS ); // Checksumme erstellen und ablegen

for xi:= 0 to outZKS[79]-1 do
   strOutDiag:=strOutDiag+' $'+ByteToHex(outZKS[xi]);
  endfor;
DebugOut( strOutDiag );

// Sende Block am Stück
SetSerEnable(UsartC0, true);
  SerOutBlock_P(UsartC0, @outZKS,  word(outZKS[79]-1));
   SetSerEnable(UsartC0, false);

endif;

rxCnt:= 0;
    WaitPipe(RxBufferC0);                         // Warte auf Daten im Puffer
     rxCnt:= PipeStat(RxBufferC0);

    Read(SerInpC0, Temp);                         // Puffer lesen

<.............>

    FlushBuffer(RxBufferC0); // löschen des Buffers

End ReadZKS;

Mit "Process ReadZKS(128,128:iData,4);" teile ich dem Compiler mit, dass er 4 SysTicks zeit hat, aber sobald er ja in den WaitPipe geht ist er draußen. Ich habe zum testen auch schon mal 2,3 und 5 getestet aber ohne erfolg. ich bekomme den Prozess nicht zum laufen:

Aktuelle Einstellungen meiner Tasks / Processe sind:

Code

DEFINE
SysTick = 10;
  TaskStack      = 256, iData;
  TaskFrame      = 256;
...
{--------------------------------------------------------------}
  // The USB_ControlJob must be repeatedly called to process common PC requests

Task ControlJob(iData, resumed);
begin
  USB_ControlJob;
end;
...

{--------------------------------------------------------------}
Process USB_RxTx (256, 256 : iData ); {Stacksize = 256 bytes, Framesize = 256 bytes}
//Procedure USB_CheckRxTx;

...

{--------------------------------------------------------------}
//Procedure StartDisp;
{--------------------------------------------------------------}
Process LCD_Displ (128, 128 : iData;5 ); {Stacksize = 128 bytes, Framesize = 128 bytes}

...

Main sollte ja als Standard 5 SysTicks bekommen, hast Du eine Idee wo ich ansetzen könnte?

Die anderen Prozesse und der USB-Task laufen ohne Probleme.

Thorsten

pvs-deck

PowerUser

Gender:
Age: 53
Homepage: pvs-deck.de
Posts: 1341
Registered: 02 / 2009

Subject:

Re: RS485 / Serport im Process nutzen

· Posted: 29.03.2018 - 14:15 · #8

Hallo rolf,

kann ich im ASM irgendwo kontrollieren, das der Schedler auch in diese Process-Routine springt?

Im ASM habe das entdeckt:

Code

                        ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                        ; processes and scheduler
                        ; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

SYSTEM.$Main_stk_chk    .EQU    0574Eh          ; var iData  Process stack area
SYSTEM.$Main_stk        .EQU    05750h          ; var iData  Process stack area
SYSTEM.$Main_stk_e      .EQU    05875h          ; var iData  Process stack area
SYSTEM.$Main_reg        .EQU    05876h          ; var iData  Process register area
SYSTEM.$Main_reg_e      .EQU    05893h          ; var iData  Process register area
SYSTEM.PP_MAIN_PROC     .EQU    05894h          ; var iData  Process scheduler area
SYSTEM.PP_LCD_Displ     .EQU    058A4h          ; var iData  Process scheduler area
SYSTEM.PP_USB_RxTx      .EQU    058B4h          ; var iData  Process scheduler area
SYSTEM.PP_ReadZKS       .EQU    058C4h          ; var iData  Process scheduler area
SYSTEM.TT_ControlJob    .EQU    058D4h          ; var iData  Process scheduler area
SYSTEM.$Main_frm_chk    .EQU    058DAh          ; var iData  Process stack area
SYSTEM.$Main_Frame      .EQU    058DCh          ; var iData  Process stack area
SYSTEM.$Main_Frame_e    .EQU    05A01h          ; var iData  Process stack area

Da ist auch die "SYSTEM.PP_ReadZKS .EQU" enthalten.

Wenn ich richtig sehe, ist auch der Process im ">> Process Queue and Scheduler Init <<":

Code

                        ; >> Process Queue and Scheduler Init <<
                        LDI       _ACCALO, 0A5h
                        LDI       _ACCAHI, 05Ah
                        STS       SYSTEM.$Main_stk_chk, _ACCALO
                        STS       SYSTEM.$Main_stk_chk+1, _ACCAHI
                        STS       SYSTEM.$Main_frm_chk, _ACCALO
                        STS       SYSTEM.$Main_frm_chk+1, _ACCAHI
                        LDI       _ACCB, SYSTEM.PP_MAIN_PROC AND 0FFh
                        LDI       _ACCA, SYSTEM.PP_MAIN_PROC SHRB 8
                        MOVW      $_CurProcess, _ACCB
                        .DEB      $_CurProcIni
                        LDI       _ACCA, 08h
                        STS       SYSTEM.PP_MAIN_PROC+0, _ACCA
                        LDI       _ACCA, 5
                        STS       SYSTEM.PP_MAIN_PROC+1, _ACCA
                        STS       SYSTEM.PP_MAIN_PROC+2, _ACCA
                        LDI       _ACCB, SYSTEM.$Main_reg AND 0FFh
                        LDI       _ACCA, SYSTEM.$Main_reg SHRB 8
                        STS       SYSTEM.PP_MAIN_PROC+11, _ACCA
                        STS       SYSTEM.PP_MAIN_PROC+10, _ACCB
                        LDI       _ACCB, SYSTEM.PP_LCD_Displ AND 0FFh
                        LDI       _ACCA, SYSTEM.PP_LCD_Displ SHRB 8
                        STS       SYSTEM.PP_MAIN_PROC+15, _ACCA
                        STS       SYSTEM.PP_MAIN_PROC+14, _ACCB
                        LDI       _ACCA, 0
                        STS       SYSTEM.PP_MAIN_PROC+5, _ACCA
                        .DEB      $_CurProcIni_X
                        LDI       _ACCALO, 0A5h
                        LDI       _ACCAHI, 05Ah
                        STS       PVS2018.$LCD_Displ_stk_chk, _ACCALO
                        STS       PVS2018.$LCD_Displ_stk_chk+1, _ACCAHI
                        STS       PVS2018.$LCD_Displ_frm_chk, _ACCALO
                        STS       PVS2018.$LCD_Displ_frm_chk+1, _ACCAHI
                        LDI       _ACCA, 10h
                        STS       SYSTEM.PP_LCD_Displ+0, _ACCA
                        LDI       _ACCA, 5
                        STS       SYSTEM.PP_LCD_Displ+1, _ACCA
                        STS       SYSTEM.PP_LCD_Displ+2, _ACCA
                        LDI       _ACCB, PVS2018.$LCD_Displ_frame_e AND 0FFh
                        LDI       _ACCA, PVS2018.$LCD_Displ_frame_e SHRB 8
                        STS       SYSTEM.PP_LCD_Displ+9, _ACCA
                        STS       SYSTEM.PP_LCD_Displ+8, _ACCB
                        LDI       _ACCB, PVS2018.$LCD_Displ_stk_e AND 0FFh
                        LDI       _ACCA, PVS2018.$LCD_Displ_stk_e SHRB 8
                        SUBI      _ACCB, 005h
                        SBCI      _ACCA, 000h
                        MOVW      _ACCCLO, _ACCB
                        STS       SYSTEM.PP_LCD_Displ+7, _ACCA
                        STS       SYSTEM.PP_LCD_Displ+6, _ACCB
                        LDI       _ACCB, PVS2018.$LCD_Displ_reg AND 0FFh
                        LDI       _ACCA, PVS2018.$LCD_Displ_reg SHRB 8
                        STS       SYSTEM.PP_LCD_Displ+11, _ACCA
                        STS       SYSTEM.PP_LCD_Displ+10, _ACCB
                        LDI       _ACCB, SYSTEM.PP_USB_RxTx AND 0FFh
                        LDI       _ACCA, SYSTEM.PP_USB_RxTx SHRB 8
                        STS       SYSTEM.PP_LCD_Displ+15, _ACCA
                        STS       SYSTEM.PP_LCD_Displ+14, _ACCB
                        LDI       _ACCA, 001h
                        STS       SYSTEM.PP_LCD_Displ+5, _ACCA
                        LDI       _ACCA, 80h
                        ST        Z+, _ACCA
                        CLR       _ACCB
                        ST        Z+, _ACCB
                        ST        Z+, _ACCA
                        LDI       _ACCB, PVS2018.LCD_Displ SHRB 1
                        LDI       _ACCA, PVS2018.LCD_Displ SHRB 9
                        LDI       _ACCALO, PVS2018.LCD_Displ SHRB 17
                        ST        Z+, _ACCALO
                        ST        Z+, _ACCA
                        ST        Z, _ACCB

                        LDI       _ACCALO, 0A5h
                        LDI       _ACCAHI, 05Ah
                        STS       PVS2018.$USB_RxTx_stk_chk, _ACCALO
                        STS       PVS2018.$USB_RxTx_stk_chk+1, _ACCAHI
                        STS       PVS2018.$USB_RxTx_frm_chk, _ACCALO
                        STS       PVS2018.$USB_RxTx_frm_chk+1, _ACCAHI
                        LDI       _ACCA, 10h
                        STS       SYSTEM.PP_USB_RxTx+0, _ACCA
                        LDI       _ACCA, 3
                        STS       SYSTEM.PP_USB_RxTx+1, _ACCA
                        STS       SYSTEM.PP_USB_RxTx+2, _ACCA
                        LDI       _ACCB, PVS2018.$USB_RxTx_frame_e AND 0FFh
                        LDI       _ACCA, PVS2018.$USB_RxTx_frame_e SHRB 8
                        STS       SYSTEM.PP_USB_RxTx+9, _ACCA
                        STS       SYSTEM.PP_USB_RxTx+8, _ACCB
                        LDI       _ACCB, PVS2018.$USB_RxTx_stk_e AND 0FFh
                        LDI       _ACCA, PVS2018.$USB_RxTx_stk_e SHRB 8
                        SUBI      _ACCB, 005h
                        SBCI      _ACCA, 000h
                        MOVW      _ACCCLO, _ACCB
                        STS       SYSTEM.PP_USB_RxTx+7, _ACCA
                        STS       SYSTEM.PP_USB_RxTx+6, _ACCB
                        LDI       _ACCB, PVS2018.$USB_RxTx_reg AND 0FFh
                        LDI       _ACCA, PVS2018.$USB_RxTx_reg SHRB 8
                        STS       SYSTEM.PP_USB_RxTx+11, _ACCA
                        STS       SYSTEM.PP_USB_RxTx+10, _ACCB
                        LDI       _ACCB, SYSTEM.PP_ReadZKS AND 0FFh
                        LDI       _ACCA, SYSTEM.PP_ReadZKS SHRB 8
                        STS       SYSTEM.PP_USB_RxTx+15, _ACCA
                        STS       SYSTEM.PP_USB_RxTx+14, _ACCB
                        LDI       _ACCA, 003h
                        STS       SYSTEM.PP_USB_RxTx+5, _ACCA
                        LDI       _ACCA, 80h
                        ST        Z+, _ACCA
                        CLR       _ACCB
                        ST        Z+, _ACCB
                        ST        Z+, _ACCA
                        LDI       _ACCB, PVS2018.USB_RxTx SHRB 1
                        LDI       _ACCA, PVS2018.USB_RxTx SHRB 9
                        LDI       _ACCALO, PVS2018.USB_RxTx SHRB 17
                        ST        Z+, _ACCALO
                        ST        Z+, _ACCA
                        ST        Z, _ACCB

                        LDI       _ACCALO, 0A5h
                        LDI       _ACCAHI, 05Ah
                        STS       PVS2018.$ReadZKS_stk_chk, _ACCALO
                        STS       PVS2018.$ReadZKS_stk_chk+1, _ACCAHI
                        STS       PVS2018.$ReadZKS_frm_chk, _ACCALO
                        STS       PVS2018.$ReadZKS_frm_chk+1, _ACCAHI
                        LDI       _ACCA, 10h
                        STS       SYSTEM.PP_ReadZKS+0, _ACCA
                        LDI       _ACCA, 4
                        STS       SYSTEM.PP_ReadZKS+1, _ACCA
                        STS       SYSTEM.PP_ReadZKS+2, _ACCA
                        LDI       _ACCB, PVS2018.$ReadZKS_frame_e AND 0FFh
                        LDI       _ACCA, PVS2018.$ReadZKS_frame_e SHRB 8
                        STS       SYSTEM.PP_ReadZKS+9, _ACCA
                        STS       SYSTEM.PP_ReadZKS+8, _ACCB
                        LDI       _ACCB, PVS2018.$ReadZKS_stk_e AND 0FFh
                        LDI       _ACCA, PVS2018.$ReadZKS_stk_e SHRB 8
                        SUBI      _ACCB, 005h
                        SBCI      _ACCA, 000h
                        MOVW      _ACCCLO, _ACCB
                        STS       SYSTEM.PP_ReadZKS+7, _ACCA
                        STS       SYSTEM.PP_ReadZKS+6, _ACCB
                        LDI       _ACCB, PVS2018.$ReadZKS_reg AND 0FFh
                        LDI       _ACCA, PVS2018.$ReadZKS_reg SHRB 8
                        STS       SYSTEM.PP_ReadZKS+11, _ACCA
                        STS       SYSTEM.PP_ReadZKS+10, _ACCB
                        LDI       _ACCB, SYSTEM.PP_MAIN_PROC AND 0FFh
                        LDI       _ACCA, SYSTEM.PP_MAIN_PROC SHRB 8
                        STS       SYSTEM.PP_ReadZKS+15, _ACCA
                        STS       SYSTEM.PP_ReadZKS+14, _ACCB
                        LDI       _ACCA, 004h
                        STS       SYSTEM.PP_ReadZKS+5, _ACCA
                        LDI       _ACCA, 80h
                        ST        Z+, _ACCA
                        CLR       _ACCB
                        ST        Z+, _ACCB
                        ST        Z+, _ACCA
                        LDI       _ACCB, PVS2018.ReadZKS SHRB 1
                        LDI       _ACCA, PVS2018.ReadZKS SHRB 9
                        LDI       _ACCALO, PVS2018.ReadZKS SHRB 17
                        ST        Z+, _ACCALO
                        ST        Z+, _ACCA
                        ST        Z, _ACCB

                        LDI       _ACCALO, 0A5h
                        LDI       _ACCAHI, 05Ah
                        STS       $TASKS_stk_chk, _ACCALO
                        STS       $TASKS_stk_chk+1, _ACCAHI
                        STS       $TASKS_frm_chk, _ACCALO
                        STS       $TASKS_frm_chk+1, _ACCAHI
                        LDI       _ACCA, 10h
                        STS       SYSTEM.TT_ControlJob+0, _ACCA
                        LDI       _ACCA, 5
                        STS       SYSTEM.TT_ControlJob+1, _ACCA
                        STS       SYSTEM.TT_ControlJob+2, _ACCA
                        LDI       _ACCA, 002h
                        STS       SYSTEM.TT_ControlJob+5, _ACCA

Ich werde mal schauen ob ich den Process mal per Hand starten kann. Sollte zwar auf Autostart sein, aber ich habe sonst keine Ahnung wo ich hingreifen kann.

Thorsten

Nachtrag:

Resume (ReadZKS); Hat leider keine Auswirkung.

Laut GetProcessState ist der Process in Idle, aber er springt ja noch nicht mal da rein

Code

  case GetProcessState (ReadZKS) of
     eProcStop :
       DebugOut('ReadZKS: Stop'); |
     eProcRun :
       DebugOut('ReadZKS: Run'); |
     eProcIdle :
       DebugOut('ReadZKS: Idle'); |
     eProcWait :
       DebugOut('ReadZKS: Wait'); |
     eProcSleep:
       DebugOut('ReadZKS: Sleep'); |
     eProcLock :
       DebugOut('ReadZKS: Lock'); |
endcase;

Attachments


Filename:	29-03-_2018_14-11-29.jpg
Filesize:	244.27 KB
Title:	Debug
Information:	Debug
Download counter:	113

1
2
Page 1 of 2

RS485 / Serport im Process nutzen

Attachments

Registered users in this topic