Kodierschschaltung mit Step 7 Awl

stevexxx

Level-1
Beiträge
40
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hab folgendes Problem


Kodierschaltung :

Hardware :
1x Einschalter
1 x Ausschalter
16 DI
24 DO (20 darf ich benützen)
2 Kodierschalter 8 Ausgänge (8 Bit)
Lampen 0-99 ansteuern mittels dieser Kodierschalter

Ich soll ich 100 lampen ansteuern (einzeln) mit diesen Kodierschaltern

hab das problem das ich 100 mal den wert der kodierschalter (eb0) abfrage weil ich keine ahnung habe wie ich das sonst anstellen soll.

Muss für jede lampe 2 Ausgänge schalten (24V 0V).

Schaltmatrix:

0.0 , 0,1....1,1
2,7 H1 H2 H10
2,6 H11.........
2,5 H21
.
.
.
1,6

also wenn ich Lampe 1 ansteuern will muss a0.0 und a 2,7 angesteuert sein. für Lampe 2 a0,1 und 2,7 usw.

weis jemand wie ich das ganze vereinfachen (verkürzen hab mom. 200 zeilen) kann bzw anhand eines kleines Bsp weiterhelfen.
Wäre für jede Hilfe dankbar
bin leider ein blutiger Anfänger in Awl


thx Steve
 
kannst du die anforderungen bitte genauer definieren? irgendwas so in richtung wahrheitstabelle oder so? ... kann deinen ausführungen nämlich nicht folgen
 
Zuviel Werbung?
-> Hier kostenlos registrieren
ok...



einfacher



habe diese 2 kodierschalter welche jeweils 4 ausgänge haben

diese schalte ich zusammen und komme auf 8 bit

Diesen zusammengesetzten Kodierschalter kann ich auf die Werte 0-99 einstellen ok...



nun habe ich das problem das ich 20 ausgänge zur Verfügung habe und anhand des wertes des kodierschalters immer 2 Ausgänge schalten muss.


Es sind insgesammt 100 Lampen die ich schalten muss
 
ok...



einfacher



habe diese 2 kodierschalter welche jeweils 4 ausgänge haben

diese schalte ich zusammen und komme auf 8 bit

Diesen zusammengesetzten Kodierschalter kann ich auf die Werte 0-99 einstellen ok...



nun habe ich das problem das ich 20 ausgänge zur Verfügung habe und anhand des wertes des kodierschalters immer 2 Ausgänge schalten muss.


Es sind insgesammt 100 Lampen die ich schalten muss

Das kann eigentlich dann nur so sein:
Die Schalter sind BCD-codiert,
die Lampen sind in einer 10x10-Matrix angeordnet.


Jeder der Schalter (BCD-kodiert) definiert ein Bit, Wert 0..9.
Ordne das so definierte das Bit des ersten Schalters den ersten 10 Ausgängen zu,
das analog definierte Bit des zweiten Schalters den restlichen 10...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ist doch ein klein wenig komplizierter, finde ich. Ich hab es mal versucht übersichtlich zu machen, das kann man mit Sicherheit noch optimieren, aber dann wird es wahrscheinlich noch weniger durchschaubar ;) . Irgendwie stimmt deine Aussage oben auch nicht ganz (die Tabelle).
Wenn du 100 Lampen mit den 8 Bit BCD-Codiert (davon geh ich mal aus) schalten willst, muß Stellung '00' Lampe 0 sein, Stellung '09', Lampe 10
Stellung '10' Lampe 11, Stellung '19' Lampe 20 ...

Also

Code:
     0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 1.0 1.1
2.7  0    1   2   3   4   5   6   7   8   9
2.6  10   11  12  13  14  15  16  17  18  19
2.5
2.4


Code:
FUNCTION FC 300 : VOID
TITLE =
AUTHOR : Ralle
FAMILY : System
NAME : Matrix
VERSION : 1.0


VAR_INPUT
  BCD_Kodierer : BYTE ;	
END_VAR
VAR_IN_OUT
  Ausgang_00_07 : BYTE ;	
  Ausgang_10_17 : BYTE ;	
  Ausgang_20_27 : BYTE ;	
END_VAR
VAR_TEMP
  Einer : INT ;	
  Zehner : INT ;	
  Einer_Bit : WORD ;	
  Zehner_Bit : WORD ;	
  Internwort_00_11 : WORD ;	
  Internword_27_16 : WORD ;	
END_VAR
BEGIN
NETWORK
TITLE =

//Einer-Stelle auslösen
      L     #BCD_Kodierer; 
      L     W#16#F; 
      UW    ; 
      T     #Einer; 

//Zehnerstelle auslösen
      L     #BCD_Kodierer; 
      SRW   4; 
      T     #Zehner; 

//Wert 1 vorbelegen zum Schieben
      L     1; 
      T     #Einer_Bit; 
      L     W#16#8000; 
      T     #Zehner_Bit; 

//Bit um den entsprechenden Wert nach links schieben
      L     #Einer; 
      L     #Einer_Bit; 
      SLW   ; 
      T     #Einer_Bit; 

//Bit um den entsprechenden Wert nach rechts schieben
      L     #Zehner; 
      L     #Zehner_Bit; 
      SRW   ; 
      T     #Zehner_Bit; 

//Ausgänge Einer 
      L     0; 
      T     #Internwort_00_11; //Intern Word mit 0 vorbelegen
      L     #Ausgang_00_07; //rechtes Byte
      OW    ; 
      L     #Ausgang_10_17; //linkes Byte
      SLW   8; 
      OW    ; 
      T     #Internwort_00_11; //Byte 1+2 ist nun in Internword_00_11
      L     W#16#3C00; //Maske, um nur die Bits 0.0-1.1 zu löschen
      UW    ; //Bit 0.0-1.1 löschen
      L     #Einer_Bit; //Einer-Bit laden
      OW    ; //Bit 0.0-1.1 setzen
      T     #Internwort_00_11; //wieder auf Ausgang schreiben

      L     0; 
      T     #Internword_27_16; //Intern Word mit 0 vorbelegen
      L     #Ausgang_10_17; //rechtes Byte
      OW    ; 
      L     #Ausgang_20_27; //linkes Byte
      SLW   8; 
      OW    ; 
      T     #Internword_27_16; //Byte 3+2 ist nun in Internword_27_16
      L     W#16#3C; //Maske, um nur die Bits 2.7-1.6 zu löschen
      UW    ; //Bit 2.7-1.6 löschen
      L     #Zehner_Bit; //Zehner-Bit laden
      OW    ; //Bit 2.7-1.6 setzen
      T     #Internword_27_16; //wieder auf Ausgang schreiben

//Ausgänge zurückschreiben
//Byte 1 zurückschreiben
      L     #Internwort_00_11; 
      L     W#16#FF; 
      UW    ; 
      T     #Ausgang_00_07; 

//Byte 3 zurückschreiben
      L     #Internword_27_16; 
      SRW   8; 
      T     #Ausgang_20_27; 

//Byte 2 (Mitte) zurückschreiben
      L     #Internwort_00_11; 
      SRW   8; //nur linkes Byte
      T     #Ausgang_10_17; 

      L     #Internword_27_16; 
      L     W#16#FF; //nur rechtes Byte
      UW    ; 
      L     #Ausgang_10_17; 
      OW    ; 
      T     #Ausgang_10_17; 
END_FUNCTION

ORGANIZATION_BLOCK OB 1
TITLE = "Main Program Sweep (Cycle)"
VERSION : 0.1


VAR_TEMP
  OB1_EV_CLASS : BYTE ;	//Bits 0-3 = 1 (Coming event), Bits 4-7 = 1 (Event class 1)
  OB1_SCAN_1 : BYTE ;	//1 (Cold restart scan 1 of OB 1), 3 (Scan 2-n of OB 1)
  OB1_PRIORITY : BYTE ;	//Priority of OB Execution
  OB1_OB_NUMBR : BYTE ;	//1 (Organization block 1, OB1)
  OB1_RESERVED_1 : BYTE ;	//Reserved for system
  OB1_RESERVED_2 : BYTE ;	//Reserved for system
  OB1_PREV_CYCLE : INT ;	//Cycle time of previous OB1 scan (milliseconds)
  OB1_MIN_CYCLE : INT ;	//Minimum cycle time of OB1 (milliseconds)
  OB1_MAX_CYCLE : INT ;	//Maximum cycle time of OB1 (milliseconds)
  OB1_DATE_TIME : DATE_AND_TIME ;	//Date and time OB1 started
END_VAR
BEGIN
NETWORK
TITLE =

      CALL FC   300 (
           BCD_Kodierer             := MB    10,
           Ausgang_00_07            := AB     0,
           Ausgang_10_17            := AB     1,
           Ausgang_20_27            := AB     2);

END_ORGANIZATION_BLOCK

Die Ausgangsbits 1.2, 1.3, 1.4, 1.5 werden von der Funktion nicht verändert/beeinflußt.
Den Code kannst du in eine AWL-Quelle kopieren, dann übersetzen und du hast einen FC300 und einen OB1. Vorsicht, vorhanden Bausteine werden beim Übersetzen überschrieben.

Es geht natürlich auch mit einigen Vergleichern und der entsprechenden Bitzuordnung (siehe argv_user), aber das mit dem Schieben gefiel mir irgendwie besser :).
 
Zuletzt bearbeitet:
danke

aber laut meine kollegen soll es noch eine einfachere Lösung geben mit nur ein paar zeilen (über pointer ausgangsadressen berechnen) kA ja hmm :(



bis i des hab bin i 100 aber danke dir
 
Zuletzt bearbeitet:
Ja, das geht tatsächlich auch.
Wenn du einen Pointer auf ein AW z.Bsp, A0.0 bildest und dann 5 dazu addierst kannst du damit A0.5 adressieren, dein Einerbit.
Dann könntest einen Pointer auf A2.7 zu bilden und den Zehnerwert von diesem subtrahieren. Damit hättest du dein Zehnerbit. Dann noch die Ausgangsbits behandeln, die nicht für die Matrix genutzt werden, damit man die auch anderweitig verwenden kann. Das könnte tatsächlich noch ein wenig kürzer sein, weil ich wegen der Schieberei die 3 Byte erst auf 2 Worte rangiert habe und dann wieder zurück.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
es sollte mit pointern gemacht werden bisheriger code:


L P#0.0
L MB 1
+I
T MD 20

L P#2.7
L MB 2
-I
T MD 21


U "S1"
S A [MD 20]

U "S1"
S A [MD 21


...............................

mb1 wert 0-9 kodierschalter 1
mb2 wert 0-9 kodierschalter 2




jetz brauch i nur noch a berichtigung von meinen code sodass er funktioniert gg

please help


thx!!!
 
Zuletzt bearbeitet:
sollte auch mittels wortschiebereien gehn

aber naja so komplex denken kann i net *gg*




mein bisheriger code:


L MB 1 // Zehnerstellen
L 10
/I
T MW 0

L MB 1 // Einerstellen
L 10
MOD
T MW 1

L MW 0 //verschieben der Ausgänge 0.0 bis 1.1
L AW 0
SRW
T AW 0

L MW 0 // verschieben der Ausgänge 2.7 bis 1.6
L AW 0
SLW
T AW 2




(in mb1 steht die zahl der lampe die ich anwähle geht von 1-100)



naja vl könntest mir ein bisschen weiter helfen danke

Na ja, das genau habe ich ja oben in dem Baustein gemacht, wobei ich davon ausgegangen bin, daß der Codierschalter bei 2x4Bit gleich BCD liefert, was eigentlich üblich ist. Mit 2 Worten war mein erster Code auch extrem kurz, aber da du 3 Byte (0,1,2) benutzt, wurde das dann leider etwas aufwendiger. :ROFLMAO:

An deiner Stelle würde ich die Pointervariante mal versuchen. Probiere es mal so, ohne Gewähr, nicht getestet, nur schnell zusammengeschrieben ;)!

Code:
//die unbenutzten Ausgänge merken, den Rest löschen
L AB1 //unbenutzen Ausgänge 
L 2#0011_1100
UW //nur die von der Matrix nicht genutzten merken!
T #Merk_AB1 //Byte!!!
L 0
T AB0
T AB1
T AB2

L P#0.0
L Einer  //INT Einer
+D
LAR1
S A[AR1, P#0.0] //Einerbit setzen, das läuft ja von 0.0 an vorwärts

L P#0.0
L 24
+D
L Zehner  //INT Zehner
-D
LAR1
S A[AR1, P#0.0] //Zeherbit setzen, das läuft ja von 2.7 an rückwärts!

L AB1
L #Merk_AB1  //die gemerkten Ausgänge wieder einblenden
OW
T AB1
 
Zuletzt bearbeitet:
danke Ralle das war genau die Antwort welches mein problem am einfachsten lösen konnte


1000000x danke!!!!!


lg steve
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Also ich denke mal nicht so kompliziert.
Das Programm ist nur unwesentlich länger als das von Ralle, dafür kann man 90% der Zeilen kopieren und jeder Elektriker wird verstehen können, wie es gemacht wird.

Kodierschalter liegt auf EB0, das Listing behandelt den einen Vektor der Matrix. Für den zweiten Vektor muss man nur das Netzwerk kopieren und mit Suchen&Ersetzen die E 0.0 - 0.3 gegen E 0.4 - 0.7 austauschen, die Ausgänge ändern von A 0.0 - A 1.1 auf A 2.7 - A 1.5 und fertig.

Code:
     U     E      0.0
      UN    E      0.1
      UN    E      0.2
      UN    E      0.3
      =     A      0.0
 
      UN    E      0.0
      U     E      0.1
      UN    E      0.2
      UN    E      0.3
      =     A      0.1
 
      U     E      0.0
      U     E      0.1
      UN    E      0.2
      UN    E      0.3
      =     A      0.2
 
      UN    E      0.0
      UN    E      0.1
      U     E      0.2
      UN    E      0.3
      =     A      0.3
 
      U     E      0.0
      UN    E      0.1
      U     E      0.2
      UN    E      0.3
      =     A      0.4
 
      UN    E      0.0
      U     E      0.1
      U     E      0.2
      UN    E      0.3
      =     A      0.5
 
      U     E      0.0
      U     E      0.1
      U     E      0.2
      UN    E      0.3
      =     A      0.6
 
      UN    E      0.0
      UN    E      0.1
      UN    E      0.2
      U     E      0.3
      =     A      0.7
 
      U     E      0.0
      UN    E      0.1
      UN    E      0.2
      U     E      0.3
      =     A      1.0
 
      UN    E      0.0
      U     E      0.1
      UN    E      0.2
      U     E      0.3
      =     A      1.1
 
danke für die antwort aber mit pointer ist´s besser da mir das bsp helfen sollte dazu zu lernen


so nach dem motto was wäre wenn statt 100 lampen 1000 000 anzusteuern wären?


lg steve
 
Akzeptiert.
Ich wollte mit dem Beispiel nur zeigen, dass die Aufgabe auch ein Programmierer lösen kann, der die Arbeit mit Zeigern nicht beherrscht.

Ich komme eben aus einer Vergangenheit, in der man solchen "Schnickschnack" wie Zeiger nicht hatte.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
anfangs hat mei programm so ausgschaut das ich die werte der kodierschalter abgefragt habe (20mal) und des wird dann ein bisschen lang


vorallem wenn es heißt die Zykluszeit soll möglichst kurz gehalten werden ...


naja wo anfangen wenn man null ahnung von pointern hat

aba jetzs hab ichs so einigermaßen gecheckt

danke nochmal für die unterstützung von dieser special Forum


lg steve
 
Tja zu früh gefreut...

chef will es so das ich bcd codiere sprich


meine 2 kodierschalter als ganzes ansehen

und nicht mit einem kodierschalter die zeile und mit dem andern die spalte angeben



hmmm....





dh wenn ks2 = 9 ks1=0 wähle ich lampe 91 aus (von 0 beginnent)


hab wieder mal keine ahnung wie er das meint that´s reality

jemand nenn plan?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Sag mal, die Vorgabe für die Matrix mit den Ausgängen A0.0-A1.1 und für die andere Seite der Matrix mit A2.7-A1.5 gibt es dafür einen Hintergrund oder kann man die frei wählen aus dem verfügbaren Adressbereich der vorhandenen Hardware ?
 
Tja zu früh gefreut...

chef will es so das ich bcd codiere sprich


meine 2 kodierschalter als ganzes ansehen

und nicht mit einem kodierschalter die zeile und mit dem andern die spalte angeben



hmmm....





dh wenn ks2 = 9 ks1=0 wähle ich lampe 91 aus (von 0 beginnent)


hab wieder mal keine ahnung wie er das meint that´s reality

jemand nenn plan?

Versteh ich nicht, das ist doch eine reine Definitionssache. Wenn man 100 Lampen mit nem BCD-Schalter anwähle will, dann ist bei '00' halt Lampe 1 dran usw. Ich weiß nicht genau was er nun von dir will, laß dir das nochmal erklären.
 
also ausgänge hätte ich 0.0 bis 2.7 zur verfügung


da ich aber immer 2 ausgänge schalten muss um 1 lampe zum leuchten zu bringen muss ich 0.0-1.1 und 2.7-1.6 auswählen
da es sonst zu überschneidungen kommt sprich es wird nur ein ausgang angesteuert anstatt 2

naja tricky
 
Zurück
Oben