Step 7 INT nach HEX umwandeln

B

bmwled

Level-2
Beiträge
62
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

ich habe ein Problem mit der Umwandlung einer Dezimalzahl.
Die Zahl im DB301.dbw24 muss nach HEX umgewandelt werden und im MW236 stehen.
Sprich dez 43 sollte hex 2b raus kommen.
Das klappt aber nicht. Stattdessen empfängt das Programm die 43.
Bitte um Tipps.

Danke


umwandlung.PNG
 
Da gibt's nix zu wandeln!
Es sei denn, Du möchtest das Ergebnis in Form von ASCII-Zeichen.
Versuch's doch mal mit einem "TypeCast", sprich INT_TO_WORD statt der Umwandlung in BCD.
 
Arrrrrrgh, nicht schon wieder, ich bekomme Augenzucken und Schweißausbrüche!!!!!
:sw9:

Wieso hält sich dieser Irrglaube man könnte etwas in Hex wandeln so hartnäckig? Ein Blick ins Forum hätte da schon Klarheit gebracht.
Aber gerne nochmals. Man kann nichts in eine Hex-Zahl wandeln, denn man spricht hier von Hexadezimaler-Darstellung und nicht von einem Zahlenformat wie Ganzzahl und Fließkommazahl wo es eine Wandlung gebe. Das ist einfach nur eine andere Art eine Zahl darzustellen, wie z.B. 5 in arabischer Schreibweise und V in lateinischer auch das Selbe ist nur anders geschrieben, so ist auch bei 17Dez und 11Hex der Speicherinhalt immer der Gleiche es wird nur anders angezeigt. Wenn Du die Zahlen in Hex dargestellt haben möchtest musst Du an irgendeiner Anzeigeeinstellung etwas ändern (Die Siemens-Experten können hier weiterhelfen) brauchst aber keinen Konverter, Wandler oder ähnliches.
Aber vielleicht erklärst Du mal was genau Du machen möchtest. Sobald mein Blutdruck wieder normal ist und mein Aggressionsfaktor sich gelegt hat kann ich Dir dann auch weiterhelfen.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Vielen Dank schon mal für eure Beteiligung!
Bitte schaut euch das Bild an.
Im Prozessschnittstellen-Assistent sollten 2b ankommen.
Ich kann mir nicht erklären, warum die 2b dort wieder als 43 erscheinen.
Deswegen habe ich mein Problem bei der "Umwandlung" der Zahl gesucht.


job1.jpg
 
Aber wo genau ist eigentlich Dein Problem? Es wird eine gewisse Anzahl an Bits übertragen und deren Inhalt ist im Hex-Format und Dez-Format gleich, also egal ob Du es jetzt im einen oder anderen Format anzeigen lässt es kommt immer das Selbe an.
 
Kannst Du denn (nicht) die Darstellung der Zahl bei Deinem "ins-Innenleben-Reingucker" anwählen? Binär? Dezimal? Hexadezimal? Vielleicht ("überflüssigerweise") sogar oktal?
Üb' mal ein Bisschen mit dem WindowsRechner in der BetriebsArt "Programmierer".
Wie soll es mit Deiner HexZahl denn weitergehen? Benötigst Du evtl. doch die HexZahl in Form von ASCII-Zeichen (= "druckbare" Zeichen mit einem PlatzBedarf von 1 Byte pro Zeichen)?

Das BitMuster 0000 0000 0010 1011 kann man interpretieren als
- HexZahl 002B oder als
- DezZahl 43 oder als
- OktZahl 000053.
Was davon jeweils lesbarer/verständlicher ist, ist z.T. GeschmacksSache.​
Oder als - HexZahl aus ASCII-Zeichen '32 42' bei einem "grossen" 'B' bzw. '32 62' bei einem "kleinen" 'b'.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich kann das leider nicht ändern.
Der Hersteller der Kamera empfängt nun immer die 43 und interpretiert diese als 67.
Er meint, er müsse 2b übertragen bekommen und würde dann die 43 entsprechend laden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
also interprtiert die kamera das bcd codiert
bei dir ist die 43 dez was 2b hex entspricht. für die kamera ist das scheinbar 43 hex was 67 dez entspricht.
ich wüsste jetzt nicht wie du 2b übertragen könntest. aber die frage ist jetzt noch was der fb intern mit der variablen macht.
wie ist in der kamera dieses wort definiert?
der gedanke von heinilein kann auch nicht sein das das ascii-zeichen sind.
 
volker schrieb:
wie ist in der kamera dieses wort definiert?

der gedanke von heinilein kann auch nicht sein das das ascii-zeichen sind.
Zum Vergrößern anklicken....
Au ja, lass mal sehen, was die Dok der Kamera dazu sagt! (Schnittstelle!)

Ich vermute nach wie vor: ASCII.

Woraus kann man schliessen, dass die Kamera 67 statt 43 versteht?

Was passiert denn jetzt schon nach der "Umwandlung in Hex" auf dem Wege zur Kamera? Steckt da schon irgendwo eine Wandlung in ASCII mit drin?
Oder hast Du die Wandlung INT in BCD wieder in Dein Programm reingeschmuggelt?

PS:
bei BCD-kodiert gibt es kein 2b !!! a .. f sind die "PseudoTetraden".

PPS:
Code: 
Für IntegerZahlen von 0 bis 255:
IZ: INT
C1: INT
C2: INT
C:  WORD

C1 := IZ / 16 + 48 ;
IF C1 > 57 THEN C1 := C1 + 7 ; END-IF ; // alternativ +39 statt +7 für KleinBuchstaben
C2 := IZ MOD 16 + 48 ;
IF C2 > 57 THEN C2 := C2 + 7 ; END-IF ; // alternativ +39 statt +7 für KleinBuchstaben
C := INT_TO_WORD(256 * C1 + C2) ;
 
Zuletzt bearbeitet:
die frage ist was macht der fb aus der eingangsvariablen.
mögliche logische umwandling wäre int_to_char (gibts bei classic soweit ich weiss nicht)
wenn die kamera aus 43 67 macht interprtiert diese den ankommenden wert als hex.
wenn der fb jetzt aus den 43 dez einen string mit den zeichen '4' '3' macht kann man das nachvollziehen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Am FB selbst steht "NEW_JOBNUMBER" IN: INT dran.

Der FB ist in SCL:

Code: 
  FUNCTION_BLOCK "FB011 VS SWITCH JOB"

//AUTHOR : DV
//FAMILY : BAUMER
//VERSION : 1.0
   VAR_INPUT 
      START : Bool;
      NEW_JOBNUMBER : Int;
   END_VAR


   VAR_OUTPUT 
      STATUS : "udtStatusKamera";
      FINISHED : Bool;
   END_VAR


   VAR_IN_OUT 
      SendReceiveTelegramm : "udtSendReceiveTelegramm";
   END_VAR


   VAR 
      FHM_Flanke : Bool;
   END_VAR


   VAR_TEMP 
      t_1000er : Int;
      t_100er : Int;
      t_10er : Int;
      t_1er : Int;
      tmp_Laenge_Endezeichen : Int;
      RET_VAL_WORD : Word;
      tmp_Zaehler : Int;
      tmp_WORD : WORD;
      tmp_WORD_BOOL AT tmp_WORD : ARRAY[0..15] OF BOOL;
      tmp_DATEN : BYTE;
   END_VAR




BEGIN
    //----------------------------------------------------
    //                PROTOKOLL Versionen
    //
    // | PROTOKOLL |              VERSION                |
    // |-----------|-------------------------------------|
    // |    10     | ETHERNET: Without end identifier    |
    // |    11     | ETHERNET: End identifier <CR>       |
    // |    12     | ETHERNET: End identifier <LF>       |
    // |    13     | ETHERNET: End identifier <CR><LF>   |
    // |           |                                     |
    //
    //----------------------------------------------------
    //
    // HINWEIS:
    //
    //----------------------------------------------------
    //           (c) 2015 Baumer Optronic GmbH
    
    IF NOT START THEN
        
        FINISHED := FALSE;
        FHM_Flanke := FALSE;
        
    END_IF;
    
    // ***************************************************
    // *****          Telegramm zusammenbauen        *****
    // ***************************************************
    
    // Befehl SJ für Programmumschaltung
    
    SendReceiveTelegramm.SEND.Zeichen[1] := 'S';
    SendReceiveTelegramm.SEND.Zeichen[2] := 'J';
    
    // Programmnummer von DEZ in ASCII wandeln
    
    t_1000er :=  NEW_JOBNUMBER / 1000;
    SendReceiveTelegramm.SEND.Zeichen[3] := INT_TO_CHAR(t_1000er+48);
    
    t_100er  := (NEW_JOBNUMBER - (t_1000er*1000)) / 100 ;
    SendReceiveTelegramm.SEND.Zeichen[4] := INT_TO_CHAR(t_100er+48);
    
    t_10er   := (NEW_JOBNUMBER - (t_1000er * 1000)- (t_100er * 100)) / 10;
    SendReceiveTelegramm.SEND.Zeichen[5] := INT_TO_CHAR(t_10er + 48);
    
    t_1er    := (NEW_JOBNUMBER - (t_1000er * 1000) - (t_100er * 100) - (t_10er * 10));
    SendReceiveTelegramm.SEND.Zeichen[6] := INT_TO_CHAR(t_1er + 48);
    
    // Protokoll / Endezeichen 
    
    IF SendReceiveTelegramm.PROTOKOLL = 11 THEN
        
        SendReceiveTelegramm.SEND.Zeichen[7] := BYTE_TO_CHAR(b#16#D);
        SendReceiveTelegramm.SEND.Zeichen[8] := BYTE_TO_CHAR(b#16#0);
        SendReceiveTelegramm.SEND.Laenge     := 7;
        tmp_Laenge_Endezeichen               := 1;
        
    ELSIF SendReceiveTelegramm.PROTOKOLL = 12 THEN
        
        SendReceiveTelegramm.SEND.Zeichen[7] := BYTE_TO_CHAR(b#16#A);
        SendReceiveTelegramm.SEND.Zeichen[8] := BYTE_TO_CHAR(b#16#0);
        SendReceiveTelegramm.SEND.Laenge     := 7;
        tmp_Laenge_Endezeichen               := 1;
        
    ELSIF SendReceiveTelegramm.PROTOKOLL = 13 THEN
        
        SendReceiveTelegramm.SEND.Zeichen[7] := BYTE_TO_CHAR(b#16#D);
        SendReceiveTelegramm.SEND.Zeichen[8] := BYTE_TO_CHAR(b#16#A);
        SendReceiveTelegramm.SEND.Laenge     := 8;
        tmp_Laenge_Endezeichen               := 2;
        
    ELSE
        
        SendReceiveTelegramm.SEND.Zeichen[7] := BYTE_TO_CHAR(b#16#0);
        SendReceiveTelegramm.SEND.Zeichen[8] := BYTE_TO_CHAR(b#16#0);
        SendReceiveTelegramm.SEND.Laenge     := 6;
        tmp_Laenge_Endezeichen               := 0;
        
    END_IF;
    
    // ***************************************************
    // *****             Telegramm senden            *****
    // ***************************************************
    
    SendReceiveTelegramm.SEND.Start := START;
    
    IF START AND NOT FHM_Flanke THEN
        
        FOR tmp_Zaehler := 1 TO 254 DO
            
            // Daten ablöschen 
            STATUS.AKTIVER_JOB := 0;
            
            STATUS.JOB_UPDATE_aktiv          := FALSE;
            STATUS.JOB_UPDATE_Fehler         := FALSE;
            STATUS.JOB_UPDATE_OK             := FALSE;
            STATUS.AUFNAHME_Trig_moeglich    := FALSE;
            STATUS.BACKUP_aktiv              := FALSE;
            STATUS.BACKUP_Fehler             := FALSE;
            STATUS.BACKUP_OK                 := FALSE;
            STATUS.INTERNER_FEHLER           := FALSE;
            STATUS.PROTOKOLL_Polling_Mode    := FALSE;
            STATUS.PROTOKOLL_Continous_Mode  := FALSE;
            STATUS.AUFNAHME_externer_Trig    := FALSE;
            STATUS.AUFNAHME_fortwaehrend     := FALSE;
            STATUS.MODE_Wiederherstellung    := FALSE;
            STATUS.MODE_Setup                := FALSE;
            STATUS.MODE_Testmode             := FALSE;
            STATUS.MODE_RUN_mode             := FALSE;
            
            FHM_Flanke := TRUE;
            
        END_FOR;
        
    END_IF;
    // ***************************************************
    // *****            Telegramm empfangen          *****
    // ***************************************************
    
    IF (SendReceiveTelegramm.SEND.Start AND
        SendReceiveTelegramm.SEND.Gesendet AND
        SendReceiveTelegramm.RECEIVE.NDR AND
        SendReceiveTelegramm.RECEIVE.Laenge = (10 + tmp_Laenge_Endezeichen) AND
        SendReceiveTelegramm.RECEIVE.Zeichen[1] = 'R' AND
        SendReceiveTelegramm.RECEIVE.Zeichen[2] = 'S') THEN
        
        FOR tmp_Zaehler := 1 TO 4 DO
             
             // Daten von ASCII Zeichen in Hexadezimal umwandeln und kopieren
             tmp_WORD := SHL(IN:= tmp_WORD, N := 4); 
             tmp_DATEN := CHAR_TO_BYTE(SendReceiveTelegramm.RECEIVE.Zeichen[tmp_Zaehler + 2]);
             tmp_DATEN := INT_TO_BYTE(BYTE_TO_INT(tmp_DATEN) - 48);
                 
             IF BYTE_TO_INT(tmp_DATEN) >= 10 THEN
                    
                tmp_DATEN := INT_TO_BYTE(BYTE_TO_INT(tmp_DATEN) - 7);
                    
                IF BYTE_TO_INT(tmp_DATEN) >= 6 THEN
                        
                    tmp_DATEN := INT_TO_BYTE(BYTE_TO_INT(tmp_DATEN) - 32);
                        
                END_IF;    
             END_IF;
                 
             tmp_WORD := tmp_WORD OR BYTE_TO_WORD(tmp_DATEN); 
        END_FOR;
              
        STATUS.JOB_UPDATE_aktiv          := tmp_WORD_BOOL[0];
        STATUS.JOB_UPDATE_Fehler         := tmp_WORD_BOOL[1];
        STATUS.JOB_UPDATE_OK             := tmp_WORD_BOOL[2];
        STATUS.AUFNAHME_Trig_moeglich    := tmp_WORD_BOOL[3];
        STATUS.BACKUP_aktiv              := tmp_WORD_BOOL[4];
        STATUS.BACKUP_Fehler             := tmp_WORD_BOOL[5];
        STATUS.BACKUP_OK                 := tmp_WORD_BOOL[6];
        STATUS.INTERNER_FEHLER           := tmp_WORD_BOOL[7];
        STATUS.PROTOKOLL_Polling_Mode    := tmp_WORD_BOOL[8];
        STATUS.PROTOKOLL_Continous_Mode  := tmp_WORD_BOOL[9];
        STATUS.AUFNAHME_externer_Trig    := tmp_WORD_BOOL[10];
        STATUS.AUFNAHME_fortwaehrend     := tmp_WORD_BOOL[11];
        STATUS.MODE_Wiederherstellung    := tmp_WORD_BOOL[12];
        STATUS.MODE_Setup                := tmp_WORD_BOOL[13];
        STATUS.MODE_Testmode             := tmp_WORD_BOOL[14];
        STATUS.MODE_RUN_mode             := tmp_WORD_BOOL[15];
        
        STATUS.AKTIVER_JOB := ((CHAR_TO_INT(SendReceiveTelegramm.RECEIVE.Zeichen[7]) - 48) * 1000) +
                               ((CHAR_TO_INT(SendReceiveTelegramm.RECEIVE.Zeichen[8]) - 48) * 100) +
                               ((CHAR_TO_INT(SendReceiveTelegramm.RECEIVE.Zeichen[9]) - 48) * 10) +
                               ((CHAR_TO_INT(SendReceiveTelegramm.RECEIVE.Zeichen[10]) - 48));
        
        FINISHED := TRUE;
        
    END_IF;
    
    SendReceiveTelegramm.RECEIVE.NDR := FALSE;
    
END_FUNCTION_BLOCK
 
Der von Dir gezeigte FB wandelt den Int-Wert "NEW-JOBNUMER" in Dezimal-ASCII um und sendet ihn dann. Dieser Baustein ist so nicht in der Lage, HEX-ASCII zu senden.
Da kannst Du den Wert "NEW-JOBNUMER" wandeln so viel Du willst.
Gruß
Erich
 
Ich sehe Umwandlungen:
DEZ in ASCII-DEZ,
ASCII-DEZ in DEZ,
ASCII-HEX in DEZ (fehlerhaft beim Versuch, KleinBuchstaben zu erkennen/wandeln! "IF BYTE_TO_INT(tmp_DATEN) >= 6 THEN"???).
Aber keine Umwandlungen in ASCII-HEX.

ASCII ist also sehr wohl ein Thema, aber mehr ist mir noch nicht klar geworden. Welche der Zahlen sollen in ASCII-Hex gewandelt werden - etwa alle?
 
Zuletzt bearbeitet:

Similar threads

M
TIA TIA String Daten als HEX interpretieren (nicht umwandeln!)
Antworten
10
Aufrufe
6K
Heinileini
Heinileini
L
Ascii dez code in Hex Wandeln
Antworten
4
Aufrufe
3K
Ralle
Ralle
M
TIA Eingangwort (Hex) als Integer interpretieren
Antworten
2
Aufrufe
8K
hucki
hucki
E
Mehrere Real-Zahlen in hex umwandeln und zusammenfügen
2
Antworten
37
Aufrufe
6K
egro
E
J
Stromzähler an VIPA 313SC
Antworten
3
Aufrufe
3K
Michael J.
M
Zurück
Oben