Addierer

Zuviel Werbung?
-> Hier kostenlos registrieren
_Praktikant_ schrieb:
Mir wurde am anfang dword gesagt -> beides möglich??
Zum Vergrößern anklicken....

Ja, es ist beides möglich, ich habs mal probiert. Mit DInt ist die Eingabe am Input des FC einfacher, ab DW#16#7FFFFFFF (größte DINT) wird dann so oder so in der Variablentabelle bei Einstellung DEZ immer eine Negative Zahl bei Addition angezeigt.

DW#16#7FFFFFFF
+
DW#16#00000002
=
DW#16#80000001
--> L#-2147483647 (mit Vorzeichen) (das ist so, weil die DINT "überläuft")
oder
--> 2147483649 (ohne Vorzeichen)

Ich bin mir im Moment nicht sicher, die Vorzeichengeschichte und DWord/DInt sind eigentlich eher ein Problem der Darstellung auf dem Bildschirm. Ob man ein Rechenergebnis als Zahl größer 2147483647 oder als neagtive Zahl interpretiert hängt letztlich davon ab, was man braucht.

Wenn ich da falsch liege korrigiert mich bitte, hab darauf noch nie zu viele Gedanken verschwendet.


_Praktikant_ schrieb:
Ist hier kopieren von werten aus DB in temp-var gemeint?
Zum Vergrößern anklicken....


Summand_1, Summand_2 sind IN
Ergebnis OUT

Du legst hintereinander 3 Temp-Var an

Summand_1_temp, Summand_2_temp, Ergebnis_temp

Die Input kopierst du in die Temp, dann kannst du mit AR1 und dem Offset alle 3 Variablen adressieren, der Ergebnis_temo zum Schluß in die Out kopieren.

Code: 
      L     32; 
      L     #Schleifenzaehler; 
      -I    ; 
      +AR1  ;
bedeutet:

AR1 := AR1 + (32 - #Schleifenzähler)

(Onkel macht das anders, der rechnet in jeder Schleife AR1 := AR1 + P#0.1, und baut immer auf dem AR1 aus der vorhergehenden Schleife auf. Ich rechne das AR1 jedesmal am Anfang der Schleife neu aus. Beides führt zum Ziel.)

Der Schleifenzähler beginnt ja bei 32 und wird dann von Loop bis 0 runtergezählt. Die duale Berechnung beginnt aber bei 0 und wird bis Bit 32 aufwärts durchgeführt.

_Praktikant_ schrieb:
Was fehlt denn noch alles bei der schleife von onkel dagobert?
XOR-verknüpfung von s1,s1 und altem übertrag und...?
Zum Vergrößern anklicken....

Onkel hat das mit AR1 und AR2 gemacht, das geht auch.
Und er hat das AR1 und AR2 etwas anders hochgezählt für die Erhöhung der Bitnummer.
Außerdem fehlt die Berechnung des jeweils neuen Übertrages, darauf bist du ja oben eingegangen, ist in dem Wiki-Beitrag ja schön zu sehen.
 
Zuletzt bearbeitet:
Er kann auch Taschnrechner spielen.

0 + 0 ergibt 0,
0 + 1 ergibt 1,
1 + 0 ergibt 1,
1 + 1 ergibt 0 mit Übertrag von 1 auf die nächsthöherwertige Stelle.

Er Wetet den letzten Bit der beiden Binärzahlen aus und hat ein Merkberit für die nächsthöherwertge Stelle, das Ergebniss in eine neue Binärzahl.

Je nachdem ob er Word oder Doppelword oder String nimmt muss halt der Loop lang sein.

Ist normal ne Übungsaufgabe aus Assembler.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
maxi schrieb:
Er kann auch Taschnrechner spielen.

0 + 0 ergibt 0,
0 + 1 ergibt 1,
1 + 0 ergibt 1,
1 + 1 ergibt 0 mit Übertrag von 1 auf die nächsthöherwertige Stelle.

Er Wetet den letzten Bit der beiden Binärzahlen aus und hat ein Merkberit für die nächsthöherwertge Stelle, das Ergebniss in eine neue Binärzahl.

Je nachdem ob er Word oder Doppelword oder String nimmt muss halt der Loop lang sein.

Ist normal ne Übungsaufgabe aus Assembler.
Zum Vergrößern anklicken....

Ja, aber er soll doch nicht addieren, jedenfalls nicht mit "+" und Add, also bleibt nur die logische Auswertung per U, O, X, UN ...
 
Hi Ralle

Will hier NICHT nerven.


Ja, aber er soll doch nicht addieren, jedenfalls nicht mit "+" und Add, also bleibt nur die logische Auswertung per U, O, X, UN ...
Zum Vergrößern anklicken....
Oder eine Subtraktion mit der ( 2.Zahl * -1)
;)

@Praktikant
Wurde WIRKLICH mit "Indirekter Adressierung ... " gesagt ?
 
Ralle schrieb:
Ja, aber er soll doch nicht addieren, jedenfalls nicht mit "+" und Add, also bleibt nur die logische Auswertung per U, O, X, UN ...
Zum Vergrößern anklicken....

Kann er ja mit Und, Oder, S, R machen.

Ich weiss aber noch was geileres :)

Einen Zähler *fg*
bzw. wenn ganz ohne Addieren dann mit 3 zählern *lach*
 
Die hatten mich ned so lieb wie ich war.
Wollen nur perfekte arische Signatruren.
Ich wurde Diknriminiert! *spass*

Lassen wir die Diskussion aber, das kannst du mir Privat mitteilen. Mag keien Zirkusveranstaltung hier mehr.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
_Praktikant_ schrieb:
..Was fehlt denn noch alles bei der schleife von onkel dagobert?..
Zum Vergrößern anklicken....

Code: 
[COLOR=blue]... AR1 sichern (TAR1)[/COLOR]
[COLOR=blue]... Summanden in Lokaldaten kopieren[/COLOR]
[COLOR=blue]... Adressen der Summanden in AR1 und AR2 laden (LAR1, LAR2)[/COLOR]
[COLOR=#0000ff]... Übertrag initialisieren (auf "0" setzen)[/COLOR]
 
      L     32
L001: T     #TEMP_INT
//*** Binärergebnis unter Berücksichtigung des Übertrag
      X      [AR1,P#0.0]
      X      [AR2,P#0.0]
      X     #UEBERTRAG
      =     #EINS                       // Ergebnisbit
 
//*** Übertrag
[COLOR=blue]... Ein neuer Übertrag erfolgt, wenn [/COLOR]
[COLOR=blue]... beide bits in den Zahlen "1" sind, ODER [/COLOR]
[COLOR=blue]... ein bit "1" ist UND ein aktueller Übertrag ansteht.[/COLOR]
      =     #UEBERTRAG
 
      U     #EINS
      =      [AR2,P#0.0]                // am Ende steht die Summe in AR2
 
      +AR1  P#0.1
      +AR2  P#0.1
      L     #TEMP_INT
      LOOP  L001
 
[COLOR=blue]... Summe, welche über AR2 in eine der Variablen[/COLOR]
[COLOR=blue]..."Summand" abgelegt wurde, in die Variabe "Summe" kopieren[/COLOR]
[COLOR=blue]... AR1 wieder herstellen (LAR1)[/COLOR]
[COLOR=blue].[/COLOR]

Wenn du das so umsetzt, hast du deinen ersten Erfolg. Beim Testen wirst du jedoch feststellen, dass es nicht über den ganzen 32-Bitbereich funktioniert. Aber bring es erst einmal soweit zum laufen, das solltest du schaffen.


Gruß, Onkel
 
Ok, dann werd ich versuchen die sachen morgen umzusetzen :sm5:!
Was mir grad noch etwas unklar im bsp von ralle ist, sind die 4 zeilen
1.
HTML: 
L 32
L #Schleifenzaehler
-I
T #Zaehlvar
Zum Vergrößern anklicken....
Was ist mit T #Zaehlvar
passiert bzw. wie/wozu wird die verarbeitet?
und dann 2.
HTML: 
      L     32; 
      L     #Schleifenzaehler; 
      -I    ; 
      +AR1  ;
Zum Vergrößern anklicken....
Ist doch der bitweise durchlauf der zahl (wie die andere möglichkeit von onkel)?
Danke nochmals und schönen abend noch...
 
_Praktikant_ schrieb:
1. Was ist mit T #Zaehlvar
passiert bzw. wie/wozu wird die verarbeitet?
Zum Vergrößern anklicken....

Das war nur ein Anfangsbeispiel mit Zaehlvar als Zwischenmerker

Statt

T #Zahelvar
L #ZaehlVar
+AR1

gleich

+AR1

_Praktikant_ schrieb:
2. Ist doch der bitweise durchlauf der zahl (wie die andere möglichkeit von onkel)?
Zum Vergrößern anklicken....

Ja genau, das hast du richtig erkannt und damit schon mal eine ganze Menge verstanden :-D. Wie ich schon schrieb ist Onkel ein wenig anders herangegangen, das Ergebnis ist das Selbe.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

hier mal ein versuch von mir:
Code: 
 L     #Summand_1
      T     #Summand1_t
      L     #Summand_2
      T     #Summand2_t
      L     P##Summand1_t
      LAR1  
      L     P##Summand2_t
      LAR2  
      U     #Uebertrag
      R     #Uebertrag
      L     32
L001: T     #Schleifenzaehler
// Binärergebnis unter Berücksichtigung des Übertrag
      X      [AR1,P#0.0]
      X      [AR2,P#0.0]
      X     #Uebertrag
      =     #Ergebnis_t                 // Ergebnisbit
// Übertrag
      U      [AR1,P#0.0]
      O      [AR2,P#0.0]
      U     #Uebertrag                  //alter Übertrag
      O(    
      U      [AR1,P#0.0]
      U      [AR2,P#0.0]
      )     
      O(    
      U      [AR1,P#0.0]
      U      [AR2,P#0.0]
      U     #Uebertrag                  //alter Übertrag
      )     
      =     #Uebertrag                  //neuer Übertrag
      U     #Ergebnis_t
      =      [AR2,P#0.0]                // am Ende steht die Summe in AR2
      +AR1  P#0.1
      +AR2  P#0.1
      L     #Schleifenzaehler
      LOOP  L001
      TAR2  
      T     #Ergebnis

Ok oder nix kapiert?!?:-?
Das speichern und wiederherstellen des AR hab ich noch nicht rausgefunden bzw. ist mir die funktion noch nicht klar;
gibt es ein bsp irgendwo?

@gravieren
Die anderen Lösungen wären zunächst bestimmt auch ok, aber da ich ind.Adr. weiterhin brauchen werde, sollte ich mich gleich damit befassen.
 
Hier mal ein paar Anmerkungen von mir:

1. Ich würde die Berechnung des Übertrags etwas anders machen, siehe hierzu:

http://de.wikipedia.org/wiki/Halbaddierer

http://de.wikipedia.org/wiki/Volladdierer


2. Deine Programmschleife kann so noch nicht funktionieren.

Du musst bedenken, wie die einzelnen Bits in einem Doppelwort in STEP 7 addressiert sind:

Code: 
                         MD0
 
           MW0                         MW2
 
    MB0           MB1           MB2           MB3
 
M0.7 - M0.0   M1.7 - M1.0   M2.7 - M2.0   M3.7 - M3.0

Gruß Kai
 
_Praktikant_ schrieb:
Hallo,

hier mal ein versuch von mir:
Code: 
 L     #Summand_1
      T     #Summand1_t
      L     #Summand_2
      T     #Summand2_t
      L     P##Summand1_t
      LAR1  
      L     P##Summand2_t
      LAR2  
      U     #Uebertrag
      R     #Uebertrag
      L     32
L001: T     #Schleifenzaehler
// Binärergebnis unter Berücksichtigung des Übertrag
      X      [AR1,P#0.0]
      X      [AR2,P#0.0]
      X     #Uebertrag
      =     #Ergebnis_t                 // Ergebnisbit
// Übertrag
      U      [AR1,P#0.0]
      O      [AR2,P#0.0]
      U     #Uebertrag                  //alter Übertrag
      O(    
      U      [AR1,P#0.0]
      U      [AR2,P#0.0]
      )     
      O(    
      U      [AR1,P#0.0]
      U      [AR2,P#0.0]
      U     #Uebertrag                  //alter Übertrag
      )     
      =     #Uebertrag                  //neuer Übertrag
      U     #Ergebnis_t
      =      [AR2,P#0.0]                // am Ende steht die Summe in AR2
      +AR1  P#0.1
      +AR2  P#0.1
      L     #Schleifenzaehler
      LOOP  L001
      TAR2  
      T     #Ergebnis
Ok oder nix kapiert?!?:-?
Das speichern und wiederherstellen des AR hab ich noch nicht rausgefunden bzw. ist mir die funktion noch nicht klar;
gibt es ein bsp irgendwo?

@gravieren
Die anderen Lösungen wären zunächst bestimmt auch ok, aber da ich ind.Adr. weiterhin brauchen werde, sollte ich mich gleich damit befassen.
Zum Vergrößern anklicken....

du schreibst ja
= [AR2,P#0.0] // am Ende steht die Summe in AR2

TAR2 Brauchst du nicht, würde so ja auch die Adresse von AR2 in dein Ergebnis transferrieren.

es reicht

L #P_Summand2_t, da steht ja das Ergebnis
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

könnte mir jmd ein beispiel geben oder sagen was genau jetzt noch
geändert werden muß?!?
Die adressierung bzw der durchlauf beginnt dann also im "rechten teil"
der einzelnen doppelwörter (zb S1 -> 3.0);
dann gäbe es doch nach jedem byte ein rücksprung auf die nächste adresse?
Ist meine übertrags berechnung dann falsch oder die andere verknüpfung einfach besser?
Danke schon mal, mfg...
 
Hallo Praktikant,
  • Befehl TAD ansehen - hatte mal einer geschrieben ;) !
Nun gut, ich denke man sollte dich nicht länger zappeln lassen.

Code: 
FUNCTION FC 1 : VOID
TITLE =
VERSION : 0.1
VAR_INPUT
  SUMMAND_A : DINT ; 
  SUMMAND_B : DINT ; 
END_VAR
VAR_OUTPUT
  SUMME : DINT ; 
END_VAR
VAR_TEMP
  SAVE_AR1 : DWORD ; 
  SA : DINT ; 
  SB : DINT ; 
  TEMP_INT : INT ; 
  UEBERTRAG : BOOL ; 
  EINS : BOOL ; 
  TEMP : BOOL ; 
END_VAR
BEGIN
NETWORK
TITLE =
//
//    Es gelten folgende Regeln
//    0+0=0
//    1+0=1
//    0+1=1
//    1+1=0 Übertrag 1
//
      TAR1  #SAVE_AR1; 
      SET   ; 
      SAVE  ; 
      L     #SUMMAND_A; 
      TAD   ; 
      T     #SA; 
      L     #SUMMAND_B; 
      TAD   ; 
      T     #SB; 
      L     P##SA; 
      LAR1  ; 
      L     P##SB; 
      LAR2  ; 
      CLR   ; 
      =     #UEBERTRAG; 
      L     32; 
L001: T     #TEMP_INT; 
//*** Binärergebnis unter Berücksichtigung des Übertrag
      X      [AR1,P#0.0]; 
      X      [AR2,P#0.0]; 
      X     #UEBERTRAG; 
      =     #EINS; // Ergebnisbit
//*** Übertrag
      U      [AR1,P#0.0]; // wenn beide bits "1"
      U      [AR2,P#0.0]; 
      O     ; 
      U     #UEBERTRAG; // oder wenn Übertrag
      U(    ; // und genau ein bit "1"
      X      [AR1,P#0.0]; 
      X      [AR2,P#0.0]; 
      )     ; 
      =     #UEBERTRAG; 
      U     #EINS; 
      =      [AR2,P#0.0]; // am Ende Summe in AR2
      +AR1  P#0.1; 
      +AR2  P#0.1; 
      L     #TEMP_INT; 
      LOOP  L001; 
      L     #SB; // Summe wurde in AR2 (#SB) geschrieben
      TAD   ; 
      T     #SUMME; 
      LAR1  #SAVE_AR1; 
END_FUNCTION


Gruß, Onkel
 
Zuletzt bearbeitet:
@Onkel

Ja, hast Recht.

@Praktikant

Ich hab es fast so wie Onkel gemacht, allerdings nur mit AR1. Der Code ist sich natürlich auf Grund der Aufgabe ähnlich. Wenn es dich interessiert, stell ich das auch noch hier ein, ansonsten bleiben wir bei Onkels Version, sonst gibts noch Codesalat :ROFLMAO:.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

vielen dank für die hilfe:p !!
Ich habs glaub ich auch soweit kapiert,
nur die 4 zeilen
Code: 
      TAR1  "SAVE_AR1"
      SET   
      SAVE  
         .
         .
         .
      LAR1  "SAVE_AR1"
Zum Vergrößern anklicken....
sind mir noch unklar?!
In der hilfe steht nicht viel, für was genau brauche ich die AR-Operationen?

@Ralle
Deine Version würd mich auch interessieren und was war jetzt egtl.
die Siemens-Stolperfalle?!
Gruß
 
Jo dann, hier mal meine Version:

Code: 
FUNCTION FC 50 : VOID
TITLE =
VERSION : 1.0
AUTHOR : Ralle

VAR_INPUT
  Summand_1 : DWORD ;    
  Summand_2 : DWORD ;    
END_VAR
VAR_OUTPUT
  Ergebnis : DWORD ;    
END_VAR
VAR_TEMP
  Schleifenzaehler : WORD ;    
  Uebertrag_Temp : BOOL ;    
  SAVE_VKE : BOOL ;    
  Summand_1_Temp : DWORD ;    
  Summand_2_Temp : DWORD ;    
  Ergebnis_Temp : DWORD ;    
END_VAR
BEGIN
NETWORK
TITLE =Sichere VKE im BIE

      SET   ; 
      SAVE  ; 
      =     #SAVE_VKE; 
NETWORK
TITLE =

// Laden der beiden Doppelwörter      
      L     #Summand_1; 
      TAD   ; //Bytes tauschen
      T     #Summand_1_Temp; 

      L     #Summand_2; 
      TAD   ; //Bytes tauschen
      T     #Summand_2_Temp; 

      L     0; 
      T     #Ergebnis_Temp; 

      CLR   ; 
      =     #Uebertrag_Temp; 

      L     L#32; 
loop: T     #Schleifenzaehler; 

      L     P##Summand_1_Temp; 
      LAR1  ; 

      L     32; 
      L     #Schleifenzaehler; 
      -I    ; 
      +AR1  ; 

//Ergebnisbit berechnen  
      X      [AR1,P#0.0]; //summand1
      X      [AR1,P#4.0]; //summand2
      X     #Uebertrag_Temp; //übertrag
      =      [AR1,P#8.0]; //ergebnis

//nächsten Übertrag berechnen
      U      [AR1,P#0.0]; //summand1
      U      [AR1,P#4.0]; //summand2
      U     #Uebertrag_Temp; //übertrag
      O     ; 
      U      [AR1,P#0.0]; //summand1
      U      [AR1,P#4.0]; //summand2
      UN    #Uebertrag_Temp; //übertrag
      O     ; 
      U      [AR1,P#0.0]; //summand1
      UN     [AR1,P#4.0]; //summand2
      U     #Uebertrag_Temp; //übertrag
      O     ; 
      UN     [AR1,P#0.0]; //summand1
      U      [AR1,P#4.0]; //summand2
      U     #Uebertrag_Temp; //übertrag
      =     #Uebertrag_Temp; //nächster übertrag

      L     #Schleifenzaehler; 
      LOOP  loop; 

//Ergebnis speichern

      L     #Ergebnis_Temp; 
      TAD   ; //Bytes zurück tauschen
      T     #Ergebnis; 
NETWORK
TITLE =

      U     #SAVE_VKE; 
      SAVE  ; 
      BE    ; 
END_FUNCTION
Das Berechnen des Übertrages hat Onkel kürzer hinbekommen :rolleyes:.

Die Stolperfalle, war das TAD. Laß mal alle TAD weg, dann funktioniert es, bis man mit seinem Ergebnis eine Bytegrenze überschreitet. Probiers mal aus.

TAR1 "SAVE_AR1" rettet das AR 1 in einen Zwischenspeicher
LAR1 "SAVE_AR1" holt das gerettete AR1 wieder zurück

Mit AR1 muß man das nicht unbedingt machen, bei AR2 ist es aber anzuraten, da das AR2 von Multi-FB genutzt wird.

SAVE speichert das VKE im BIE-Bit (Siehe dazu ausführlich die Step7-Hilfe)
 
Zuletzt bearbeitet:

Similar threads

D
Step 7 REAL im DB
Antworten
9
Aufrufe
6K
DerMatze
D
P
Mittelwertbildung
2 3
Antworten
45
Aufrufe
15K
vierlagig
vierlagig
Zurück
Oben