Aus zweisselliger Interger beide Ziffern auslesen

ToGe4811

Level-1
Beiträge
9
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

Ich muss aus einem Integer (die maximal zweistellig ist 00-99) die einzelnen Zahlen auslesen.

Also au 32 die 3 und die 2, damit ich die per ASCII Code weiter verarbeiten kann.

Muss an einen Beschrifter die Zahl einzeln per Byte senden.

Vielleicht lachen sich jetzt einige kaputt aber im Moment stehe ich voll auf der Leitung.
 
Guten Abend,

um jetzt mal so schnell aus der Hüfte geschossen einen Vorschlag zu machen würde ich die Integerzahl durch 10 teilen, d.h. ich bekomme auf dein Beispiel bezogen 3.2 herraus, durch "Runden durch Abschneiden" (Müsste TRUNC sein) die daraus 3 isolieren. Jetzt diese 3 mit 10 Multiplizieren und von 32 abziehen, jetzt hast du nur noch die einer Stelle. So hast du dann ja beide Ziffern einzeln. Natürlich könnte es auch einen einfacheren Befehl geben, aber das wäre jetzt meine Version ohne die "F1"-Taste drücken zu können ;) Schließlich aus der Integer noch ein ASCII-Zahl machen.

Schönen Abend :)
 
Warum denn so schwierig?
Bei zwei Ziffern gehts doch auch so:
Code:
L #Zahl  // Zahl von 0-99
ITB // BCD-Codiert
L W#16#F // nur 1er Stelle
UW
+ 48 // In ASCII Wandeln
T #Einer // Einer Stelle als ASCII

L #Zahl  // Zahl von 0-99
ITB // BCD-Codiert
SRW 4 // 1er Stelle rausschieben
+ 48 // In ASCII Wandeln
T #Zehner // Zehner Stelle als ASCII

Es geht bestimmt auch eleganter, aber das hier ist recht einfach.

Grüße
Gebs
 
DINT zu ASCII...

Länge des Any's auf die Ascii Zahl bestimmt die Größe...

Code:
FUNCTION FC 140 : VOID
TITLE =
//Beschreibung:
//
//Dieser FC wandelt einen DINT in Ascii Zeichen um. 
//Falls der DINT Wert zu groß ist, als nicht in den Ascii
//Wert passt, wird '0' ausgegeben. Führende leerstellen
//werden mit '0' gefüllt!
VERSION : 0.1




VAR_INPUT
  DINTVAL : DINT ;	
END_VAR
VAR_OUTPUT
  ASCII : ANY ;	
END_VAR
VAR_TEMP
  ASCII_LOC : DWORD ;	
  RETVAL : INT ;	
  SCHLEIFE_MAX : INT ;	
  SCHLEIFE : INT ;	
  FAKTOR : DINT ;	
  ZAHL : DINT ;	
  ZAHL_WAR_DA : BOOL ;	
  DB_NR : INT ;	
  backup_DB : INT ;	
  backup_AR1 : DWORD ;	
END_VAR
BEGIN
NETWORK
TITLE =


//backup
      L     DBNO; 
      T     #backup_DB; 
      TAR1  ; 
      T     #backup_AR1; 


//Initialisieren
      L     #DINTVAL; 
      T     #ZAHL; 


//Pointer auf Ascii laden
      L     P##ASCII; 
      LAR1  ; 


//Schleife mit Länge des Pointers initialisieren
      L     W [AR1,P#2.0]; 
      T     #SCHLEIFE_MAX; 


//Datentyp ermitteln, nur Byte gültig!
//      L     B [AR1,P#1.0]
// 4 - 5 -->  Länge 2
// 6 - 8 -->  Länge 4


//DB des Pointers öffnen (falls vorhanden!)
      L     0; 
      L     W [AR1,P#4.0]; 
      ==I   ; 
      SPB   spOK; 
      T     #DB_NR; 
      AUF   DB [#DB_NR]; 


//Wenn Speicherbereich DI, in DB ändern
      L     B [AR1,P#6.0]; 
      L     B#16#85; //Speicerbereich DI??
      ==I   ; 
      SPBN  spOK; 
      L     B#16#84; //Speicherberich DB
      T     B [AR1,P#6.0]; 


//Startadresse in AR1 laden
spOK: L     D [AR1,P#6.0]; 
      LAR1  ; 


//Potenzfaktor Startwert
      L     L#1; 
      T     #FAKTOR; 


//max Potenzfaktor bestimmen (10^(LängeAny-1), ausser wenn Schleife_max = 1, da loop sonst ins negative dekrementiert!
      L     0; 
      L     #SCHLEIFE_MAX; 
      +     -1; 
      ==I   ; 
      SPB   sl2; 


sl1:  T     #SCHLEIFE; 
      L     L#10; 
      L     #FAKTOR; 
      *D    ; 
      T     #FAKTOR; 
      L     #SCHLEIFE; 
      LOOP  sl1; 


//Zahl zu groß, ergebniss = 0
      L     #FAKTOR; 
      L     10; 
      *D    ; 
      L     #ZAHL; 
      >D    ; 
      SPB   sl2; 
      L     0; 
      T     #ZAHL; 


//Aktuelles Zeichen laden und prüfen ob Ziffer
sl2:  L     #ZAHL; 
      L     #FAKTOR; 
      /D    ; 
      T     B [AR1,P#0.0]; //Ziffer in DB eintragen
      L     #FAKTOR; 
      *D    ; 
      NEGD  ; 
      L     #ZAHL; 
      +D    ; 
      T     #ZAHL; 


//Ziffer in ascii wandeln...
      L     B [AR1,P#0.0]; 
      L     '0'; 
      +I    ; 
      T     B [AR1,P#0.0]; 


      L     1; 
      L     #FAKTOR; 
      ==D   ; 
      SPB   ende; 


      L     L#10; 
      /D    ; 
      T     #FAKTOR; 


      L     P#1.0; 
      +AR1  ; 
      SPA   sl2; 


ende: AUF   DB [#backup_DB]; 
      L     #backup_AR1; 
      LAR1  ; 
END_FUNCTION
 
Zurück
Oben