dominic/st
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename to "ST"

Browse Source 
Name change due to confusion with the common programming verb "set".

Once again I cannot settle on a name.:
This commit is contained in:
Dominic Höglinger 2025-05-15 20:28:16 +02:00
parent 0e068e764d
commit 6da9ea8028
3 changed files with 203 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

310
set.c → st.c
View File

@ -1,5 +1,5 @@
/* /*
* SET: Streaming Event Trace - A tiny tracing library * ST: Streaming Trace - A tiny tracing library
* Copyright (C) 2025 Dominic Hoeglinger * Copyright (C) 2025 Dominic Hoeglinger
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@ -21,16 +21,16 @@
* SOFTWARE. * SOFTWARE.
*/ */
#include "set.h" #include "st.h"
#define SET_NIBBLE_TO_HEX(nibble) ((nibble) < 10 ? (nibble) + '0' : (nibble) - 10 + 'A') #define ST_NIBBLE_TO_HEX(nibble) ((nibble) < 10 ? (nibble) + '0' : (nibble) - 10 + 'A')
#define SET_NIBBLE(value, nibble) ((value >> nibble) & 0xF) #define ST_NIBBLE(value, nibble) ((value >> nibble) & 0xF)
#define SET_BYTE(value, offset) (char)(((value >> (8 * offset)) & 0xFF)) #define ST_BYTE(value, offset) (char)(((value >> (8 * offset)) & 0xFF))
#define SET_ENCODE(value, nibble) (char)(SET_NIBBLE_TO_HEX(SET_NIBBLE(value, nibble))) #define ST_ENCODE(value, nibble) (char)(ST_NIBBLE_TO_HEX(ST_NIBBLE(value, nibble)))
#define SET_NELEMS(a) (sizeof(a) / sizeof(a[0])) #define ST_NELEMS(a) (sizeof(a) / sizeof(a[0]))
#define SET_MACROPACK_FRAME_SIZE (2 * 8) #define ST_MACROPACK_FRAME_SIZE (2 * 8)
#define SET_MACROPACK_SIZE(n) (SET_MACROPACK_FRAME_SIZE * n + (SET_MACROPACK_FRAME_SIZE * n) / 254 + 1 + n - 1) #define ST_MACROPACK_SIZE(n) (ST_MACROPACK_FRAME_SIZE * n + (ST_MACROPACK_FRAME_SIZE * n) / 254 + 1 + n - 1)
#define SET_MAX_RENDER_SIZE(n) (SET_MACROPACK_SIZE(n) + (SET_MACROPACK_SIZE(n) / 254) + 1) #define ST_MAX_RENDER_SIZE(n) (ST_MACROPACK_SIZE(n) + (ST_MACROPACK_SIZE(n) / 254) + 1)
#define FASTLZ1_MAX_COPY 32 #define FASTLZ1_MAX_COPY 32
#define FASTLZ1_MAX_LEN 264 /* 256 + 8 */ #define FASTLZ1_MAX_LEN 264 /* 256 + 8 */
@ -44,43 +44,43 @@
typedef enum typedef enum
{ {
set_d1 = 0x11, st_d1 = 0x11,
set_d2 = 0x12, st_d2 = 0x12,
set_d4 = 0x14, st_d4 = 0x14,
set_v1 = 0x21, st_v1 = 0x21,
set_v2 = 0x22, st_v2 = 0x22,
set_v4 = 0x24, st_v4 = 0x24,
set_a1 = 0x31, st_a1 = 0x31,
set_a2 = 0x32, st_a2 = 0x32,
set_a4 = 0x34, st_a4 = 0x34,
set_s4 = 0x44, st_s4 = 0x44,
set_f4 = 0x54, st_f4 = 0x54,
set_ev = 0x60, st_ev = 0x60,
} set_type_t; } st_type_t;
typedef enum typedef enum
{ {
set_packet_z = (1 << 0), st_packet_z = (1 << 0),
} set_packetflags_t; } st_packetflags_t;
typedef struct typedef struct
{ {
const char* m_tag; const char* m_tag;
uint16_t m_hash; uint16_t m_hash;
} set_hashcache_t; } st_hashcache_t;
typedef union typedef union
{ {
uint32_t u32value; uint32_t u32value;
#if (!SET_FLOAT_DISABLE) #if (!ST_FLOAT_DISABLE)
float f32value; float f32value;
#endif #endif
} set_convert_t; } st_convert_t;
static bool s_enabled = false; static bool s_enabled = false;
static uint32_t s_last_time = 0; static uint32_t s_last_time = 0;
set_overflow_policy_t s_policy = set_overwrite; st_overflow_policy_t s_policy = st_overwrite;
static set_trace_t* s_tracebuffer; static st_trace_t* s_tracebuffer;
static size_t s_tracebuffer_size = 0; static size_t s_tracebuffer_size = 0;
static size_t s_tracebuffer_head = 0; static size_t s_tracebuffer_head = 0;
static size_t s_tracebuffer_tail = 0; static size_t s_tracebuffer_tail = 0;
@ -100,39 +100,39 @@ static uint32_t s_diag_avg_ctime_n = 0;
static uint32_t s_diag_avg_rtime_total = 0; static uint32_t s_diag_avg_rtime_total = 0;
static uint32_t s_diag_avg_rtime_n = 0; static uint32_t s_diag_avg_rtime_n = 0;
#if (SET_HASHCACHE_LINES > 0) #if (ST_HASHCACHE_LINES > 0)
static set_hashcache_t s_hashcache[SET_HASHCACHE_LINES] = {0}; static st_hashcache_t s_hashcache[ST_HASHCACHE_LINES] = {0};
static size_t s_hashcache_index = 0; static size_t s_hashcache_index = 0;
#endif #endif
size_t render_macropacket_payload(char buffer[], const size_t buffer_size, size_t n); size_t render_macropacket_payload(char buffer[], const size_t buffer_size, size_t n);
static size_t frame_preamble(char buffer[], const size_t buffer_size); static size_t frame_preamble(char buffer[], const size_t buffer_size);
static size_t frame_epilouge(char buffer[], const size_t buffer_size); static size_t frame_epilouge(char buffer[], const size_t buffer_size);
static size_t pack_frame(char packet_bytes[], const set_trace_t* const p_packet); static size_t pack_frame(char packet_bytes[], const st_trace_t* const p_packet);
static size_t ttyize_payload(char packet_buffer[], const size_t packet_size, const size_t buffer_size); static size_t ttyize_payload(char packet_buffer[], const size_t packet_size, const size_t buffer_size);
static uint16_t bsd_hash(const char* const str, size_t n); static uint16_t bsd_hash(const char* const str, size_t n);
static bool populate_time_delta_packet(const uint32_t timestamp, set_trace_t* const p_trace); static bool populate_time_delta_packet(const uint32_t timestamp, st_trace_t* const p_trace);
static void tracebuffer_add(const uint32_t timestamp, const set_type_t type, const uint32_t value, const uint8_t sub, char const *tag); static void tracebuffer_add(const uint32_t timestamp, const st_type_t type, const uint32_t value, const uint8_t sub, char const *tag);
size_t cobs_encode(uint8_t* dst, size_t dst_buf_len, const uint8_t* ptr, int len, uint8_t delim); size_t cobs_encode(uint8_t* dst, size_t dst_buf_len, const uint8_t* ptr, int len, uint8_t delim);
static int fastlz1_compress(const void* input, int length, void* output); static int fastlz1_compress(const void* input, int length, void* output);
void set_init(set_trace_t tracebuffer[], size_t ntraces) void st_init(st_trace_t tracebuffer[], size_t ntraces)
{ {
s_tracebuffer = tracebuffer; s_tracebuffer = tracebuffer;
s_tracebuffer_size = ntraces; s_tracebuffer_size = ntraces;
} }
size_t set_get_buffer_items(void) size_t st_get_buffer_items(void)
{ {
return s_tracebuffer_items; return s_tracebuffer_items;
} }
void set_tty_mode(const bool enable) void st_tty_mode(const bool enable)
{ {
s_tty_enabled = enable; s_tty_enabled = enable;
} }
size_t set_tty_rubout(char buffer[], const size_t buffer_size) size_t st_tty_rubout(char buffer[], const size_t buffer_size)
{ {
const size_t rubout_packet_size = 3 + s_tty_rubout_len + 3; const size_t rubout_packet_size = 3 + s_tty_rubout_len + 3;
size_t buffer_pos = 0; size_t buffer_pos = 0;
@ -153,27 +153,27 @@ size_t set_tty_rubout(char buffer[], const size_t buffer_size)
return buffer_pos; return buffer_pos;
} }
size_t set_output(size_t n, const bool compress, const bool rubout) size_t st_output(size_t n, const bool compress, const bool rubout)
{ {
const size_t render_number_items = 4; const size_t render_number_items = 4;
const size_t render_max_size = SET_MAX_RENDER_SIZE(render_number_items); const size_t render_max_size = ST_MAX_RENDER_SIZE(render_number_items);
char packet_bytes[SET_MAX_RENDER_SIZE(4)] = {0}; char packet_bytes[ST_MAX_RENDER_SIZE(4)] = {0};
size_t packet_size = 0; size_t packet_size = 0;
size_t i = 0; size_t i = 0;
n = (n == 0) ? s_tracebuffer_size : n; n = (n == 0) ? s_tracebuffer_size : n;
while ((s_tracebuffer_full || (s_tracebuffer_tail != s_tracebuffer_head)) && (i < n)) while ((s_tracebuffer_full || (s_tracebuffer_tail != s_tracebuffer_head)) && (i < n))
{ {
packet_size = set_render(packet_bytes, render_max_size, render_number_items, compress); packet_size = st_render(packet_bytes, render_max_size, render_number_items, compress);
i += render_number_items; i += render_number_items;
set_out(packet_bytes, packet_size); st_out(packet_bytes, packet_size);
} }
if (rubout) if (rubout)
{ {
packet_size = set_tty_rubout(packet_bytes, render_max_size); packet_size = st_tty_rubout(packet_bytes, render_max_size);
set_out(packet_bytes, packet_size); st_out(packet_bytes, packet_size);
} }
return i; return i;
@ -184,7 +184,7 @@ size_t render_macropacket_payload(char buffer[], const size_t buffer_size, size_
const size_t max_render_size = (8 + 1 + 1) * 2 - 1; const size_t max_render_size = (8 + 1 + 1) * 2 - 1;
char payload_buffer[8] = {0}; char payload_buffer[8] = {0};
char delimimter = 0x00; char delimimter = 0x00;
set_trace_t timestamp_pack = {0}; st_trace_t timestamp_pack = {0};
size_t payload_size = 0; size_t payload_size = 0;
size_t i = 0; size_t i = 0;
size_t buffer_pos = 0; size_t buffer_pos = 0;
@ -223,20 +223,20 @@ size_t render_macropacket_payload(char buffer[], const size_t buffer_size, size_
return buffer_pos; return buffer_pos;
} }
size_t set_render(char buffer[], const size_t buffer_size, const size_t n, const bool compress) size_t st_render(char buffer[], const size_t buffer_size, const size_t n, const bool compress)
{ {
const char delimimter = '\033'; const char delimimter = '\033';
size_t n_elems = (n == 0) ? s_tracebuffer_items : n; size_t n_elems = (n == 0) ? s_tracebuffer_items : n;
n_elems = (s_tty_enabled && (n > 4)) ? 4 : n_elems; n_elems = (s_tty_enabled && (n > 4)) ? 4 : n_elems;
size_t render_max_size = SET_MAX_RENDER_SIZE(n_elems); size_t render_max_size = ST_MAX_RENDER_SIZE(n_elems);
uint32_t ticks_render_start = set_timestamp(); uint32_t ticks_render_start = st_timestamp();
char *final_payload_buffer = NULL; char *final_payload_buffer = NULL;
size_t final_payload_size = 0; size_t final_payload_size = 0;
while ((buffer_size < (1 + (render_max_size * 2))) && (n_elems > 0)) while ((buffer_size < (1 + (render_max_size * 2))) && (n_elems > 0))
{ {
n_elems--; n_elems--;
render_max_size = SET_MAX_RENDER_SIZE(n_elems); render_max_size = ST_MAX_RENDER_SIZE(n_elems);
} }
if (n_elems == 0) return 0; if (n_elems == 0) return 0;
@ -248,11 +248,11 @@ size_t set_render(char buffer[], const size_t buffer_size, const size_t n, const
size_t compressed_size = macropack_payload_size + (macropack_payload_size*15)/100; size_t compressed_size = macropack_payload_size + (macropack_payload_size*15)/100;
char *compressed_buffer = &buffer[buffer_size - compressed_size]; char *compressed_buffer = &buffer[buffer_size - compressed_size];
uint32_t ticks_comp_start = set_timestamp(); uint32_t ticks_comp_start = st_timestamp();
compressed_size = fastlz1_compress(buffer, macropack_payload_size, compressed_buffer); compressed_size = fastlz1_compress(buffer, macropack_payload_size, compressed_buffer);
final_payload_buffer = compressed_buffer; final_payload_buffer = compressed_buffer;
final_payload_size = compressed_size; final_payload_size = compressed_size;
s_diag_avg_ctime_total += set_timestamp() - ticks_comp_start; s_diag_avg_ctime_total += st_timestamp() - ticks_comp_start;
s_diag_avg_ctime_n++; s_diag_avg_ctime_n++;
if (macropack_payload_size > 0) if (macropack_payload_size > 0)
@ -275,7 +275,7 @@ size_t set_render(char buffer[], const size_t buffer_size, const size_t n, const
size_t out_pos = frame_preamble(buffer, buffer_size); size_t out_pos = frame_preamble(buffer, buffer_size);
uint8_t flags = 0; uint8_t flags = 0;
if (compress) flags |= (uint8_t)set_packet_z; if (compress) flags |= (uint8_t)st_packet_z;
buffer[out_pos] = flags; buffer[out_pos] = flags;
out_pos++; out_pos++;
@ -293,54 +293,54 @@ size_t set_render(char buffer[], const size_t buffer_size, const size_t n, const
out_pos += payload_size; out_pos += payload_size;
out_pos += frame_epilouge(&buffer[out_pos], buffer_size - out_pos); out_pos += frame_epilouge(&buffer[out_pos], buffer_size - out_pos);
s_diag_avg_rtime_total += set_timestamp() - ticks_render_start; s_diag_avg_rtime_total += st_timestamp() - ticks_render_start;
s_diag_avg_rtime_n++; s_diag_avg_rtime_n++;
return out_pos; return out_pos;
} }
void set_enable(const set_overflow_policy_t policy) void st_enable(const st_overflow_policy_t policy)
{ {
s_policy = policy; s_policy = policy;
s_enabled = true; s_enabled = true;
} }
void set_disable(void) void st_disable(void)
{ {
s_enabled = false; s_enabled = false;
} }
void set_clear(void) void st_clear(void)
{ {
s_tracebuffer_tail = s_tracebuffer_head; s_tracebuffer_tail = s_tracebuffer_head;
s_tracebuffer_full = false; s_tracebuffer_full = false;
} }
void set_diagtrace(void) void st_diagtrace(void)
{ {
const uint32_t buffer_health = ((s_tracebuffer_size - s_tracebuffer_items) * 0xFF)/s_tracebuffer_size; const uint32_t buffer_health = ((s_tracebuffer_size - s_tracebuffer_items) * 0xFF)/s_tracebuffer_size;
set_u32trace("SET.BufferItems", s_tracebuffer_items, false); st_u32trace("ST.BufferItems", s_tracebuffer_items, false);
set_u8trace("SET.BufferHealth", (uint8_t)buffer_health, true); st_u8trace("ST.BufferHealth", (uint8_t)buffer_health, true);
if (s_diag_avg_compression_n > 0) if (s_diag_avg_compression_n > 0)
{ {
const uint32_t average = s_diag_avg_compression_total / s_diag_avg_compression_n; const uint32_t average = s_diag_avg_compression_total / s_diag_avg_compression_n;
set_u8trace("SET.CompressionLevel", (uint8_t)average, true); st_u8trace("ST.CompressionLevel", (uint8_t)average, true);
s_diag_avg_compression_total = 0; s_diag_avg_compression_total = 0;
s_diag_avg_compression_n = 0; s_diag_avg_compression_n = 0;
} }
if (s_diag_items_sent > 0) if (s_diag_items_sent > 0)
{ {
set_u32trace("SET.ItemsSent", s_diag_items_sent, true); st_u32trace("ST.ItemsSent", s_diag_items_sent, true);
s_diag_items_sent = 0; s_diag_items_sent = 0;
} }
if (s_diag_avg_ctime_n > 0) if (s_diag_avg_ctime_n > 0)
{ {
const uint32_t average = s_diag_avg_ctime_total / s_diag_avg_ctime_n; const uint32_t average = s_diag_avg_ctime_total / s_diag_avg_ctime_n;
set_u8trace("SET.CompressionTime", (uint8_t)average, true); st_u8trace("ST.CompressionTime", (uint8_t)average, true);
s_diag_avg_ctime_total = 0; s_diag_avg_ctime_total = 0;
s_diag_avg_ctime_n = 0; s_diag_avg_ctime_n = 0;
} }
@ -349,147 +349,147 @@ void set_diagtrace(void)
if (s_diag_avg_rtime_n > 0) if (s_diag_avg_rtime_n > 0)
{ {
const uint32_t average = s_diag_avg_rtime_total / s_diag_avg_rtime_n; const uint32_t average = s_diag_avg_rtime_total / s_diag_avg_rtime_n;
set_u8trace("SET.RenderTime", (uint8_t)average, true); st_u8trace("ST.RenderTime", (uint8_t)average, true);
s_diag_avg_rtime_total = 0; s_diag_avg_rtime_total = 0;
s_diag_avg_rtime_n = 0; s_diag_avg_rtime_n = 0;
} }
} }
void set_evtrace(const char* const tag, const bool skip_time) void st_evtrace(const char* const tag, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_ev, 1UL, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_ev, 1UL, 0U, tag);
} }
} }
void set_u8trace(const char* const tag, const uint8_t value, const bool skip_time) void st_u8trace(const char* const tag, const uint8_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v1, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v1, (uint32_t)value, 0U, tag);
} }
} }
void set_u16trace(const char* const tag, const uint16_t value, const bool skip_time) void st_u16trace(const char* const tag, const uint16_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v2, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v2, (uint32_t)value, 0U, tag);
} }
} }
void set_u32trace(const char* const tag, const uint32_t value, const bool skip_time) void st_u32trace(const char* const tag, const uint32_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v4, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v4, (uint32_t)value, 0U, tag);
} }
} }
void set_s8trace(const char* const tag, const int8_t value, const bool skip_time) void st_s8trace(const char* const tag, const int8_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v1, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v1, (uint32_t)value, 0U, tag);
} }
} }
void set_s16trace(const char* const tag, const int16_t value, const bool skip_time) void st_s16trace(const char* const tag, const int16_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v2, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v2, (uint32_t)value, 0U, tag);
} }
} }
void set_s4trace(const char* const tag, const int32_t value, const bool skip_time) void st_s4trace(const char* const tag, const int32_t value, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_v4, (uint32_t)value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_v4, (uint32_t)value, 0U, tag);
} }
} }
void set_au8trace(const char* const tag, const uint8_t value[const], const uint8_t size, const bool skip_time) void st_au8trace(const char* const tag, const uint8_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
tracebuffer_add(ts, set_a1, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a1, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_au16trace(const char* const tag, const uint16_t value[const], const uint8_t size, const bool skip_time) void st_au16trace(const char* const tag, const uint16_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
tracebuffer_add(ts, set_a2, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a2, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_au32trace(const char* const tag, const uint32_t value[const], const uint8_t size, const bool skip_time) void st_au32trace(const char* const tag, const uint32_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
uint16_t sub = (i) | (size << 8); uint16_t sub = (i) | (size << 8);
tracebuffer_add(ts, set_a4, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a4, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_as8trace(const char* const tag, const int8_t value[const], const uint8_t size, const bool skip_time) void st_as8trace(const char* const tag, const int8_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
tracebuffer_add(ts, set_a1, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a1, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_as16trace(const char* const tag, const int16_t value[const], const uint8_t size, const bool skip_time) void st_as16trace(const char* const tag, const int16_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
tracebuffer_add(ts, set_a2, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a2, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_as32trace(const char* const tag, const int32_t value[const], const uint8_t size, const bool skip_time) void st_as32trace(const char* const tag, const int32_t value[const], const uint8_t size, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
{ {
uint16_t sub = (i) | (size << 8); uint16_t sub = (i) | (size << 8);
tracebuffer_add(ts, set_a4, (uint32_t)value[i], (uint8_t)i, tag); tracebuffer_add(ts, st_a4, (uint32_t)value[i], (uint8_t)i, tag);
} }
} }
} }
void set_strtrace(const char* const tag, const char* const str, const bool skip_time) void st_strtrace(const char* const tag, const char* const str, const bool skip_time)
{ {
if (s_enabled == true) if (s_enabled == true)
{ {
const size_t ts = skip_time ? 0UL : set_timestamp(); const size_t ts = skip_time ? 0UL : st_timestamp();
uint32_t packword = 0; uint32_t packword = 0;
uint8_t packindex = 0; uint8_t packindex = 0;
for (size_t i = 0; str[i] != '\0'; ++i) for (size_t i = 0; str[i] != '\0'; ++i)
@ -498,24 +498,24 @@ void set_strtrace(const char* const tag, const char* const str, const bool skip_
packword |= (str[i] << (8 * packindex)); packword |= (str[i] << (8 * packindex));
if (packindex == 3) if (packindex == 3)
{ {
tracebuffer_add(ts, set_s4, packword, (uint8_t)str[i + 1] == '\0', tag); tracebuffer_add(ts, st_s4, packword, (uint8_t)str[i + 1] == '\0', tag);
packword = 0; packword = 0;
} }
} }
if (packindex != 3) if (packindex != 3)
{ {
tracebuffer_add(ts, set_s4, packword, (uint8_t)true, tag); tracebuffer_add(ts, st_s4, packword, (uint8_t)true, tag);
} }
} }
} }
#if (!SET_FLOAT_DISABLE) #if (!ST_FLOAT_DISABLE)
void set_f32trace(const char* const tag, const float value, const bool skip_time) void st_f32trace(const char* const tag, const float value, const bool skip_time)
{ {
set_convert_t converter = {.f32value = value }; st_convert_t converter = {.f32value = value };
if (s_enabled == true) if (s_enabled == true)
{ {
tracebuffer_add(skip_time ? 0UL : set_timestamp(), set_f4, converter.u32value, 0U, tag); tracebuffer_add(skip_time ? 0UL : st_timestamp(), st_f4, converter.u32value, 0U, tag);
} }
} }
#endif #endif
@ -544,56 +544,56 @@ static size_t frame_epilouge(char buffer[], const size_t buffer_size)
return pack_pos; return pack_pos;
} }
static size_t pack_frame(char packet_bytes[], const set_trace_t* const p_packet) static size_t pack_frame(char packet_bytes[], const st_trace_t* const p_packet)
{ {
size_t packet_size = 0; size_t packet_size = 0;
packet_bytes[packet_size++] = (char)p_packet->m_type; packet_bytes[packet_size++] = (char)p_packet->m_type;
switch ((set_type_t)p_packet->m_type) switch ((st_type_t)p_packet->m_type)
{ {
case set_v1: case st_v1:
case set_a1: case st_a1:
case set_d1: case st_d1:
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 0); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 0);
break; break;
case set_v2: case st_v2:
case set_a2: case st_a2:
case set_d2: case st_d2:
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 0); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 0);
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 1); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 1);
break; break;
case set_v4: case st_v4:
case set_a4: case st_a4:
case set_s4: case st_s4:
case set_f4: case st_f4:
case set_d4: case st_d4:
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 0); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 0);
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 1); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 1);
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 2); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 2);
packet_bytes[packet_size++] = SET_BYTE(p_packet->m_value, 3); packet_bytes[packet_size++] = ST_BYTE(p_packet->m_value, 3);
break; break;
} }
switch ((set_type_t)p_packet->m_type) switch ((st_type_t)p_packet->m_type)
{ {
case set_a1: case st_a1:
case set_a2: case st_a2:
case set_a4: case st_a4:
case set_s4: case st_s4:
packet_bytes[packet_size++] = (char)p_packet->m_sub; packet_bytes[packet_size++] = (char)p_packet->m_sub;
break; break;
} }
switch ((set_type_t)p_packet->m_type) switch ((st_type_t)p_packet->m_type)
{ {
case set_d1: case st_d1:
case set_d2: case st_d2:
case set_d4: case st_d4:
break; break;
default: default:
const uint16_t hash_tag = bsd_hash(p_packet->m_tag, SET_MAX_TAG_LEN); const uint16_t hash_tag = bsd_hash(p_packet->m_tag, ST_MAX_TAG_LEN);
packet_bytes[packet_size++] = SET_BYTE(hash_tag, 0); packet_bytes[packet_size++] = ST_BYTE(hash_tag, 0);
packet_bytes[packet_size++] = SET_BYTE(hash_tag, 1); packet_bytes[packet_size++] = ST_BYTE(hash_tag, 1);
break; break;
} }
@ -613,8 +613,8 @@ static size_t ttyize_payload(char packet_buffer[], const size_t packet_size, con
{ {
value = packet_buffer[(packet_size - i - 1)]; value = packet_buffer[(packet_size - i - 1)];
backpos = (packet_size - i - 1) * 2; backpos = (packet_size - i - 1) * 2;
packet_buffer[backpos] = SET_ENCODE(value, 0); packet_buffer[backpos] = ST_ENCODE(value, 0);
packet_buffer[backpos + 1] = SET_ENCODE(value, 4); packet_buffer[backpos + 1] = ST_ENCODE(value, 4);
} }
return tty_packet_size; return tty_packet_size;
@ -625,10 +625,10 @@ static uint16_t bsd_hash(const char* const str, size_t n)
uint32_t checksum = 0; uint32_t checksum = 0;
if (str == NULL) return 0U; if (str == NULL) return 0U;
#if (SET_HASHCACHE_LINES > 0) #if (ST_HASHCACHE_LINES > 0)
for (size_t i = 0; i < SET_HASHCACHE_LINES; ++i) for (size_t i = 0; i < ST_HASHCACHE_LINES; ++i)
{ {
size_t hash_index = (i + s_hashcache_index) % SET_HASHCACHE_LINES; size_t hash_index = (i + s_hashcache_index) % ST_HASHCACHE_LINES;
if (s_hashcache[hash_index].m_tag == str) if (s_hashcache[hash_index].m_tag == str)
{ {
return s_hashcache[hash_index].m_hash; return s_hashcache[hash_index].m_hash;
@ -641,8 +641,8 @@ static uint16_t bsd_hash(const char* const str, size_t n)
checksum += str[i]; checksum += str[i];
checksum &= 0xFFFF; checksum &= 0xFFFF;
} }
#if (SET_HASHCACHE_LINES > 0) #if (ST_HASHCACHE_LINES > 0)
s_hashcache_index = (s_hashcache_index + 1) % SET_HASHCACHE_LINES; s_hashcache_index = (s_hashcache_index + 1) % ST_HASHCACHE_LINES;
s_hashcache[s_hashcache_index].m_hash = checksum; s_hashcache[s_hashcache_index].m_hash = checksum;
s_hashcache[s_hashcache_index].m_tag = str; s_hashcache[s_hashcache_index].m_tag = str;
#endif #endif
@ -650,7 +650,7 @@ static uint16_t bsd_hash(const char* const str, size_t n)
return checksum; return checksum;
} }
static bool populate_time_delta_packet(const uint32_t timestamp, set_trace_t* const p_trace) static bool populate_time_delta_packet(const uint32_t timestamp, st_trace_t* const p_trace)
{ {
const uint32_t dt = timestamp - s_last_time; const uint32_t dt = timestamp - s_last_time;
uint16_t type = 0; uint16_t type = 0;
@ -661,15 +661,15 @@ static bool populate_time_delta_packet(const uint32_t timestamp, set_trace_t* co
{ {
if (dt > 0xFFFF) if (dt > 0xFFFF)
{ {
type = set_d4; type = st_d4;
} }
else if (dt > 0xFF) else if (dt > 0xFF)
{ {
type = set_d2; type = st_d2;
} }
else else
{ {
type = set_d1; type = st_d1;
} }
p_trace->m_type = type; p_trace->m_type = type;
@ -685,18 +685,18 @@ static bool populate_time_delta_packet(const uint32_t timestamp, set_trace_t* co
return false; return false;
} }
static void tracebuffer_add(const uint32_t timestamp, const set_type_t type, const uint32_t value, const uint8_t sub, char const *tag) static void tracebuffer_add(const uint32_t timestamp, const st_type_t type, const uint32_t value, const uint8_t sub, char const *tag)
{ {
const size_t insertion_pos = s_tracebuffer_head; const size_t insertion_pos = s_tracebuffer_head;
uint32_t critical_h = 0UL; uint32_t critical_h = 0UL;
if (s_tracebuffer_full == false || s_policy == set_overwrite) if (s_tracebuffer_full == false || s_policy == st_overwrite)
{ {
set_crit_on(&critical_h); st_crit_on(&critical_h);
s_tracebuffer_head = (s_tracebuffer_head + 1) % s_tracebuffer_size; s_tracebuffer_head = (s_tracebuffer_head + 1) % s_tracebuffer_size;
s_tracebuffer_full = (s_tracebuffer_head == s_tracebuffer_tail); s_tracebuffer_full = (s_tracebuffer_head == s_tracebuffer_tail);
s_tracebuffer_items++; s_tracebuffer_items++;
set_crit_off(critical_h); st_crit_off(critical_h);
s_tracebuffer[insertion_pos].m_type = (uint8_t)type; s_tracebuffer[insertion_pos].m_type = (uint8_t)type;
s_tracebuffer[insertion_pos].m_value = value; s_tracebuffer[insertion_pos].m_value = value;
@ -761,7 +761,7 @@ static uint16_t flz_hash(uint32_t v) {
} }
static void set_memcpy(uint8_t* dest, const uint8_t* src, uint32_t count) static void st_memcpy(uint8_t* dest, const uint8_t* src, uint32_t count)
{ {
for(size_t i = 0; i < count; ++i) for(size_t i = 0; i < count; ++i)
{ {
@ -779,14 +779,14 @@ static uint32_t flz_cmp(const uint8_t* p, const uint8_t* q, const uint8_t* r) {
static uint8_t* flz_literals(uint32_t runs, const uint8_t* src, uint8_t* dest) { static uint8_t* flz_literals(uint32_t runs, const uint8_t* src, uint8_t* dest) {
while (runs >= FASTLZ1_MAX_COPY) { while (runs >= FASTLZ1_MAX_COPY) {
*dest++ = FASTLZ1_MAX_COPY - 1; *dest++ = FASTLZ1_MAX_COPY - 1;
set_memcpy(dest, src, FASTLZ1_MAX_COPY); st_memcpy(dest, src, FASTLZ1_MAX_COPY);
src += FASTLZ1_MAX_COPY; src += FASTLZ1_MAX_COPY;
dest += FASTLZ1_MAX_COPY; dest += FASTLZ1_MAX_COPY;
runs -= FASTLZ1_MAX_COPY; runs -= FASTLZ1_MAX_COPY;
} }
if (runs > 0) { if (runs > 0) {
*dest++ = runs - 1; *dest++ = runs - 1;
set_memcpy(dest, src, runs); st_memcpy(dest, src, runs);
dest += runs; dest += runs;
} }
return dest; return dest;

96
set.h → st.h
View File

@ -1,5 +1,5 @@
/* /*
* SET: Streaming Event Trace - A tiny tracing library * ST: Streaming Trace - A tiny tracing library
* Copyright (C) 2025 Dominic Hoeglinger * Copyright (C) 2025 Dominic Hoeglinger
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
@ -21,28 +21,28 @@
* SOFTWARE. * SOFTWARE.
*/ */
#ifndef SET_H_INCLUDED_ #ifndef ST_H_INCLUDED_
#define SET_H_INCLUDED_ #define ST_H_INCLUDED_
#include <stddef.h> #include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
/** Maxmum signal name / tag length considered for the identifying hash */ /** Maxmum signal name / tag length considered for the identifying hash */
#define SET_MAX_TAG_LEN (126) #define ST_MAX_TAG_LEN (126)
/** Number of cached hashes */ /** Number of cached hashes */
#define SET_HASHCACHE_LINES (64) #define ST_HASHCACHE_LINES (64)
/** Switch to enable or disable floating point support */ /** Switch to enable or disable floating point support */
#define SET_FLOAT_DISABLE (false) #define ST_FLOAT_DISABLE (false)
/** Overflow policy for the tracebuffer */ /** Overflow policy for the tracebuffer */
typedef enum typedef enum
{ {
set_overwrite, /**< Overwrite oldest samples */ st_overwrite, /**< Overwrite oldest samples */
set_drop /**< Drop newest samples */ st_drop /**< Drop newest samples */
} set_overflow_policy_t; } st_overflow_policy_t;
/** Element used to allocate the tracebuffer */ /** Element used to allocate the tracebuffer */
typedef struct typedef struct
@ -52,51 +52,51 @@ typedef struct
uint32_t m_value; uint32_t m_value;
uint8_t m_type; uint8_t m_type;
uint8_t m_sub; uint8_t m_sub;
} set_trace_t; } st_trace_t;
/** @brief Integration hook writing out a packet to the desired interface /** @brief Integration hook writing out a packet to the desired interface
* @param[in] str Packet data * @param[in] str Packet data
* @param[in] len Packet data length * @param[in] len Packet data length
* @return None * @return None
*/ */
void set_out(const char* const str, size_t len); void st_out(const char* const str, size_t len);
/** @brief Integration hook for retrieving a timestamp /** @brief Integration hook for retrieving a timestamp
* @return Timestamp value * @return Timestamp value
*/ */
uint32_t set_timestamp(void); uint32_t st_timestamp(void);
/** @brief Integration hook which locks the tracebuffer /** @brief Integration hook which locks the tracebuffer
* This can be for instance a mutex or interrupt lock. * This can be for instance a mutex or interrupt lock.
* @param[out] h handle value which will be passed to the #set_crit_off function * @param[out] h handle value which will be passed to the #set_crit_off function
*/ */
void set_crit_on(uint32_t *h); void st_crit_on(uint32_t *h);
/** @brief Integration hook which unlocks the tracebuffer /** @brief Integration hook which unlocks the tracebuffer
* @param[in] h handle value set by #set_crit_on * @param[in] h handle value set by #set_crit_on
*/ */
void set_crit_off(const uint32_t h); void st_crit_off(const uint32_t h);
/** @brief Initializes PET with the provided trace buffer /** @brief Initializes PET with the provided trace buffer
* @param[in] str Trace buffer array * @param[in] str Trace buffer array
* @param[in] len Trace buffer array length * @param[in] len Trace buffer array length
* @return None * @return None
*/ */
void set_init(set_trace_t tracebuffer[], size_t ntraces); void st_init(st_trace_t tracebuffer[], size_t ntraces);
/** @brief Returns the current trace buffer utilization /** @brief Returns the current trace buffer utilization
* @return Number of items used in the trace buffer * @return Number of items used in the trace buffer
*/ */
size_t set_get_buffer_items(void); size_t st_get_buffer_items(void);
/** @brief Enables or disables TTY mode /** @brief Enables or disables TTY mode
* TTY mode esures packet output is friendly for interactive console usage without a client. * TTY mode esures packet output is friendly for interactive console usage without a client.
* This means that at most 4 packets are sent at once, the data is encoded as hex digits * This means that at most 4 packets are sent at once, the data is encoded as hex digits
* and position is restored with each transmit. To erase a transmitted packet, see set_tty_rubout. * and position is restored with each transmit. To erase a transmitted packet, see st_tty_rubout.
* @param[in] enable If true, enable TTY mode * @param[in] enable If true, enable TTY mode
* @return None * @return None
*/ */
void set_tty_mode(const bool enable); void st_tty_mode(const bool enable);
/** @brief Creates a rubout packet clearing the maximum amount of data transmitted in TTY mode. /** @brief Creates a rubout packet clearing the maximum amount of data transmitted in TTY mode.
* This consists of a ANSI store, enough spaces to overwrite sent data and an ANSI restore. * This consists of a ANSI store, enough spaces to overwrite sent data and an ANSI restore.
@ -104,32 +104,32 @@ void set_tty_mode(const bool enable);
* @param[in] buffer_size the size of the output buffer * @param[in] buffer_size the size of the output buffer
* @return The packet size written to the buffer * @return The packet size written to the buffer
*/ */
size_t set_tty_rubout(char buffer[], const size_t buffer_size); size_t st_tty_rubout(char buffer[], const size_t buffer_size);
/** @brief Enables tracing with the provided overflow policy /** @brief Enables tracing with the provided overflow policy
* @param[in] policy Either overwrite to overwrite oldest trace, or drop to drop the newest sample * @param[in] policy Either overwrite to overwrite oldest trace, or drop to drop the newest sample
* @return None * @return None
*/ */
void set_enable(const set_overflow_policy_t policy); void st_enable(const st_overflow_policy_t policy);
/** @brief Disables tracing /** @brief Disables tracing
* @return None * @return None
*/ */
void set_disable(void); void st_disable(void);
/** @brief Clears the trace buffer deleting all captures samples /** @brief Clears the trace buffer deleting all captures samples
* @return None * @return None
*/ */
void set_clear(void); void st_clear(void);
/** @brief Render a set amount of tracebuffer items and write them out using set_out /** @brief Render a set amount of tracebuffer items and write them out using st_out
* This function is for basic usage where the output function writes into a managed stream such as stdout * This function is for basic usage where the output function writes into a managed stream such as stdout
* @param[in] n Number of tracebuffer items to render, or 0 for the current size of the tracebuffer * @param[in] n Number of tracebuffer items to render, or 0 for the current size of the tracebuffer
* @param[in] compress if true, render the packets compressed * @param[in] compress if true, render the packets compressed
* @param[in] rubout if true, sends a rubout packet at the end clearing the trace output on a terminal * @param[in] rubout if true, sends a rubout packet at the end clearing the trace output on a terminal
* @return None * @return None
*/ */
size_t set_output(size_t n, const bool compress, const bool rubout); size_t st_output(size_t n, const bool compress, const bool rubout);
/** @brief Render a set amount of tracebuffer items and store them in the provided buffer /** @brief Render a set amount of tracebuffer items and store them in the provided buffer
* This advanced function is intended to be used with DMA buffers. * This advanced function is intended to be used with DMA buffers.
@ -139,26 +139,26 @@ size_t set_output(size_t n, const bool compress, const bool rubout);
* @param[in] compress if true, render the packets compressed * @param[in] compress if true, render the packets compressed
* @return None * @return None
*/ */
size_t set_render(char buffer[], const size_t buffer_size, const size_t n, const bool compress); size_t st_render(char buffer[], const size_t buffer_size, const size_t n, const bool compress);
/** @brief Adds diagnostic samples to the tracebuffer /** @brief Adds diagnostic samples to the tracebuffer
* Signals include: * Signals include:
* - SET.BufferItems:u32 - The current amount of tracebuffer items * - ST.BufferItems:u32 - The current amount of tracebuffer items
* - SET.BufferHealth:u8 - The buffer utilization, zero means that the buffer is full while 255 means the buffer is free * - ST.BufferHealth:u8 - The buffer utilization, zero means that the buffer is full while 255 means the buffer is free
* - SET.CompressionLevel:u8 - The average compression level if packets are rendered compressed * - ST.CompressionLevel:u8 - The average compression level if packets are rendered compressed
* - SET.CompressionTime:u32 - The average compression time spent for one packet render * - ST.CompressionTime:u32 - The average compression time spent for one packet render
* - SET.RenderTime:u32 - The average render time for one packet * - ST.RenderTime:u32 - The average render time for one packet
* - SET.ItemsSent:u32 - The number of items sent since the last call to this function * - ST.ItemsSent:u32 - The number of items sent since the last call to this function
* @return None * @return None
*/ */
void set_diagtrace(void); void st_diagtrace(void);
/** @brief Trace an event /** @brief Trace an event
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_evtrace(const char* const tag, const bool skip_time); void st_evtrace(const char* const tag, const bool skip_time);
/** @brief Trace an u8 value /** @brief Trace an u8 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -166,7 +166,7 @@ void set_evtrace(const char* const tag, const bool skip_time);
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_u8trace(const char* const tag, const uint8_t value, const bool skip_time); void st_u8trace(const char* const tag, const uint8_t value, const bool skip_time);
/** @brief Trace an u16 value /** @brief Trace an u16 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -174,7 +174,7 @@ void set_u8trace(const char* const tag, const uint8_t value, const bool skip_tim
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_u16trace(const char* const tag, const uint16_t value, const bool skip_time); void st_u16trace(const char* const tag, const uint16_t value, const bool skip_time);
/** @brief Trace an u32 value /** @brief Trace an u32 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -182,7 +182,7 @@ void set_u16trace(const char* const tag, const uint16_t value, const bool skip_t
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_u32trace(const char* const tag, const uint32_t value, const bool skip_time); void st_u32trace(const char* const tag, const uint32_t value, const bool skip_time);
/** @brief Trace an s8 value /** @brief Trace an s8 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -190,7 +190,7 @@ void set_u32trace(const char* const tag, const uint32_t value, const bool skip_t
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_s8trace(const char* const tag, const int8_t value, const bool skip_time); void st_s8trace(const char* const tag, const int8_t value, const bool skip_time);
/** @brief Trace an s16 value /** @brief Trace an s16 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -198,7 +198,7 @@ void set_s8trace(const char* const tag, const int8_t value, const bool skip_time
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_s16trace(const char* const tag, const int16_t value, const bool skip_time); void st_s16trace(const char* const tag, const int16_t value, const bool skip_time);
/** @brief Trace an s32 value /** @brief Trace an s32 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -206,7 +206,7 @@ void set_s16trace(const char* const tag, const int16_t value, const bool skip_ti
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_s32trace(const char* const tag, const int32_t value, const bool skip_time); void st_s32trace(const char* const tag, const int32_t value, const bool skip_time);
/** @brief Trace an array of u8 values /** @brief Trace an array of u8 values
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -215,7 +215,7 @@ void set_s32trace(const char* const tag, const int32_t value, const bool skip_ti
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_au8trace(const char* const tag, const uint8_t value[const], const uint8_t size, const bool skip_time); void st_au8trace(const char* const tag, const uint8_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace an array of u16 values /** @brief Trace an array of u16 values
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -224,7 +224,7 @@ void set_au8trace(const char* const tag, const uint8_t value[const], const uint8
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_au16trace(const char* const tag, const uint16_t value[const], const uint8_t size, const bool skip_time); void st_au16trace(const char* const tag, const uint16_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace an array of u32 values /** @brief Trace an array of u32 values
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -233,7 +233,7 @@ void set_au16trace(const char* const tag, const uint16_t value[const], const uin
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_au32trace(const char* const tag, const uint32_t value[const], const uint8_t size, const bool skip_time); void st_au32trace(const char* const tag, const uint32_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace an array of s8 values /** @brief Trace an array of s8 values
@ -243,7 +243,7 @@ void set_au32trace(const char* const tag, const uint32_t value[const], const uin
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_as8trace(const char* const tag, const int8_t value[const], const uint8_t size, const bool skip_time); void st_as8trace(const char* const tag, const int8_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace an array of s16 values /** @brief Trace an array of s16 values
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -252,7 +252,7 @@ void set_as8trace(const char* const tag, const int8_t value[const], const uint8_
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_as16trace(const char* const tag, const int16_t value[const], const uint8_t size, const bool skip_time); void st_as16trace(const char* const tag, const int16_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace an array of s32 values /** @brief Trace an array of s32 values
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -261,7 +261,7 @@ void set_as16trace(const char* const tag, const int16_t value[const], const uint
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_as32trace(const char* const tag, const int32_t value[const], const uint8_t size, const bool skip_time); void st_as32trace(const char* const tag, const int32_t value[const], const uint8_t size, const bool skip_time);
/** @brief Trace a string /** @brief Trace a string
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -269,9 +269,9 @@ void set_as32trace(const char* const tag, const int32_t value[const], const uint
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_strtrace(const char* const tag, const char* const str, const bool skip_time); void st_strtrace(const char* const tag, const char* const str, const bool skip_time);
#if (!SET_FLOAT_DISABLE) #if (!ST_FLOAT_DISABLE)
/** @brief Trace an f32 value /** @brief Trace an f32 value
* @param[in] tag Signal name of the trace * @param[in] tag Signal name of the trace
@ -279,7 +279,7 @@ void set_strtrace(const char* const tag, const char* const str, const bool skip_
* @param[in] skip_time Use last recorded timestamp for this trace * @param[in] skip_time Use last recorded timestamp for this trace
* @return None * @return None
*/ */
void set_f32trace(const char* const tag, const float value, const bool skip_time); void st_f32trace(const char* const tag, const float value, const bool skip_time);
#endif #endif
#endif #endif

0
set_record.py → st_record.py
View File