Mehrere Busteilnehmer mit einem CP340 ansprechen

Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,
vielleicht ja so :
Code: 
[COLOR=#ff0000]// die ersten beiden Zeichen vergleichen
      L     "P_RCV_Data".RCV_String[1]
      L     "P_RCV_Data".RCV_String[2]
      <>I 
      L s5t#2s[/COLOR]
[COLOR=#ff0000]      SE T 100[/COLOR]
[COLOR=#ff0000]      U T 100[/COLOR]
[COLOR=#ff0000]      SPB INC[/COLOR]
Code: 
// Alphabet durchzählen
[COLOR=red]INC:[/COLOR] L     "P_SEND_Data".SND_ASCII[1]
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]
ende: NOP   0
... versuch das mal ...
Gruß
LL
 
Vielen Dank Larry! Ohne dich wäre ich aufgeschmissen!
Muss aber noch immer die Sprünge nachvollziehen, denn irgendwie denke ich anders als AWL haben möchte... *grmpf*

Es hat funktioniert, nur, dass ich nicht die zwei empfangenen Zeichen vergleichen darf, sondern das erste gesendete Zeichen mit dem zweiten empfangenen Zeichen (mein Fehler):

Code: 
// die ersten beiden Zeichen vergleichen
      [COLOR="Red"]L     "P_SEND_Data".SND_ASCII[1][/COLOR]
      L     "P_RCV_Data".RCV_String[2]
      <>I   
      L     S5T#50MS
      SE    T      5
      U     T      5
      SPB   INC

So zähle ich jetzt mein Alphabet durch:
Code: 
// Alphabet durchzählen
INC:  L     "P_RCV_Data".RCV_String[1]
      T     "P_RCV_Data".Antwort_Teilnehmer    // Welcher Teilnehmer hat zuletzt geantwortet?
      L     "P_SEND_Data".SND_ASCII[1]
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]
ende: NOP   0

Nun möchte ich für meine Visu einzelne Bits setzen, die angeben, welcher Teilnehmer wie gewünscht geantwortet hat.
Im Anhang ist ein Screenshot von meinem DB.
Kann man das mit den Bits so machen oder geht das eleganter?
Mit deiner Sprunganweisung wird ja der Busteilnehmer übersprungen, der in einer vorgegebenen Zeit nicht geantwortet hat.
Ich habe nur zwei Busteilnehmer zur Verfügung, aber was ist, wenn bei drei Teilnehmern nur Teilnehmer a und c antworten, Teilnehmer b gar nicht?!
Das würde ich gerne in meinem DB "speichern", also DB2.DBX530.0 und DB2.DBX530.2 auf TRUE und DB2.DBX530.1 auf FALSE. Geht das?
Bin schon eine Weile am Probieren, aber ich weiß nicht, wie ich aus den Zahlen 97 und 99 die Bits auf TRUE setze und bei 98 das Bit auf FALSE.
Vielleicht denke ich aber mal wieder zu kompliziert?!

Danke,
poppycock
 

Anhänge

  • db2_tln.jpg
    db2_tln.jpg
    181,4 KB · Aufrufe: 2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo... :-D

Bezüglich zu meiner letzten Frage habe ich eben folgenden Code geschrieben (rote Schriftfarbe):

Code: 
[COLOR="Red"]// Nun wird ein Bit vom antwortenden Busteilnehmer gespeichert, 
// um erkennen zu können, welcher Busteilnehmer ausgefallen ist.
// Es wird ab Byte 530 im DB2 gespeichert, darum wird DBX530.0 nach dezimal umgerechnet:
// Bit 530.0 -> 4240 dezimal.
// Da das Alphabet bei 97dez anfängt, muss man von der 4240 den Wert 97 abziehen,
// damit das erste Bit vom ersten Teilnehmer ab Bit 530.0 gesetzt wird:
// 4240 - 97 = 4143
// Teilnehmer a: 4143 + 97 = Bit 530.0
// Teilnehmer b: 4143 + 98 = Bit 530.1
// usw.
INC:  L     4143                        // Offset 4143 laden
      L     "P_RCV_Data".RCV_String[2]  // dezimalen Wert von der Busadresse laden
      +I                                // beide Werte addieren
      ITD                               // von INT nach DOUBLE umwandeln
      LAR1                              // Wert ins Adressregister 1 laden
      AUF   "P_RCV_Data"
      =     DBX [AR1,P#0.0]             // aus dem Wert einen Pointer generieren
[/COLOR]
// Alphabet durchzählen
      L     "P_SEND_Data".SND_ASCII[1]  // lade letztes gesendete Zeichen
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]
ende: NOP   0

// alle Daten da, Senden wieder anstoßen
      SET   
      =     "P_SEND_Data".SND_Anstoss

nop0: NOP   0

Es wird tatsächlich das Bit gesetzt, das gesetzt werden soll.
Nun habe ich aber das Problem, dass das einzelne Bit nicht zurückgesetzt wird, wenn plötzlich ein Teilnehmer nicht mehr antwortet.

Bin noch weiter am Probieren, aber evtl. hat jemand (Vielleicht Larry?) einen Lösungsvorschlag?!

Gruß,
poppycock
 
Du könntest alle Bits gemeinsam zurücksetzen, wenn eine "Neue Runde" in der Kommunikation startet.

PS: Laß das ITD weg, beim Umwandeln in einen Pointer. Hatte ich auch mal, führt bei großen Int zu einem Fehler im späteren Pointer. Man darf nicht ITD wandeln denn das höchste Bit wird u.U. als Minus interpretiert und dann auch bei ITD entsprechend in der Double verschoben. Das Ergebnis ist Datenmüll als Zeiger! Das ganze funktioniert ohne ITD.
 
Ralle schrieb:
Du könntest alle Bits gemeinsam zurücksetzen, wenn eine "Neue Runde" in der Kommunikation startet.
Zum Vergrößern anklicken....
Daran habe ich auch gedacht, aber es flackern die Bits von TRUE nach FALSE und umgekehrt.
Vielleicht mache ich es aber auch falsch?!

Code: 
// SENDEN
      CALL  "P_SEND_OLD" , "P_SEND_Instanz"
       REQ   :="P_SEND_Data".SND_Anstoss
       R     :=
       LADDR :=256
       DB_NO :=3
       DBB_NO:=4
       LEN   :=1
       DONE  :="P_SEND_Data".SND_Done
       ERROR :="P_SEND_Data".SND_Error
       STATUS:=

// EMPFANGEN
      CALL  "P_RCV_OLD" , "P_RCV_Instanz"
       EN_R  :=M0.1
       R     :=
       LADDR :=256
       DB_NO :=2
       DBB_NO:=4
       NDR   :="P_RCV_Data".RCV_NDR
       ERROR :="P_RCV_Data".RCV_Error
       LEN   :=
       STATUS:=

      L     "P_RCV_Instanz".i_GESAMTLAE
      T     "P_RCV_Data".aktuelle_Laenge

// Sende-Anstoß blockieren
      CLR   
      =     "P_SEND_Data".SND_Anstoss

[COLOR="Red"]// alle Statusbits der Busteilnehmer zurücksetzen
      L     0
      T     DB2.DBD  530[/COLOR]


// nutzbare Länge errechnen
      L     "P_RCV_Data".aktuelle_Laenge
      L     3
      -I    
      T     "P_RCV_Data".nutzbare_Laenge


Ralle schrieb:
Laß das ITD weg, beim Umwandeln in einen Pointer. Hatte ich auch mal, führt bei großen Int zu einem Fehler im späteren Pointer. Man darf nicht ITD wandeln denn das höchste Bit wird u.U. als Minus interpretiert und dann auch bei ITD entsprechend in der Double verschoben. Das Ergebnis ist Datenmüll als Zeiger! Das ganze funktioniert ohne ITD.
Zum Vergrößern anklicken....
Danke für den Hinweis, hatte das mit dem ITD vor längerer Zeit hier im Forum gelesen. Habs nun rausgenommen und es geht tatsächlich noch immer! :ROFLMAO:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
poppycock schrieb:
Daran habe ich auch gedacht, aber es flackern die Bits von TRUE nach FALSE und umgekehrt.
Vielleicht mache ich es aber auch falsch?!

Code: 
// SENDEN
      CALL  "P_SEND_OLD" , "P_SEND_Instanz"
       REQ   :="P_SEND_Data".SND_Anstoss
       R     :=
       LADDR :=256
       DB_NO :=3
       DBB_NO:=4
       LEN   :=1
       DONE  :="P_SEND_Data".SND_Done
       ERROR :="P_SEND_Data".SND_Error
       STATUS:=

// EMPFANGEN
      CALL  "P_RCV_OLD" , "P_RCV_Instanz"
       EN_R  :=M0.1
       R     :=
       LADDR :=256
       DB_NO :=2
       DBB_NO:=4
       NDR   :="P_RCV_Data".RCV_NDR
       ERROR :="P_RCV_Data".RCV_Error
       LEN   :=
       STATUS:=

      L     "P_RCV_Instanz".i_GESAMTLAE
      T     "P_RCV_Data".aktuelle_Laenge

// Sende-Anstoß blockieren
      CLR   
      =     "P_SEND_Data".SND_Anstoss

[COLOR="Red"]// alle Statusbits der Busteilnehmer zurücksetzen
      L     0
      T     DB2.DBD  530[/COLOR]


// nutzbare Länge errechnen
      L     "P_RCV_Data".aktuelle_Laenge
      L     3
      -I    
      T     "P_RCV_Data".nutzbare_Laenge
Zum Vergrößern anklicken....

Das sieht so aus, als ob du nun immer 0 reinschreibst. Ich würde das erst machen, bevor ich mit dem 1. Teilnehmer wieder von vorn beginne.
 
Ralle schrieb:
Das sieht so aus, als ob du nun immer 0 reinschreibst. Ich würde das erst machen, bevor ich mit dem 1. Teilnehmer wieder von vorn beginne.
Zum Vergrößern anklicken....

Das funktioniert auch nicht. Oder ich bin einfach zu blöde. :cry:
Jetzt flackert nur noch das Bit vom ersten Teilnehmer, obwohl beide antworten (Änderung ist wieder in rot dargestellt):

Code: 
// SENDEN
      CALL  "P_SEND_OLD" , "P_SEND_Instanz"
       REQ   :="P_SEND_Data".SND_Anstoss
       R     :=
       LADDR :=256
       DB_NO :=3
       DBB_NO:=4
       LEN   :=1
       DONE  :="P_SEND_Data".SND_Done
       ERROR :="P_SEND_Data".SND_Error
       STATUS:=

// EMPFANGEN
      CALL  "P_RCV_OLD" , "P_RCV_Instanz"
       EN_R  :=M0.1
       R     :=
       LADDR :=256
       DB_NO :=2
       DBB_NO:=4
       NDR   :="P_RCV_Data".RCV_NDR
       ERROR :="P_RCV_Data".RCV_Error
       LEN   :=
       STATUS:=

      L     "P_RCV_Instanz".i_GESAMTLAE
      T     "P_RCV_Data".aktuelle_Laenge

// Sende-Anstoß blockieren
      CLR   
      =     "P_SEND_Data".SND_Anstoss

// nutzbare Länge errechnen
      L     "P_RCV_Data".aktuelle_Laenge
      L     3
      -I    
      T     "P_RCV_Data".nutzbare_Laenge

// erstes Zeichen auslesen und speichern
      L     "P_RCV_Data".RCV_String[1]
      T     "P_RCV_Data".erstes_ASCII_Zeichen[1]

// zweites Zeichen auslesen und speichern
      L     "P_RCV_Data".RCV_String[2]
      T     "P_RCV_Data".zweites_ASCII_Zeichen[1]

// die ersten beiden Zeichen vergleichen
      L     "P_SEND_Data".SND_ASCII[1]
      L     "P_RCV_Data".RCV_String[2]
      <>I   
      L     S5T#50MS
      SE    T      5
      U     T      5
      SPB   INC

// verwertbare ASCII-Daten heraussuchen
      CALL  "MID"
       IN     :="P_RCV_Data".RCV_String
       L      :="P_RCV_Data".nutzbare_Laenge
       P      :=3
       RET_VAL:="P_RCV_Data".ASCII_Daten

// empfangenen ASCII-String nach INT wandeln
      CALL  "STRNG_I"
       S      :="P_RCV_Data".ASCII_Daten
       RET_VAL:="P_RCV_Data".INT_Daten

      U     "P_RCV_Data".RCV_NDR
      SPBN  nop0                        // Mache nichts, wenn keine neue Daten empfangen wurden

// Im DB die Speicherstelle generieren
      L     "P_SEND_Data".SND_ASCII[1]
      L     97
      -I    
      L     2
      *I    
      SLW   3
      LAR1  
      L     "P_RCV_Data".INT_Daten
      T     #Werte
      AUF   "P_INT_Data"
      L     #Werte
      T     DBW [AR1,P#0.0]

// Nun wird ein Bit vom antwortenden Busteilnehmer gespeichert, 
// um erkennen zu können, welcher Busteilnehmer ausgefallen ist.
// Es wird ab Byte 530 im DB2 gespeichert, darum wird DBX530.0 nach dezimal umgerechnet:
// Bit 530.0 -> 4240 dezimal.
// Da das Alphabet bei 97dez anfängt, muss man von der 4240 den Wert 97 abziehen,
// damit das erste Bit vom ersten Teilnehmer ab Bit 530.0 gesetzt wird:
// 4240 - 97 = 4143
// Teilnehmer a: 4143 + 97 = Bit 530.0
// Teilnehmer b: 4143 + 98 = Bit 530.1
// usw.
INC:  L     4143                        // Offset 4143 laden
      L     "P_RCV_Data".RCV_String[2]  // dezimalen Wert von der Busadresse laden
      +I                                // beide Werte addieren
      LAR1                              // Wert ins Adressregister 1 laden
      AUF   "P_RCV_Data"                // den dazugehörigen DB zum Speichern öffnen
      S     DBX [AR1,P#0.0]             // aus dem Wert einen Pointer generieren

// Alphabet durchzählen
      L     "P_SEND_Data".SND_ASCII[1]  // lade letztes gesendete Zeichen
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]

[COLOR="red"]// alle Statusbits der Busteilnehmer zurücksetzen
      L     0
      T     DB2.DBD  530[/COLOR]

ende: NOP   0

// fertig, Senden wieder anstoßen
      SET   
      =     "P_SEND_Data".SND_Anstoss

nop0: NOP   0
 
poppycock schrieb:
Bin noch weiter am Probieren, aber evtl. hat jemand (Vielleicht Larry?) einen Lösungsvorschlag?!
Zum Vergrößern anklicken....

So ... da bin ich wieder ...
Aber bei Ralle warst du eigentlich auch in guten Händen :)

Das "Flackern" der Bits kommt m.E. daher, dass du bei jedem Zyklus die Routine durchführst. Danach fragst du dann irgendwann ab, ob Daten gekommen sind. Das Problem ist, dass es viele Zyklen lang keine Antwort gibt. Du müßtest es wenn dann so ändern, das der Teilnehmer regelmäßig antwortet. Tut er es eine zeitlang nicht (Timeout), so setzt du dann das Bit zurück ...

Gruß
LL
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Larry! :)

Larry Laffer schrieb:
Du müßtest es wenn dann so ändern, das der Teilnehmer regelmäßig antwortet. Tut er es eine zeitlang nicht (Timeout), so setzt du dann das Bit zurück ...
Zum Vergrößern anklicken....
Und genau da wollte ich auch anfangen.
Du hast mir doch so eine Art Timeout programmiert. Das würde ich gerne verwenden.
Es klappt auch schon einigermaßen gut, aber die Bits sind noch immer am Flackern.
Kann ich denn nicht dauerhaft eine 1 im DB speichern? Kommt mir so vor, als ob die 1 immer wieder zurückgesetzt wird:

Code: 
// SENDEN
      CALL  "P_SEND_OLD" , "P_SEND_Instanz"
       REQ   :="P_SEND_Data".SND_Anstoss
       R     :=
       LADDR :=256
       DB_NO :=3
       DBB_NO:=4
       LEN   :=1
       DONE  :="P_SEND_Data".SND_Done
       ERROR :="P_SEND_Data".SND_Error
       STATUS:=

// EMPFANGEN
      CALL  "P_RCV_OLD" , "P_RCV_Instanz"
       EN_R  :=M0.1
       R     :=
       LADDR :=256
       DB_NO :=2
       DBB_NO:=4
       NDR   :="P_RCV_Data".RCV_NDR
       ERROR :="P_RCV_Data".RCV_Error
       LEN   :=
       STATUS:=

      L     "P_RCV_Instanz".i_GESAMTLAE
      T     "P_RCV_Data".aktuelle_Laenge

// Sende-Anstoß blockieren
      CLR   
      =     "P_SEND_Data".SND_Anstoss

// nutzbare Länge errechnen
      L     "P_RCV_Data".aktuelle_Laenge
      L     3
      -I    
      T     "P_RCV_Data".nutzbare_Laenge

// erstes Zeichen auslesen und speichern
      L     "P_RCV_Data".RCV_String[1]
      T     "P_RCV_Data".erstes_ASCII_Zeichen[1]

// zweites Zeichen auslesen und speichern
      L     "P_RCV_Data".RCV_String[2]
      T     "P_RCV_Data".zweites_ASCII_Zeichen[1]

// die ersten beiden Zeichen vergleichen
      L     "P_SEND_Data".SND_ASCII[1]
      L     "P_RCV_Data".RCV_String[2]
      <>I   
      L     S5T#50MS
      SE    T      5
      U     T      5
      SPB   INC

// Nun wird ein Bit vom antwortenden Busteilnehmer gespeichert, 
// um erkennen zu können, welcher Busteilnehmer ausgefallen ist.
// Es wird ab Byte 530 im DB2 gespeichert, darum wird DBX530.0 nach dezimal umgerechnet:
// Bit 530.0 -> 4240 dezimal.
// Da das Alphabet bei 97dez anfängt, muss man von der 4240 den Wert 97 abziehen,
// damit das erste Bit vom ersten Teilnehmer ab Bit 530.0 gesetzt wird:
// 4240 - 97 = 4143
// Teilnehmer a: 4143 + 97 = Bit 530.0
// Teilnehmer b: 4143 + 98 = Bit 530.1
// usw.
[COLOR="Red"]      L     4143                        // Offset 4143 laden
      L     "P_RCV_Data".RCV_String[2]  // dezimalen Wert von der Busadresse laden
      +I                                // beide Werte addieren
      LAR1                              // Wert ins Adressregister 1 laden
      AUF   "P_RCV_Data"                // den dazugehörigen DB zum Speichern öffnen
      S     DBX [AR1,P#0.0]             // aus dem Wert einen Pointer generieren
[/COLOR]
// verwertbare ASCII-Daten heraussuchen
      CALL  "MID"
       IN     :="P_RCV_Data".RCV_String
       L      :="P_RCV_Data".nutzbare_Laenge
       P      :=3
       RET_VAL:="P_RCV_Data".ASCII_Daten

// empfangenen ASCII-String nach INT wandeln
      CALL  "STRNG_I"
       S      :="P_RCV_Data".ASCII_Daten
       RET_VAL:="P_RCV_Data".INT_Daten

      U     "P_RCV_Data".RCV_NDR
      SPBN  nop0                        // Mache nichts, wenn keine neue Daten empfangen wurden

// Im DB die Speicherstelle generieren
      L     "P_SEND_Data".SND_ASCII[1]
      L     97
      -I    
      L     2
      *I    
      SLW   3
      LAR1  
      L     "P_RCV_Data".INT_Daten
      T     #Werte
      AUF   "P_INT_Data"
      L     #Werte
      T     DBW [AR1,P#0.0]

[COLOR="red"]INC:  L     4143                        // Offset 4143 laden
      L     "P_SEND_Data".SND_ASCII[1]  // dezimalen Wert von der Busadresse laden
      +I                                // beide Werte addieren
      LAR1                              // Wert ins Adressregister 1 laden
      AUF   "P_RCV_Data"                // den dazugehörigen DB zum Speichern öffnen
      R     DBX [AR1,P#0.0]             // aus dem Wert einen Pointer generieren[/COLOR]


// Alphabet durchzählen
      L     "P_SEND_Data".SND_ASCII[1]  // lade letztes gesendete Zeichen
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]

ende: NOP   0

// fertig, Senden wieder anstoßen
      SET   
      =     "P_SEND_Data".SND_Anstoss

nop0: NOP   0

Gruß,
poppycock

-----------------------------
EDIT:
Jetzt klappt es. Habe einen Sprung vergessen:
Code: 
// Im DB die Speicherstelle generieren
      L     "P_SEND_Data".SND_ASCII[1]
      L     97
      -I    
      L     2
      *I    
      SLW   3
      LAR1  
      L     "P_RCV_Data".INT_Daten
      T     #Werte
      AUF   "P_INT_Data"
      L     #Werte
      T     DBW [AR1,P#0.0]
    [B][COLOR="Red"]  SPA   abc[/COLOR][/B]

INC:  L     4143                        // Offset 4143 laden
      L     "P_SEND_Data".SND_ASCII[1]  // dezimalen Wert von der Busadresse laden
      +I                                // beide Werte addieren
      LAR1                              // Wert ins Adressregister 1 laden
      AUF   "P_RCV_Data"                // den dazugehörigen DB zum Speichern öffnen
      R     DBX [AR1,P#0.0]             // aus dem Wert einen Pointer generieren


// Alphabet durchzählen
[COLOR="red"][B]abc:[/B][/COLOR]  L     "P_SEND_Data".SND_ASCII[1]  // lade letztes gesendete Zeichen
      L     1                           // lade nächstes Zeichen
      +I    
      T     "P_SEND_Data".SND_ASCII[1]
      L     98
      >I                                // Alphabet-Ende erreicht...
      SPBN  ende
      L     97                          // ... wieder bei 'a' anfangen
      T     "P_SEND_Data".SND_ASCII[1]

ende: NOP   0
 
Zuletzt bearbeitet:
... wie ich schon geschrieben habe ...
Du empfängst ja sehr wahrscheinlich öfter nichts als das du etwas empfängst. Das Bit wird zwar beim Empfangen gesetzt, beim Nicht-Empfangen aber auch sofort wieder gelöscht. Hier müßte jetzt ein Timer oder ggf. noch besser ein Zyklenzähler kommen. Erreicht der Zyklenzähker den Wert xyz, dann löscht du das Bit und wenn du Daten empfängst dann löscht du den Zähler (den Zähler natürlich nur laufen lassen, wenn Bit gesetzt ...).

Gruß
LL

Edit:
Umso besser natürlich, wenn es jetzt dann funktioniert ...
 
Zuletzt bearbeitet:
Hallo Larry.

Ein mehrfaches Empfangen als ich überhaupt anfordere, kann nicht eintreffen.
Der CP340 steht zwar immer auf "Empfang", aber meine Busteilnehmer reagieren nur auf Befehle vom CP340.
Anbei noch meine Konfiguration vom CP340.

Die Lösung, die ich jetzt habe, finde ich gut.
Denn: Wenn ein Busteilnehmer ausfällt, wird nach 50ms der nächste Teilnehmer im Bus angesprochen.
  • Vorteil: der Bus bricht nicht zusammen, wenn ein Teilnehmer ausfällt
  • Nachteil: jedes Mal, wenn ein Tln. ausfällt, wird die Bus-Zykluszeit um 50ms verlängert
Aber mit diesem Nachteil kann ich leben, weil ja im Normalfall jeder Busteilnehmer funktioniert und auch reagiert!

Habe nur noch eine Sache zu erledigen:
Wenn absolut KEIN Teilnehmer antwortet, sollen alle Tln. auf FALSE gesetzt werden. Das funktioniert mit diesem Code noch nicht, denn es werden nie die anderen Busteilnehmer angesprochen, um das Bit zurück zu setzen.
Naja, das werde ich auch noch hinbekommen.

BTW: Jetzt wird es mir immer klarer mit den Sprüngen in AWL! *froi*

Vielen Dank,
poppycock
 

Anhänge

  • cp340_konfig.JPG
    cp340_konfig.JPG
    56,8 KB · Aufrufe: 4

Similar threads

W
Step 7 Problem mit CP340: kann nicht senden
Antworten
14
Aufrufe
5K
Wurst.feat.Senf
W
F
FX1N Klon - serielle Ausgabe über Uart/RS485
Antworten
0
Aufrufe
2K
FX1N_Klon
F
R
Step 7 ET200SP mit CM PtP - RS232 Kommunikation - Empfange keine Daten
Antworten
2
Aufrufe
7K
Bocksth
B
N
Step 7 CP340 - RS232 ASCII Datenübertragung CR/LF Problem
Antworten
9
Aufrufe
4K
Ralle
Ralle
T
CP340 ASCII Zeichen senden und empfangen
2 3
Antworten
44
Aufrufe
19K
PN/DP
PN/DP
Zurück
Oben