B&R: BCD-CODE Einlesen mit reAction-Modul

[APROLmicha]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,
Ich versuche seit einiger Zeit mehr oder Weniger erfolgreich eine gemultiplexte 7-Segment-Anzeige einer Maschine mit BCD-CODE einzulesen, um Fehler zu Visualisieren. Bis jetzt wird den Bedienern nur ein Fehlercode angezeigt, was neuen bzw. unerfahrenen Bedienern zum Verhängnis wird. Die Neue Anzeige soll dann auf einem Signage-Display erfolgen in Klartext.
Leider bekomme ich einige Ziffern nicht mit bzw. es werden Ziffern erkannt, die nicht angezeigt werden.
Es handelt sich um eine WiBond Anzeige mit 6 Stellen (Datenblatt angehängt).
Den Code hab ich mal angehängt, auch wenn er einige versuche noch enthält. Simuliere ich dann wird alles richtig erkannt.
Verwendet wird eine B&R X20CP1584 mit einem reAction Eingangsmodul (aufgrund der möglichen kurzen Zeiten).
Die Anzeige hat einen Ausgangsstecker auf dem ich mit dem SPS-Modul daraufhänge. Auch ein Direkter Anschluss an die SPS der Maschine hilft nicht weiter.

Wie würdet ihr daran gehen?

PROGRAM _CYCLIC
	RTEnable := TRUE;
	
	f_trig_0(CLK := CS);
	r_trig_0(CLK := CS);
	
	IF CS AND Strobe THEN
			
//Adresse zusammen setzen		
		Bit2Byte_01.bitadr := ADR(adressarray[0]); (* get adress of bit array *)
		Bit2Byte_01.length := 8;
		Bit2Byte_01(bitadr := ADR(adressarray), length := 8); (* convert bit array into byte array *)
		adress1 := Bit2Byte_01.byteadr; (* get adress of byte array *)
		memcpy(ADR(adress), adress1, 2);
			
		IF adress <> adressold THEN
			arraycounter := arraycounter + 1;
			adressdatabase[arraycounter] := adress;
			IF arraycounter = 512 THEN
				arraycounter := 0;
			END_IF
			adressold := adress;
		END_IF
		
		
// Zeichen-Bits erstellen
		IF D1 THEN 
			z0 := 1 ;
		ELSE z0 := 0;	
		END_IF
		
		IF D2 THEN 
			z1 := 2 ;
		ELSE z1 := 0;
		END_IF
		
		IF D3 THEN 
			z2 := 4 ;
		ELSE z2 := 0;
		END_IF
		
		IF D4 THEN 
			z3 := 8 ;
		ELSE z3 := 0;
		END_IF
			


// Zeichen Bilden
		Zeichen := z0 + z1 + z2 + z3;		
			
		Zifferarray[adress] := Zeichen;
		
//Zeichen umwandeln & String bilden
		sZiffer0 := INT_TO_STRING(Zifferarray[0]);
		sZiffer1 := INT_TO_STRING(Zifferarray[1]);
		sZiffer2 := INT_TO_STRING(Zifferarray[2]);
		sZiffer3 := INT_TO_STRING(Zifferarray[3]);
		sZiffer4 := INT_TO_STRING(Zifferarray[4]);
		sZiffer5 := INT_TO_STRING(Zifferarray[5]);
		sZiffer6 := INT_TO_STRING(Zifferarray[6]);
		sZiffer7 := INT_TO_STRING(Zifferarray[7]);


//FehlerString Leeren	
	        FehlerstringZiffer := leerstring;
		
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer7));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer6));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer5));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer4));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer3));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer2));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer1));
		strcat(ADR(FehlerstringZiffer), ADR(sZiffer0));
		
//Fehlernummern Abspeichern
		IF FehlerstringZiffer <> FehlerstringZifferOld THEN
			//MpAlarmXSet(gAlarmXCore,FehlerstringZiffer);//
			arraycounter1 := arraycounter1 + 1;
			Fehlerstringdatabase[arraycounter1] := FehlerstringZiffer;
			IF arraycounter1 = 512 THEN
				arraycounter1 := 0;
			END_IF
		
		
			FehlerstringZifferOld := FehlerstringZiffer;
	
		END_IF
		
				
	END_IF
			
END_PROGRAM

Vielen Dank schonmal!

grüße
Micha

 

[Heinileini]

An der Schnittstelle hast Du
- 4 DatenBits
- 3 AdressBits
- 1 Bit für DezimalPunkt
- 1 StrobeBit
Das LampenTestBit kannst Du ignorieren.
Du müsstest klären,
- ob er DezimalPunkt statt einer Ziffer angezeigt wird oder
- ob er mit einer Ziffer angezeigt wird und, wenn ja,
- ob der Punkt links oder rechts der Ziffer angezeigt wird.
- welche Adresse welcher Stelle in der Anzeige entspricht (sozusagen, ob die 6 Stellen von links nach rechts oder umgekehrt durchnumeriert sind).
AdressBits und DatenBits darfst Du nur auswerten, wenn das StrobeBit high ist.
Was es mit dem CS-Bit auf sich hat, habe ich nicht verstanden. Könnte sozusagen ein StrobeBit für die Übernahme der AdressBits sein.
Wahrscheinlich kannst Du das CS-Bit ignorieren, weil es vermutlich nur für eine hardwaremässige Auswertung in der AnzeigeEinheit von Bedeutung ist.
Wertest Du die Eingänge in genügend kurzen Abständen aus oder könnten StrobeBits überlesen werden?

Gruss, Heinileini

 

[APROLmicha]

Zuviel Werbung?
-> Hier kostenlos registrieren

Also einen Dezimalpunkt gibt es nicht. In welcher Richtung die Ziffern durchnummeriert sind kann ich dir aus dem Stehgreif nicht sagen, müsste ich nochmal nachsehen.
Schnell genug sind die Eingänge und die Verarbeitung. Arbeite mit 1mSek Zykluszeit

 

[Heinileini]

Sorry, ich habe mir erst jetzt die im Diagramm angegebenen Zeitwerte genauer angesehen.
T3 (der Strobe) ist mindestens 5 µs und höchstens 200 µs lang. Mindestens 5 µs bedeutet, dass die ZyklusZeit kleiner als 5 µs sein müsste.
Davon bist Du trotz einer schon recht sportlichen ZyklusZeit von 1 ms noch weit entfernt.
Ich würde mich auch nicht darauf verlassen, dass ein sooo kurzer Impuls am HardwareEingang überhaupt (zuverlässig) an das SPS-Programm weitergegeben wird.
Das ist eine ganz andere GrössenOrdnung als das, wofür SPS konstruiert sind. Schnelle "ZählerKarten" können das Problem leider nicht entschärfen.

Du schreibst "Die Anzeige hat einen Ausgangsstecker auf dem ich mit dem SPS-Modul daraufhänge.". Gilt das ZeitDiagramm (auch) für diese Schnittstelle?

Von wo kommen denn die Informationen, die an der AnzeigeEinheit ankommen? Gibt es an der Quelle eine andere Möglichkeit, die Daten abzuzapfen?
Oder könnte man dort eine deutlich langsamere Übertragung einstellen?

Ich fürchte, Dein Projekt ist zum Scheitern verurteilt.

Gruss, Heinileini

 

[Bitmanipulator]

Typische reAction Module weisen einen Eingangsfilter von kleiner 3us auf. Wenn also Signale mit mindestens 5us ankommen, so sollten sie ausgewertet werden können. Ich würde mich zunächst an eine Stelle wagen. Wenn die sicher ausgewertet werden kann, kommen die weiteren, bis sich der komplette Fehler-Code in voller Schönheit zeigt.

 

[PN/DP]

Zuviel Werbung?
-> Hier kostenlos registrieren

Typische reAction Module weisen einen Eingangsfilter von kleiner 3us auf. Wenn also Signale mit mindestens 5us ankommen, so sollten sie ausgewertet werden können.

"Eingangsfilter" bedeutet nicht "Abfragezyklus"
Können die reAction-Module alle 5µs abgefragt werden? Oder können sie Prozessalarme/Interrupts? Oder die kurzen Impulse irgendwie zwischenspeichern? Wie schon im Beitrag vor Dir erwähnt wurde: "Mindestens 5 µs bedeutet, dass die ZyklusZeit kleiner als 5 µs sein müsste."

Harald

 

[Heinileini]

Typische reAction Module weisen einen Eingangsfilter von kleiner 3us auf.

Super, dann wird das also nicht zum Problem.
Aber wie soll das funktionieren, einen 5 µs langen Impuls nicht nur zufällig, sondern verlässlich zu "erwischen", wenn er irgendwann mal im 1 ms Zyklus auftritt?
Und der nächste StrobeImpuls bereits 1 ms danach? Allein letzteres (bei einem entsprechend längeren StrobeSignal) würde bedingen, dass die ZyklusZeit nicht grösser als 500 µs wird.
Wahrscheinlich denke ich zu sehr in Siemens, aber mit einem ProzessAbbild ist das nicht praktikabel. Ein Polling des StrobeEingangs alle 2,5 µs ist wohl auch nicht allzu praktikabel, weil die CPU dann kaum noch für andere Arbeiten zur Verfügung steht. Harald hat's gerade geschrieben: ProzessAlarm/Interrupt. Das wäre das Optimium.

Wenn das Abfragen mit einer Stelle funktioniert und dabei bereits die 3 AdressBits als Index für die Stelle benutzt werden, ist der Schritt von 1 Stelle zu 6 (max. 8 )Stellen tatsächlich kein grosser Sprung für die Menschheit mehr. Das Abfragen einer Stelle "zum Einüben" empfinde ich in diesem Zusammenhang als ziemlich "over fluid".

Gruss, Heinileini

 

[Bitmanipulator]

Ich gehe mal davon aus, dass der Themenstarter mit dem Oszilloskop die Signaldauer gemessen hat. Wenn man hier tatsächlich an der 5us Grenze liegt, dann muss man nochmal nachdenken, ob der Ansatz der richtige ist. Ansonsten gilt für reAction Module, dass der Code direkt auf dem Modul abgearbeitet wird und man frei von der SPS-Zykluszeiten ist. Signaleingang/Verarbeitung/Signalausgabe kann damit in 1us realisiert werden (https://www.br-automation.com/de-de/technologie/reaction-technology/).

 

[APROLmicha]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo und erstmal vielen dank für die vielen Tipps & Antworten.
Das Problem ist das ich die Zykluszeit der RT-Karte auf 1µs runterschrauben kann, aber der Buszyklus des X2X kann minimal 100µs. Ich verlängere die Impulse nur auf der Karte damit sie von der SPS eingelesen werden können. Auf der Karte selber kann ich die Signale nicht verwursten, da der Funktionsumfang nicht grade Groß ist in der Speziellen Bibliothek von B&R.
Mit dem OSZI war ich selber noch nicht dran, da die Anlage an einem anderen Standort steht. Ich muss mal schauen ob ich da die Tage mal hin komme. Zur zeit hab ich Schicht da laufen Projekte "nebenbei".

Die Maschinensteuerung ist eine recht alte SPS (so vom Baujahr ca. 2000) von ich glaube Eberspächer. Kommunizieren tut sie über einen LWL-BUS.
Der Maschinenhersteller aus der Schweiz ist leider nicht sehr Hilfsbereit, aber auch an der Front kämpfe ich.

Ich habe schon überlegt die Umwandlung durch einen Arduino o.Ä. machen zu lassen und per Ethernet dann die Störungen auf dem Display anzeigen zu lassen.
Aber das ist ja bekanntlich nicht die beste Methode für Industrielle Umgebungen.

Schönen Abend euch noch

grüße
Micha

 

[Heinileini]

Auf der Karte selber kann ich die Signale nicht verwursten, da der Funktionsumfang nicht grade Groß ist in der Speziellen Bibliothek von B&R.

Trotzdem stimmt mich das und Bitmanipulators Link recht zuversichtlich!
Mit dem Link bin ich leider nicht zu halbwegs konkreten Angaben durchgedrungen.
Das allgemeine BlaBla klingt nicht schlecht, aber was will das schon heissen.
Ganz offensichtlich liegt der SchwerPunkt auf vorgefertigten Funktionen und auf der Lieferung von kundenspezifischen Entwicklungen.
Verfügst Du denn über etwas genauere Angaben über BefehlsUmfang, Schnittstellen zur SPS?
Könntest Du denn ein eigenes Programm nicht nur auf die Karte laden, sondern evtl. auch einigermassen testen?
So wahnsinnig komplex ist Deine Aufgabe doch gar nicht. ("Wir schaffen das!")
Es müsste doch möglich sein, die 8 Eingänge in 1 StrobeBit, 3 AdressBits und 4 DatenBits zu "zerlegen".
Im richtigen Moment (pos. Flanke von Strobe) die DatenBits um Adresse mal 4 Bits zu verschieben und zum Zwischenergebnis dazuzuodern.
Wenn Einlesen eines 6-Stellen-Zyklus fertig ist, die 3 Byte oder das DoppelWort irgendwohin kopieren, wo sich die SPS - so oft sie will - die BCD-Zahl abholen kann und das ZwischenErgebnis löschen.
Ein 32-Bit-Akku wäre super und verunden, verodern bzw. schieben 32-bitweise.
Eine Umwandlung von BCD in irgendwas anderes muss ja nicht auf der Karte geschehen.
Das EingangsByte kannst Du vermutlich nach eigenem Gutdünken belegen.
Um in Gang zu kommen, würde ich
Bit 7 : Strobe
Bit 6 : AdressBit2
Bit 5 : AdressBit1
Bit 4 : AdressBit0
Bit 3 : DatenBit3
Bit 2 : DatenBit2
Bit 1 : DatenBit1
Bit 0 : DatenBit0
vorschlagen.

Eine Verlängerung der 8 Signale um ca 500 µs wäre für meinen Geschmack zu aufwendig. Lieber gleich und zielführend so wie oben angedeutet verfahren.
Gegen ein Polling des StrobeEingangs hätte ich auch nichts einzuwenden, da ja lediglich die Karte damit beschäftigt ist und nicht die ZyklusZeit der SPS in die Höhe getrieben wird.

Gruss, Heinileini

Edit:

Strobe := InByte AND 80h  
IF Strobe > 0 AND StrobeOld = 0 THEN  
    Address := InByte AND 70h 
    IF Address = 0 THEN  
        Result := Temp
        Temp := 0
        ENDIF
//  IF Invers <> 0 THEN  // influence order and position of digits
//      Address := Invers - Address 
//      ENDIF
    Address := Address / 4   // shift right by 2 BitPositions 
    Data := InByte AND 0Fh 
    Data := Data * Address   // shift left by Nr of BitPositions in Address 
    Temp := Temp OR Data 
    ENDIF 
StrobeOld := Strobe

 

[roger34]

Es gibt ja Flankekennung, Multiplexer, Demultiplexer Damit könnte man ja entspreched der 8 Adressen die Daten auf 8 verschiedene Speicherstellen schreiben.
Aber ich habe mit dem reaction Modul noch nicht gearbeitet.

Wie sieht momentan dein Programm im Reaction Teil aus ?
Du kannst die Daten max. von Strobe zu Strobe verlängern. Wenn Strobe zu Strobe 1ms ist müsste ja die Zyluszeit unter eine ms stellen.

 

[APROLmicha]

Zuviel Werbung?
-> Hier kostenlos registrieren

"Wir schaffen das!"

Ja das werden wir.
Danke zunächst für eure antworten und auch den Code.
Leider ist einem beim reAction keine möglichkeit der ST-Verarbeitung gegeben- nur FUB... (was mich tierisch ärgert...)

Wie sieht momentan dein Programm im Reaction Teil aus ?

Ist zwar nicht alles und etwas durcheinander aber sollte das WIE eigentlich darstellen- Mit dem TP verlängert man die Impulse um in diesen fall 220 Zyklen, also 220µs.
Mit dem Byte-Transfer aufs ausgangs-abbild der karte kommen die gleichen Daten raus wie mit den einzelnen Bits.

hier die vorhandenen FUB's aus der Bibliothek:


Schönen Abend euch noch

der müde Nachtschicht-Micha