Direct mode output

[hlvs-gnc]

After coming across the direct mode output option with Trice over RTT using a debug probe, was wondering if it would be possible to implement this feature without access to a device using protocols such as UART or USB, for example by routing the necessary data using another interface, and get the output to a console or virtual serial port

I've been looking for the OpenOCD Debugger in order to bypass any physical link, therefore taking advantage of all the Trice characteristics for an isolated application used for code development prior to an evaluation phase and hardware deployment

The main reason is to keep a sandbox-testing environment with the least amount of external interaction and as close to a pure-software domain

TLDR: objective - the goal is to explore the feasibility of implementing the Trice direct mode output option without the need for a physical device

Thank you and keep up the good work!

[rokath]

demo.c:

#include "trice.h"
int main( void ){
    trice( "msg:Hello World!\n");
    return 0;
}

Am I understand you right, that you want compile and run this on a PC as separate application, so that the trice tool grabs the binary data and displays "Hello World!"?

To get that:

• Create a C project on your PC
• Add the trice/src files to that project
• Add #define TRICE_DIRECT_AUXILIARY 1 to your triceConfig.h
• Copy file trice/src/triceAuxiliary.c as myAuxiliary.c in the new C project.
• Comment out all code inside file trice/src/triceAuxiliary.c.
• Add user code into file myAuxiliary.c
• You could let TriceNonBlockingDirectWriteAuxiliary() write into a file trices.raw and log with trice l -p FILE.
• Feel free to add the created C project into the trice/examples folder and make a pull request.

[hlvs-gnc]

Thank you! Will create a PR for the example

Keep up the good work (:

[rokath]

On Mon, 19 Feb 2024, 17:45 hlvs-gnc, <notifications@github.com> wrote:
I've successfully ported the auxiliary methods to be called, writing to the file in append mode, opening it and closing for each message

Defined the references:

#define TRICE_DIRECT_OUTPUT 1
#define TRICE_DIRECT_AUXILIARY 1

#define TRICE_DIRECT_OUT_FRAMING TRICE_FRAMING_COBS
#define TRICE_BUFFER TRICE_STACK_BUFFER
The following "trice l -p FILE -args trices.raw -idList til.json" does not show any output, although apparently the file is being written with new log data

The trice tool assumes TCOBS framing per default. When using COBS, you need to tell that via CLI. I am not sure what happens if you close and open the trice.raw file all the time. I would open it only once. When you have a trice.raw, the trice tool should be able to display it also alone. For that it maybe better to use -p FILEBUFFER.

[hlvs-gnc]

Alright, solved it, and now I'm only opening the file once

Got it to run in both cases (FILE and FILEBUFFER), using TCOBS encoding

Expect a PR in the next few days, will try to integrate it with the repo, inside "examples/" directory

[rokath]

That are good news! I am unsure how to deal with the file trice/src/triceAuxiliary.c in a clean way. Any idea?

[hlvs-gnc]

I've got a small function to deal with the file write in direct mode

Regarding the (auxiliary) deferred option, could make use of a local buffer array, for example, before flushing raw data to the file:

• define a threshold/ watermark on the number of bytes to be written
• adapt one of the available buffer structures
• use a timer with a periodic interval to control data transferences to file

[rokath]

In main branch file ./src/triceAuxiliary.c is now changed into:

#if TRICE_DIRECT_AUXILIARY == 1

//! UserNonBlockingDirectWriteAuxiliaryFn can get a user function address for writing to an auxiliary interface.
WriteAuxiliaryFn_t UserNonBlockingDirectWriteAuxiliaryFn = (void*)0;

//! TriceNonBlockingDirectWriteAuxiliary writes to a user defined interface.
void TriceNonBlockingDirectWriteAuxiliary( uint8_t const * enc, size_t encLen ){
    if( UserNonBlockingDirectWriteAuxiliaryFn != (void*)0 ){
        UserNonBlockingDirectWriteAuxiliaryFn( enc, encLen );
    }
}

#endif // #if TRICE_DIRECT_AUXILIARY == 1

#if TRICE_DEFERRED_AUXILIARY == 1

//! UserNonBlockingDeferredWriteAuxiliaryFn can get a user function address for writing to an auxiliary interface.
WriteAuxiliaryFn_t UserNonBlockingDeferredWriteAuxiliaryFn = (void*)0;

//! TriceNonBlockingDeferredWriteAuxiliary writes to a user defined interface.
void TriceNonBlockingDeferredWriteAuxiliary( uint8_t const * enc, size_t encLen ){
    if( UserNonBlockingDeferredWriteAuxiliaryFn != (void*)0 ){
        UserNonBlockingDeferredWriteAuxiliaryFn( enc, encLen );
    }
}

#endif // #if TRICE_DEFERRED_AUXILIARY == 1

This allows to add user code without editing the library code. It would be great, if you give it a try.

[rokath]

Should we close this now or do you want to make a pull request first?