adding support for new macros to the daemon. new macros: DLT_HEX8(VAR) 8bits variable displayed in hexadecimal with "0x" prefix DLT_HEX16(VAR) 16bits displayed in hexadecimal with "0x" prefix DLT_HEX32(VAR) 32bits displayed in hexadecimal with "0x" prefix DLT_HEX64(VAR) 64bits displayed in hexadecimal with "0x" prefix DLT_BIN8(VAR) 8bits variable displayed in binary with "0b" prefix DLT_BIN16(VAR) 16bits variable displayed in binary with "0b" prefix

plus typo fix

Signed-off-by: Alexander Wenzel <Alexander.AW.Wenzel@bmw.de>

2 files changed, 255 insertions, 3 deletions

diff --git a/src/lib/dlt_user.c b/src/lib/dlt_user.c
index 22283c2..fad3fa0 100644
--- a/src/lib/dlt_user.c
+++ b/src/lib/dlt_user.c
@@ -1310,10 +1310,10 @@ int dlt_user_log_write_finish(DltContextData *log)
 
 int dlt_user_log_write_raw(DltContextData *log,void *data,uint16_t length)
 {
-	return dlt_user_log_write_raw_formated(log,data,length,DLT_FORMAT_DEFAULT);
+	return dlt_user_log_write_raw_formatted(log,data,length,DLT_FORMAT_DEFAULT);
 }
 
-int dlt_user_log_write_raw_formated(DltContextData *log,void *data,uint16_t length,DltFormatType type)
+int dlt_user_log_write_raw_formatted(DltContextData *log,void *data,uint16_t length,DltFormatType type)
 {
     uint16_t arg_size;
     uint32_t type_info;
@@ -1627,6 +1627,186 @@ int dlt_user_log_write_uint64(DltContextData *log, uint64_t data)
     return 0;
 }
 
+int dlt_user_log_write_uint8_formatted(DltContextData *log, uint8_t data, DltFormatType type)
+{
+    uint32_t type_info;
+
+    if (log==0)
+    {
+        return -1;
+    }
+
+    if ((log->size+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+    {
+        return -1;
+    }
+
+    if (dlt_user.verbose_mode)
+    {
+        if ((log->size+sizeof(uint32_t)+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+        {
+            return -1;
+        }
+
+        type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
+
+        if(type>=DLT_FORMAT_HEX8 && type<=DLT_FORMAT_HEX64)
+        {
+            type_info |= DLT_SCOD_HEX;
+        }
+
+        else if(type>=DLT_FORMAT_BIN8 && type<=DLT_FORMAT_BIN16)
+        {
+            type_info |= DLT_SCOD_BIN;
+        }
+
+        memcpy((log->buffer)+log->size,&(type_info),sizeof(uint32_t));
+        log->size += sizeof(uint32_t);
+    }
+
+    memcpy((log->buffer)+log->size,&data,sizeof(uint8_t));
+    log->size += sizeof(uint8_t);
+
+    log->args_num ++;
+
+    return 0;
+}
+
+int dlt_user_log_write_uint16_formatted(DltContextData *log, uint16_t data, DltFormatType type)
+{
+    uint32_t type_info;
+
+    if (log==0)
+    {
+        return -1;
+    }
+
+    if ((log->size+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+    {
+        return -1;
+    }
+
+    if (dlt_user.verbose_mode)
+    {
+        if ((log->size+sizeof(uint32_t)+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+        {
+            return -1;
+        }
+
+        type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
+
+        if(type>=DLT_FORMAT_HEX8 && type<=DLT_FORMAT_HEX64)
+        {
+            type_info |= DLT_SCOD_HEX;
+        }
+
+        else if(type>=DLT_FORMAT_BIN8 && type<=DLT_FORMAT_BIN16)
+        {
+            type_info |= DLT_SCOD_BIN;
+        }
+
+        memcpy((log->buffer)+log->size,&(type_info),sizeof(uint32_t));
+        log->size += sizeof(uint32_t);
+    }
+
+    memcpy((log->buffer)+log->size,&data,sizeof(uint16_t));
+    log->size += sizeof(uint16_t);
+
+    log->args_num ++;
+
+    return 0;
+}
+
+int dlt_user_log_write_uint32_formatted(DltContextData *log, uint32_t data, DltFormatType type)
+{
+    uint32_t type_info;
+
+    if (log==0)
+    {
+        return -1;
+    }
+
+    if ((log->size+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+    {
+        return -1;
+    }
+
+    if (dlt_user.verbose_mode)
+    {
+        if ((log->size+sizeof(uint32_t)+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+        {
+            return -1;
+        }
+
+        type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
+
+        if(type>=DLT_FORMAT_HEX8 && type<=DLT_FORMAT_HEX64)
+        {
+            type_info |= DLT_SCOD_HEX;
+        }
+
+        else if(type>=DLT_FORMAT_BIN8 && type<=DLT_FORMAT_BIN16)
+        {
+            type_info |= DLT_SCOD_BIN;
+        }
+
+        memcpy((log->buffer)+log->size,&(type_info),sizeof(uint32_t));
+        log->size += sizeof(uint32_t);
+    }
+
+    memcpy((log->buffer)+log->size,&data,sizeof(uint32_t));
+    log->size += sizeof(uint32_t);
+
+    log->args_num ++;
+
+    return 0;
+}
+
+int dlt_user_log_write_uint64_formatted(DltContextData *log, uint64_t data, DltFormatType type)
+{
+    uint32_t type_info;
+
+    if (log==0)
+    {
+        return -1;
+    }
+
+    if ((log->size+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+    {
+        return -1;
+    }
+
+    if (dlt_user.verbose_mode)
+    {
+        if ((log->size+sizeof(uint32_t)+sizeof(uint16_t))>DLT_USER_BUF_MAX_SIZE)
+        {
+            return -1;
+        }
+
+        type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
+
+        if(type>=DLT_FORMAT_HEX8 && type<=DLT_FORMAT_HEX64)
+        {
+            type_info |= DLT_SCOD_HEX;
+        }
+
+        else if(type>=DLT_FORMAT_BIN8 && type<=DLT_FORMAT_BIN16)
+        {
+            type_info |= DLT_SCOD_BIN;
+        }
+
+        memcpy((log->buffer)+log->size,&(type_info),sizeof(uint32_t));
+        log->size += sizeof(uint32_t);
+    }
+
+    memcpy((log->buffer)+log->size,&data,sizeof(uint64_t));
+    log->size += sizeof(uint64_t);
+
+    log->args_num ++;
+
+    return 0;
+}
+
 int dlt_user_log_write_int(DltContextData *log, int data)
 {
     if (log==0)
diff --git a/src/shared/dlt_common.c b/src/shared/dlt_common.c
index dd4d74a..d0beb97 100755
--- a/src/shared/dlt_common.c
+++ b/src/shared/dlt_common.c
@@ -3217,7 +3217,6 @@ int dlt_message_argument_print(DltMessage *msg,uint32_t type_info,uint8_t **ptr,
     int64_t value64f_tmp_int64i=0,value64f_tmp_int64i_swaped=0;
 
     uint32_t quantisation_tmp = 0;
-
     if ( (type_info & DLT_TYPE_INFO_STRG) && (((type_info & DLT_TYPE_INFO_SCOD) == DLT_SCOD_ASCII) || ((type_info & DLT_TYPE_INFO_SCOD) == DLT_SCOD_UTF8)) )
     {
 
@@ -3271,6 +3270,79 @@ int dlt_message_argument_print(DltMessage *msg,uint32_t type_info,uint8_t **ptr,
             return -1;
         snprintf(text+strlen(text),textlength-strlen(text),"%d",value8u);
     }
+    else if ((type_info & DLT_TYPE_INFO_UINT) && (DLT_SCOD_BIN == (type_info & DLT_TYPE_INFO_SCOD)))
+    {
+        if (DLT_TYLE_8BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            DLT_MSG_READ_VALUE(value8u,*ptr,*datalength,uint8_t); /* No endian conversion necessary */
+            if((*datalength)<0)
+                return -1;
+            char binary[10] = {'\0'}; // e.g.: "0b1100 0010"
+            int i;
+            for (i = (1 << 7); i > 0; i >>= 1)
+            {
+                if ((1<<3) == i)
+                    strcat(binary, " ");
+                strcat(binary, (i == (value8u & i)) ? "1" : "0");
+            }
+
+            snprintf(text+strlen(text),textlength-strlen(text),"0b%s",binary);
+        }
+        if (DLT_TYLE_16BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            DLT_MSG_READ_VALUE(value16u,*ptr,*datalength,uint16_t);
+            if((*datalength)<0)
+                return -1;
+            char binary[20] = {'\0'}; // e.g.: "0b1100 0010 0011 0110"
+            int i;
+            for (i = (1 << 15); i > 0; i >>= 1)
+            {
+                if (((1<<3) == i) || ((1<<7) == i) || ((1<<11) == i))
+                    strcat(binary, " ");
+                strcat(binary, (i == (value16u & i)) ? "1" : "0");
+            }
+
+            snprintf(text+strlen(text),textlength-strlen(text),"0b%s",binary);
+        }
+    }
+    else if ((type_info & DLT_TYPE_INFO_UINT) && (DLT_SCOD_HEX == (type_info & DLT_TYPE_INFO_SCOD)))
+    {
+        if (DLT_TYLE_8BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            DLT_MSG_READ_VALUE(value8u,*ptr,*datalength,uint8_t); /* No endian conversion necessary */
+            if((*datalength)<0)
+                return -1;
+            snprintf(text+strlen(text),textlength-strlen(text),"0x%02x",value8u);
+        }
+        if (DLT_TYLE_16BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            DLT_MSG_READ_VALUE(value16u,*ptr,*datalength,uint16_t);
+            if((*datalength)<0)
+                return -1;
+            snprintf(text+strlen(text),textlength-strlen(text),"0x%04x",value16u);
+        }
+        if (DLT_TYLE_32BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            DLT_MSG_READ_VALUE(value32u,*ptr,*datalength,uint32_t);
+            if((*datalength)<0)
+                return -1;
+            snprintf(text+strlen(text),textlength-strlen(text),"0x%08x",value32u);
+        }
+        if (DLT_TYLE_64BIT == (type_info & DLT_TYPE_INFO_TYLE))
+        {
+            *ptr += 4;
+            DLT_MSG_READ_VALUE(value32u,*ptr,*datalength,uint32_t);
+            if((*datalength)<0)
+                return -1;
+            snprintf(text+strlen(text),textlength-strlen(text),"0x%08x",value32u);
+            *ptr -= 8;
+            DLT_MSG_READ_VALUE(value32u,*ptr,*datalength,uint32_t);
+            if((*datalength)<0)
+                return -1;
+            snprintf(text+strlen(text),textlength-strlen(text),"%08x",value32u);
+            *ptr += 4;
+        }
+    }
     else if ((type_info & DLT_TYPE_INFO_SINT) || (type_info & DLT_TYPE_INFO_UINT))
     {
         /* signed or unsigned argument received */