Startseite Beiträge getaggt mit "Hex"

Schlagwort: Hex

[ABAP] Binärdaten (HEX) in eine lokale Datei speichern 

* HEX-Daten (Beispiel)
DATA(it_solix) = VALUE solix_tab(
                   ( line = '7639BD' )
                   ( line = '67326F' )
                 ).

TRY.
    DATA: lv_action TYPE i.
    DATA: lv_filename TYPE string.
    DATA: lv_fullpath TYPE string.
    DATA: lv_path TYPE string.

* Save-Dialog
    cl_gui_frontend_services=>file_save_dialog( EXPORTING
                                                  default_file_name = 'Data.bin'
                                                  default_extension = 'bin'
                                                  file_filter       = |Binärdaten (*.bin)\|*.bin\|{ cl_gui_frontend_services=>filetype_all }|
                                                CHANGING
                                                  filename          = lv_filename
                                                  path              = lv_path
                                                  fullpath          = lv_fullpath
                                                  user_action       = lv_action ).

    IF lv_action EQ cl_gui_frontend_services=>action_ok.
* XSTRING für Längenbestimung erzeugen
      DATA(lv_xstring) = cl_bcs_convert=>solix_to_xstring( it_solix ).

* Datei lokal speichern
      cl_gui_frontend_services=>gui_download( EXPORTING
                                                filename     = lv_fullpath
                                                filetype     = 'BIN'
                                                bin_filesize = xstrlen( lv_xstring )
                                              CHANGING
                                                data_tab     = it_solix ).

    ENDIF.
  CATCH cx_root INTO DATA(e_text).
    MESSAGE e_text->get_text( ) TYPE 'I'.
ENDTRY.

[ABAP] Binärdaten: Bits setzen und auslesen, Bitoperationen 

* DEMO_DATA_BIT
TRY.
* zwei Bytes
    DATA: lv_xa TYPE x LENGTH 1.
    DATA: lv_xb TYPE x LENGTH 1.

* Bit 1 und 8 setzen
    SET BIT 1 OF lv_xa.
    SET BIT 8 OF lv_xb.

* xstring mit Bit == 1 an der 7. Stelle
    DATA(lv_hex) = bit-set( 7 ).

    cl_demo_output=>write_data( lv_xa ).
    cl_demo_output=>write_data( lv_xb ).
    cl_demo_output=>write_data( lv_hex ).

* Bit 1 lesen
    DATA(lv_bit1) = 0.
    GET BIT 1 OF lv_xa INTO lv_bit1.

    cl_demo_output=>write_data( lv_bit1 ).

* Bit 8 lesen
    DATA(lv_bit8) = 0.
    GET BIT 8 OF lv_xb INTO lv_bit8.

    cl_demo_output=>write_data( lv_bit8 ).

    DATA: lv_and TYPE x LENGTH 1.
    DATA: lv_or TYPE x LENGTH 1.
    DATA: lv_xor TYPE x LENGTH 1.
    DATA: lv_not TYPE x LENGTH 1.

* AND
    lv_and = lv_xa BIT-AND lv_xb.
    cl_demo_output=>write_data( lv_and ).

* OR
    lv_or = lv_xa BIT-OR lv_xb.
    cl_demo_output=>write_data( lv_or ).

* XOR
    lv_xor = lv_xa BIT-XOR lv_xb BIT-XOR lv_hex.
    cl_demo_output=>write_data( lv_xor ).

* NOT
    lv_not = BIT-NOT lv_xb.
    cl_demo_output=>write_data( lv_not ).

* Bitweises lesen
    DATA(lv_bitstring_a) = ||.
    DATA(lv_bitstring_b) = ||.
    DATA(lv_bitstring_hex) = ||.
    DATA(lv_bitstring_and) = ||.
    DATA(lv_bitstring_or) = ||.
    DATA(lv_bitstring_xor) = ||.
    DATA(lv_bitstring_not) = ||.
    DO 8 TIMES.
      DATA(lv_bit) = 0.
      GET BIT sy-index OF lv_xa INTO lv_bit.
      lv_bitstring_a = lv_bitstring_a && lv_bit.
      GET BIT sy-index OF lv_xb INTO lv_bit.
      lv_bitstring_b = lv_bitstring_b && lv_bit.
      GET BIT sy-index OF lv_hex INTO lv_bit.
      lv_bitstring_hex = lv_bitstring_hex && lv_bit.
      GET BIT sy-index OF lv_and INTO lv_bit.
      lv_bitstring_and = lv_bitstring_and && lv_bit.
      GET BIT sy-index OF lv_or INTO lv_bit.
      lv_bitstring_or = lv_bitstring_or && lv_bit.
      GET BIT sy-index OF lv_xor INTO lv_bit.
      lv_bitstring_xor = lv_bitstring_xor && lv_bit.
      GET BIT sy-index OF lv_not INTO lv_bit.
      lv_bitstring_not = lv_bitstring_not && lv_bit.
    ENDDO.

    cl_demo_output=>write_data( lv_bitstring_a ).
    cl_demo_output=>write_data( lv_bitstring_b ).
    cl_demo_output=>write_data( lv_bitstring_hex ).
    cl_demo_output=>write_data( lv_bitstring_and ).
    cl_demo_output=>write_data( lv_bitstring_or ).
    cl_demo_output=>write_data( lv_bitstring_xor ).
    cl_demo_output=>write_data( lv_bitstring_not ).

    cl_demo_output=>display( ).
  CATCH cx_root INTO DATA(e_txt).
    WRITE: / e_txt->get_text( ).
ENDTRY.

[ABAP] Konvertierung Integer (ASCII) HEX CHAR

Variante 1 (Integer (ASCII) -> HEX -> Char)

DATA: ascii_hex TYPE x.
DATA: char TYPE c.

DO 26 TIMES.
* INT -> HEX
  ascii_hex = 64 + sy-index.

* HEX -> CHAR
  cl_abap_conv_in_ce=>create( encoding = 'UTF-8' )->convert( EXPORTING input = ascii_hex
                                                             IMPORTING data  = char ).

  WRITE: / sy-index, '->', ascii_hex, '->', char.
ENDDO.

Variante 2 (Char -> Hex -> Integer (ASCII))

DATA: char TYPE c VALUE 'A'.
DATA: ascii_hex TYPE xstring.
DATA: ascii_int TYPE i.

DATA(o_conv) = cl_abap_conv_out_ce=>create( encoding = 'UTF-8' endian = 'L' ).
o_conv->write( data = char ).

* CHAR -> HEX
ascii_hex = o_conv->get_buffer( ).

* HEX -> INT
ascii_int = ascii_hex.

WRITE: / char, '->', ascii_hex, '->', ascii_int.

[ABAP] Hexadezimale IP-Adresse in IPv4-String umwandeln 

CLASS lcl_conv DEFINITION.
  PUBLIC SECTION.
*--------------------------------------------------------------------*
    CLASS-METHODS: ipv4hex_to_ipv4string
      IMPORTING
                i_hexadr      TYPE mshostadr
      RETURNING VALUE(ret_ip) TYPE string.
ENDCLASS.
*--------------------------------------------------------------------*
CLASS lcl_conv IMPLEMENTATION.
*--------------------------------------------------------------------*
* Konvertiert IP-Adresse (Hex) nach IPv4-String
*--------------------------------------------------------------------*
* -> i_hexadr - Hostadresse (IP) in Hex
* <- ret_ip   - IP-Adresse (IPv4)
*--------------------------------------------------------------------*
  METHOD ipv4hex_to_ipv4string.
* IP besteht aus 4 Bytes (Hex)
    IF xstrlen( i_hexadr ) = 4.
* jeder Hex-Wert wird in Integer konvertiert
      ret_ip = |{ CONV i( i_hexadr+0(1) ) }.{ CONV i( i_hexadr+1(1) ) }.{ CONV i( i_hexadr+2(1) ) }.{ CONV i( i_hexadr+3(1) ) }|.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

* mshostadr -> TYPE RAW4 -> x
* 255.255.255.0
DATA: ip_hex TYPE mshostadr VALUE 'FFFFFF00'.

WRITE: / lcl_conv=>ipv4hex_to_ipv4string( ip_hex ).

Stringliterale in Hexcodes wandeln 

/// Beim Speichern von Strings in Textdateien möchte man manchmal, dass Literale (Zeilenumbrüche, Tabs usw.)
/// nicht interpretiert werden, sondern als hexadezimale Codierungen gespeichert werden.
/// die statische Klasse wandelt alle ASCII-Steuerzeichen in einem String mit ASCIICode < 32 in die entsprechenden hexadezimalen Pendants um.
using System;

/// <summary>
/// freeware helper class for converting string formats
/// (W) 2011 by admin of codezentrale.6x.to
/// </summary>
public static class StringConverter
{
    /// <summary>
    /// hex replace of literals
    /// </summary>
    /// <param name="path">a string</param>
    /// <returns>string with replaced literals</returns>
    public static string ReplaceLiterals(string inputstring)
    {
        string output = string.Empty;
        
        foreach (char t in inputstring)
        {
            int ascii = Convert.ToInt32(t);
            output += (ascii < 32) ? string.Format("&#x{0:X02};", ascii) : t.ToString();
        }

        return output;
    }
}

Beispiel:

string sInput = "Hallo" + Environment.NewLine + "Welt!"

// "Hallo Welt!"
string sOutPut = StringConverter.ReplaceLiterals(sInput));