[Problem] 5-stellige Zahl auf 5 Bytes verteilen (1er/10er/100er/1000er/10000er)

Ich habe es mal auf die ganz einfache Tour gelöst.

Code: 
DATA_BLOCK DB 2
TITLE =
VERSION : 0.1

  STRUCT  
   Anfangszahl : DINT ; //Aufzuteilende Zahl
   Zehntausender : INT ; //Zehntausender Zahl
   Tausender : INT ; //Tausender Zahl
   Hunderter : INT ; //Hundert Zahl
   Zehner : INT ; //Zehner Zahl
   Einer : INT ; //Einer Zahl
  END_STRUCT ; 
BEGIN
   Anfangszahl := L#6001; 
   Zehntausender := 0; 
   Tausender := 0; 
   Hunderter := 0; 
   Zehner := 0; 
   Einer := 0; 
END_DATA_BLOCK
FUNCTION FC 2 : VOID
TITLE =
VERSION : 0.1

VAR_INPUT
  Anfangszahl : DINT ; //Aufzusplittende Zahl
END_VAR
VAR_OUTPUT
  Zehntausend : INT ; //Zehntausender Stelle
  Tausend : INT ; //Tausender Stelle
  Hundert : INT ; //Hunderter Stelle
  Zehner : INT ; //Zehner Stelle
  Einer : INT ; //Einer Stelle
END_VAR
VAR_TEMP
  Zwischenspeicher : DINT ; //Zwischenspeicher
END_VAR
BEGIN
NETWORK
TITLE =Initialisieren
      L     L#0; 
      T     #Zehntausend; 
      T     #Tausend; 
      T     #Hundert; 
      T     #Zehner; 
      T     #Einer; 
NETWORK
TITLE =Zehntausender Stelle ermitteln
      U(    ; 
      L     #Anfangszahl; 
      L     L#9999; 
      >D    ; 
      )     ; 
      SPBNB M001; 
      L     #Anfangszahl; 
      L     L#10000; 
      /D    ; 
      T     #Zehntausend; 
M001: U(    ; 
      L     #Zehntausend; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M002; 
      L     #Zehntausend; 
      L     L#10000; 
      *D    ; 
      T     #Zwischenspeicher; 
M002: U(    ; 
      L     #Zehntausend; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M003; 
      L     #Anfangszahl; 
      L     #Zwischenspeicher; 
      -D    ; 
      T     #Anfangszahl; 
M003: NOP   0; 
NETWORK
TITLE =Tausender Stelle ermitteln
      U(    ; 
      L     #Anfangszahl; 
      L     L#999; 
      >D    ; 
      )     ; 
      SPBNB M004; 
      L     #Anfangszahl; 
      L     L#1000; 
      /D    ; 
      T     #Tausend; 
M004: U(    ; 
      L     #Tausend; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M005; 
      L     #Tausend; 
      L     L#1000; 
      *D    ; 
      T     #Zwischenspeicher; 
M005: U(    ; 
      L     #Tausend; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M006; 
      L     #Anfangszahl; 
      L     #Zwischenspeicher; 
      -D    ; 
      T     #Anfangszahl; 
M006: NOP   0; 
NETWORK
TITLE =Hunderter Stelle ermitteln
      U(    ; 
      L     #Anfangszahl; 
      L     L#99; 
      >D    ; 
      )     ; 
      SPBNB M007; 
      L     #Anfangszahl; 
      L     L#100; 
      /D    ; 
      T     #Hundert; 
M007: U(    ; 
      L     #Hundert; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M008; 
      L     #Hundert; 
      L     L#100; 
      *D    ; 
      T     #Zwischenspeicher; 
M008: U(    ; 
      L     #Hundert; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M009; 
      L     #Anfangszahl; 
      L     #Zwischenspeicher; 
      -D    ; 
      T     #Anfangszahl; 
M009: NOP   0; 
NETWORK
TITLE =Zehner Stelle ermitteln
      U(    ; 
      L     #Anfangszahl; 
      L     L#9; 
      >D    ; 
      )     ; 
      SPBNB M010; 
      L     #Anfangszahl; 
      L     L#10; 
      /D    ; 
      T     #Zehner; 
M010: U(    ; 
      L     #Zehner; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M011; 
      L     #Zehner; 
      L     L#10; 
      *D    ; 
      T     #Zwischenspeicher; 
M011: U(    ; 
      L     #Zehner; 
      L     L#0; 
      >D    ; 
      )     ; 
      SPBNB M012; 
      L     #Anfangszahl; 
      L     #Zwischenspeicher; 
      -D    ; 
      T     #Anfangszahl; 
M012: NOP   0; 
NETWORK
TITLE =Einer Stelle ermitteln
 
      L     #Anfangszahl; 
      T     #Einer; 
END_FUNCTION

Vielleicht ist es ja so für Dich verständlicher.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Moin,

Lipperlandstern hat es dir doch schon geschrieben, ohne +I

Code: 
      L     #Deine Eingangszahl  // INT       
      L     1000       
      MOD          
      T     #MOD_100      
      L     100       
      MOD          
      T     #MOD_10     
      L     10        
      MOD          
      T     #MOD_1        

      L     #Deine Eingangszahl       
      L     1000       
      /I            
      T     #Byte_1_Stelle  // 1. Stelle      
     
      L     #MOD_100      
      L     100       
      /I             
      T     #Byte_2_Stelle   // 2. Stelle       

      L     #MOD_10       
      L     10       
      /I            
      T     #Byte_3_Stelle   // 3. Stelle        

      L     #MOD_1  // 4. Stelle         
      T     #Byte_4_Stelle   // 4. Stelle
 
Zuletzt bearbeitet:
Nordischerjung schrieb:
Moin,

Lipperlandstern hat es dir doch schon geschrieben, ohne +I
Zum Vergrößern anklicken....


Hallo,

ich habe doch gar kein "+I" drin...oder?

Aber ich komme irgendwie nicht über 255 hinweg... ab 256 schreibt er mir eine 0 in die Hunderter.
Wenn ich dann statt BYTE ein WORD nehme, klappt gar nix mehr.

@190B: So einfach finde ich das gar nicht...

Ich muss auch leider zugeben, dass Ihr wahrscheinlich einiges an Grundwissen voraussetzt, dass bei mir teilweise nicht gegeben ist. Ich wurde mit dem Ding hier im wahrsten Sinne des Wortes ins kalte Wasser geschmissen und muss jetzt zusehen, wie ich damit klarkomme. Ich weiß Eure Hilfe und Geduld sehr zu schätzen und freue mich über jeden Tipp, der mich in die richtige Richtung treibt, aber für mich ist das hier fast alles Neuland!


Gruß,

dia
 
Ich hab's!!! :idea:

Ich hatte einen kleinen Fehler drin...
Nun haut es hin!!! :ROFLMAO:

Meine Fresse, war das eine schwere Geburt!!!

Danke, danke, danke!!!

Gruß,

dia
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Eigentlich ist das Zerlegen einer Zahl in seine Dezimalziffern nur ein bißchen Bit-"geschubse".
Dafür gibt es verschiedene bewährte und effiziente Verfahren. Und viele weitere Lösungen, wie man es auch noch machen kann, wenn die Verständlichkeit des Algorithmus wichtiger ist als seine Effizienz.

1. bietet sich das Verfahren der Ziffern-Abspaltung von hinten nach vorn durch fortwährende Division mit 10 an (ähnlich Lipperlandstern). Der Divisionsrest (MOD) ist die abgespaltene hinterste Ziffer, mit dem Quotient wird weitergerechnet. Dieses Verfahren eignet sich ganz allgemein gut zur Zerlegung von Zahlen aus Stellenwert-Zahlensystemen mit verschiedener Basis.

2. kann man die Zahl in BCD umwandeln und danach die 4-Bit-Nibbles auf je 8 Bit erweitern (ähnlich Larry Laffer).
Hier mal eine Zerlegung einer 5-stelligen Zahl (DINT) in 5 Dezimalziffern:
Code: 
      L     #DINT_Zahl                  // 0 ... 12345 ... 99999
      DTB
      RLD   16
      T     #Byte_Stelle_1

      SLW   4
      RLD   4
      T     #Byte_Stelle_2

      SLW   4
      RLD   4
      T     #Byte_Stelle_3

      SLW   4
      RLD   4
      T     #Byte_Stelle_4

      SLW   4
      RLD   4
      T     #Byte_Stelle_5

Harald
 
Wie wärs mal mit:

- Zahl in String wandeln....
- String in einzelne Zeichen aufteilen....
- Zeichen zurück wandeln....
- In Bytes schreiben....

Achja, bevor mir jemand an die Grugel will...


</Ironiemodus>
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Da macht jemand seinem Namen wieder alle Ehre.

Dabei habe ich doch extra auf den Ironiemodus hingewiesen :)

Trotzdem würde ich meine Lösung verwenden.
Gefällt mir richtig gut.
Finde den Code einfach Süss.

An dieser Stelle möchte ich nochmals freundlich aber mit aller Nachdrücklichkeit darauf Hinweisen
Dass dieser und auch mein letzter Beitrag mit der gewissen Ironie zu verstehen sind und keinesfalls
den Anspruch erheben, den Themenstarter bei seiner Lösungsfindung unterstützen.
Für diesen Klamauk/Schabernack/Eulenspiegelei bitte ich um Nachsicht.

Okay, des haben wir geklärt. Kann mans so stehen lassen? Ich glaub schon. Oder sollte ich nochmals ausdrücklich auf die IRONIE hinweisen? Ach was. Die User hier verstehen die IRONIE dabe sicher. Ich könnte in meinem Beitrag das Wort IRONI auch fett schreiben. Ach was komm. Ich schick den Beitrag ab...

3

2

1
 

Similar threads

L
Sonstiges Hilfe ! 4-stelliges Zählen mit Siemens Logo
Antworten
14
Aufrufe
12K
hucki
hucki
Zurück
Oben