[add] trice

EWARM/stm32_broad_mini.ewp

@@ -353,6 +353,8 @@
                     <state>$PROJ_DIR$/../Middlewares/rtthread/include</state>
                     <state>$PROJ_DIR$/../Middlewares/rtthread/include/libc</state>
                     <state>$PROJ_DIR$/../Middlewares/rtthread/finsh</state>
+                    <state>$PROJ_DIR$\..\Middlewares\trice\example</state>
+                    <state>$PROJ_DIR$\..\Middlewares\trice</state>
                 </option>
                 <option>
                     <name>CCStdIncCheck</name>
@@ -1091,6 +1093,9 @@
             </file>
             <file>
                 <name>$PROJ_DIR$\..\Middlewares\coredump\testbug.c</name>
+                <excluded>
+                    <configuration>stm32_broad_mini</configuration>
+                </excluded>
             </file>
         </group>
         <group>
@@ -1224,6 +1229,9 @@
         </group>
         <group>
             <name>RTT</name>
+            <excluded>
+                <configuration>stm32_broad_mini</configuration>
+            </excluded>
             <file>
                 <name>$PROJ_DIR$\..\Middlewares\segger_rtt\SEGGER_RTT.c</name>
             </file>
@@ -1297,5 +1305,74 @@
                 <name>$PROJ_DIR$\..\Middlewares\rtthread\src\timer.c</name>
             </file>
         </group>
+        <group>
+            <name>trice</name>
+            <group>
+                <name>example</name>
+                <file>
+                    <name>$PROJ_DIR$\..\Middlewares\trice\example\triceConfig.h</name>
+                </file>
+                <file>
+                    <name>$PROJ_DIR$\..\Middlewares\trice\example\triceExamples.c</name>
+                </file>
+                <file>
+                    <name>$PROJ_DIR$\..\Middlewares\trice\example\triceLogDiagData.c</name>
+                </file>
+                <file>
+                    <name>$PROJ_DIR$\..\Middlewares\trice\example\triceUart.h</name>
+                </file>
+            </group>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\cobsDecode.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\cobsEncode.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\SEGGER_RTT.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\tcobsv1Decode.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\tcobsv1Encode.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\trice.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\trice16.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\trice32.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\trice64.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\trice8.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceAuxiliary.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceDoubleBuffer.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceRingBuffer.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceStackBuffer.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceStaticBuffer.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\triceUart.c</name>
+            </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\trice\xtea.c</name>
+            </file>
+        </group>
     </group>
 </project>

Middlewares/rtthread/board.c

@@ -93,18 +93,86 @@ void SysInit(void)
     MX_USART1_UART_Init();
 }
 
+#if !TRICE_OFF
+// ms32 is a 32-bit millisecond counter, counting circular in steps of 1 every ms.
+uint32_t ms32 = 0;
+#endif
+
 int main(void)
 {
-    int i = 1;
-    int q = 58;
-    int d = i + q;
-    //rt_kprintf("%s\n", __func__);
-    test_softbreakpoint();
+#if !TRICE_OFF
+  TriceInit(); // This so early, to allow trice logs inside interrupts from the beginning. Only needed for RTT.
+  TriceHeadLine("  ????????????-F030R8    ");
+#endif
+    //int i = 1;
+    //int q = 58;
+    //int d = i + q;
+    rt_kprintf("%s\n", __func__);
+    //test_softbreakpoint();
+    
+#if !TRICE_OFF
+  SysTick->CTRL |= SysTick_CTRL_TICKINT_Msk; // enable SysTick interrupt
+  LogTriceConfiguration();
+  SomeExampleTrices(3);
+#endif
+  /* USER CODE END 2 */
+
+  /* Infinite loop */
+  /* USER CODE BEGIN WHILE */
+  while (1)
+  {
+#if !TRICE_OFF
+        static uint32_t lastMs = 0;
+        if( lastMs != ms32 ){ // each ms
+            lastMs = ms32;
+
+#if TRICE_DIAGNOSTICS == 1
+            static uint32_t msDiag = 0;
+            msDiag++;
+            if(msDiag >= 3000 ){
+                msDiag = 0;
+                TriceLogDiagnosticData();
+            }
+#endif
+            static uint32_t msCheck = 0;
+            msCheck++;
+            if(msCheck >= 1000 ){
+                msCheck = 0; 
+                SomeExampleTrices(5);
+            }
+
+            #if (TRICE_BUFFER == TRICE_RING_BUFFER) || (TRICE_BUFFER == TRICE_DOUBLE_BUFFER)
+
+                static uint32_t msTransfer = 0;
+                msTransfer++;
+                if(msTransfer >= 100 ){
+                    msTransfer = 0;
+                    // Serve deferred trice transfer every few ms or if TRICE_BUFFER is getting filled. With an RTOS put this in a separate task.
+                    // In TRICE_RING_BUFFER && TRICE_SINGLE_PACK_MODE TriceTransfer can transmit only 1 Trice per call, so call it every 1ms then.
+                    // In TRICE_DOUBLE_BUFFER TriceTransfer transmits one half buffer.
+                    TriceTransfer(); // serve deferred output
+                }
+                #if TRICE_RING_BUFFER_OVERFLOW_WATCH == 1
+                    WatchRingBufferMargins();
+                #endif
+
+            #endif // #if ( TRICE_BUFFER == TRICE_RING_BUFFER) || ( TRICE_BUFFER == TRICE_DOUBLE_BUFFER)
+        }
+        
+
+    /* USER CODE END WHILE */
+
+    /* USER CODE BEGIN 3 */
+#endif // #if !TRICE_OFF
+  }
     return 0;
 }
 
 void SysTick_Handler(void)
 {
+#if !TRICE_OFF
+    ms32++;
+#endif
     /* enter interrupt */
     rt_interrupt_enter();
 

Middlewares/trice/ReadMe.md

@@ -0,0 +1,76 @@
+# Target Setup
+
+* See ./doc/TriceUserGuide.md -> [Embedded system code setup](https://github.com/rokath/trice/blob/master/docs/TriceUserGuide.md#24-port-it)
+
+## Issue Tracking
+
+### L432 FreeRTOS, `TRICE_RING_BUFFER` with RTT but without reading RTT @115200
+
+```bash
+Jul  9 10:24:58.607462  com3:          triceCheck.c   167
+COBS: 08 98 cb 32 32 32 32 3b 01 00 
+COBS:          32 32 32 32 5b 01 00 
+inconsistent COBS buffer!
+
+Jul  9 10:24:57.006345  com3:          triceCheck.c  1534  842,150_450 1b43 triceSingleDepthMax = 168 of 168 (TRICE_BUFFER_SIZE)
+COBS: 07 41 5a 31 04 98 07 01 01 00 
+COBS:       5a 6c 04 d3 31 01 01 00 
+inconsistent COBS buffer!
+
+Jul  9 11:00:54.395380  com3:          triceCheck.c   280  842,150_450 1afd TRICE32_2 line 280,2
+COBS: 0b 59 cd 32 32 32 32 3c 10 19 01 01 01 01 01 01 02 02 01 01 01 01 01 01 01 00 
+COBS:    59 cd 32 32 32 32 f7 10 19 01 01 01 01 01 01 02 02 01 01 01 01 01 01 01 00 
+inconsistent COBS buffer!
+
+Jul  9 11:02:03.653064  com3:          triceCheck.c  1515              0f89 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJK
+COBS: 35 89 4f 09 30 30 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77 78 79 7a 41 42 43 44 45 46 47 48 49 4a 4b 4c 00 
+COBS:       4f c4 30 30 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77 78 79 7a 41 42 43 44 45 46 47 48 49 4a 4b 4c 00 
+inconsistent COBS buffer!
+
+Jul  9 11:03:33.892756  com3:          triceCheck.c   182  842,150_450 04ce TRICE64 int -518, double -518.054749 (%f), c080307020601050, 1100000010000000001100000111000000100000011000000001000001010000
+COBS: 29 8b d6 32 32 32 32 65 20 b0 ef 9f df 8f cf 7f bf 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 00 
+COBS: 29 8b d6 32 32 32 32 1f 20 b0 ef 9f df 8f cf 7f bf 50 10 60                            70 30 80 c0 50 10 60 20 70 30 80 c0 00 
+inconsistent COBS buffer!
+
+Jul  9 11:21:09.519959  com3:          triceCheck.c   298  842,150_450 1c8d Runtime generated strings
+COBS: 0a 15 c8 32 32 32 32 6f 04 0c 01 01 01 00 
+COBS:                         04       01 01 00 
+inconsistent COBS buffer!
+
+Jul  9 11:22:30.968562  com3:          triceCheck.c   266  842,150_450 1e71 TRICE STOP time message
+COBS: 08 83 c7 32 32 32 32 88 01 00 
+COBS:       c7 32 32 32 32 43 01 00 
+inconsistent COBS buffer!
+
+Jul  9 11:23:43.414792  com3:          triceCheck.c   137  842,150_450 1620 12 16-bit values -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12 and a 32-bit stamp.
+COBS: 1f b8 8a 16 16 b6 18 ff ff fe ff fd ff fc ff fb ff fa ff f9 ff f8 ff f7 ff f6 ff f5 ff f4 ff 00 
+COBS:             16 71 18 ff ff fe ff fd ff fc ff fb ff fa ff f9 ff f8 ff f7 ff f6 ff f5 ff f4 ff 00 
+inconsistent COBS buffer!
+```
+
+### L432 FreeRTOS, `TRICE_RING_BUFFER` without RTT @115200
+
+```bash
+Jul  9 11:57:15.313061  com3:          triceCheck.c   167              1544 value=88
+COBS: 08 98 cb 32 32 32 32 98 01 00
+COBS:                32 32 2e 01 00 
+inconsistent COBS buffer!
+
+Jul  9 12:00:44.139512  com3:          triceCheck.c   277  842,150_450 0f9e TRICE64 1, 2
+COBS: 0b db d1 32 32 32 32 b5 04 16 01 01 01 00
+COBS:          32 32 32 32 6b 04 16 01 01 01 00 
+inconsistent COBS buffer!
+
+
+Jul  9 12:05:16.403643  com3:          triceCheck.c   181  842,150_450 1670 TRICE64 int -518, double -518.054749 (%f), c080307020601050, 1100000010000000001100000111000000100000011000000001000001010000
+COBS: 29 ce c4 32 32 32 32 a2 20 fa fd ff ff ff ff ff ff 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 00 
+COBS:                      5b 20 fa fd ff ff ff ff ff ff 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 50 10 60 20 70 30 80 c0 00 
+inconsistent COBS buffer!
+
+
+Jul  9 12:06:41.752570  com3:          triceCheck.c   188  842,150_450 0574 With TRICE_S:abcde 12345
+COBS: 14 7a d4 32 32 32 32 c9 0b 61 62 63 64 65 20 31 32 33 34 35 00
+COBS: 14 7a d4 32 32 32 32 7f 0b 61 62 63 64 65 20 31       
+inconsistent COBS buffer!
+```
+

Middlewares/trice/SEGGER_RTT.h

@@ -0,0 +1,520 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2021 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       RTT version: 8.12a                                           *
+*                                                                    *
+**********************************************************************
+
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT.h
+Purpose : Implementation of SEGGER real-time transfer which allows
+          real-time communication on targets which support debugger
+          memory accesses while the CPU is running.
+Revision: $Rev: 25842 $
+----------------------------------------------------------------------
+*/
+
+#ifndef SEGGER_RTT_H
+#define SEGGER_RTT_H
+
+#include "SEGGER_RTT_Conf.h"
+
+/*********************************************************************
+*
+*       Defines, defaults
+*
+**********************************************************************
+*/
+
+#ifndef RTT_USE_ASM
+  //
+  // Some cores support out-of-order memory accesses (reordering of memory accesses in the core)
+  // For such cores, we need to define a memory barrier to guarantee the order of certain accesses to the RTT ring buffers.
+  // Needed for:
+  //   Cortex-M7 (ARMv7-M)
+  //   Cortex-M23 (ARM-v8M)
+  //   Cortex-M33 (ARM-v8M)
+  //   Cortex-A/R (ARM-v7A/R)
+  //
+  // We do not explicitly check for "Embedded Studio" as the compiler in use determines what we support.
+  // You can use an external toolchain like IAR inside ES. So there is no point in checking for "Embedded Studio"
+  //
+  #if (defined __CROSSWORKS_ARM)                  // Rowley Crossworks
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+    #if (defined __ARM_ARCH_7M__)                 // Cortex-M3
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+    #elif (defined __ARM_ARCH_7EM__)              // Cortex-M4/M7
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_BASE__)          // Cortex-M23
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_MAIN__)          // Cortex-M33
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined(__ARM_ARCH_8_1M_MAIN__))       // Cortex-M85
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #else
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+    #endif
+  #elif (defined __ARMCC_VERSION)
+    //
+    // ARM compiler
+    // ARM compiler V6.0 and later is clang based.
+    // Our ASM part is compatible to clang.
+    //
+    #if (__ARMCC_VERSION >= 6000000)
+      #define _CC_HAS_RTT_ASM_SUPPORT 1
+    #else
+      #define _CC_HAS_RTT_ASM_SUPPORT 0
+    #endif
+    #if (defined __ARM_ARCH_6M__)                 // Cortex-M0 / M1
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0         // No ASM support for this architecture
+    #elif (defined __ARM_ARCH_7M__)               // Cortex-M3
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+    #elif (defined __ARM_ARCH_7EM__)              // Cortex-M4/M7
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_BASE__)          // Cortex-M23
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_MAIN__)          // Cortex-M33
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8_1M_MAIN__)        // Cortex-M85
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif \
+    ((defined __ARM_ARCH_7A__) || (defined __ARM_ARCH_7R__)) || \   // Cortex-A/R ARMv7-A/R & ARMv8-A/R
+    ((defined __ARM_ARCH_8A__) || (defined __ARM_ARCH_8R__))
+      //
+      // Cortex-A/R ARMv7-A/R & ARMv8-A/R
+      //
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #else
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+    #endif
+  #elif ((defined __GNUC__) || (defined __clang__))
+    //
+    // GCC / Clang
+    //
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+    // ARM 7/9: __ARM_ARCH_5__ / __ARM_ARCH_5E__ / __ARM_ARCH_5T__ / __ARM_ARCH_5T__ / __ARM_ARCH_5TE__
+    #if (defined __ARM_ARCH_7M__)                 // Cortex-M3
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+    #elif (defined __ARM_ARCH_7EM__)              // Cortex-M4/M7
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1         // Only Cortex-M7 needs a DMB but we cannot distinguish M4 and M7 here...
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_BASE__)          // Cortex-M23
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8M_MAIN__)          // Cortex-M33
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif (defined __ARM_ARCH_8_1M_MAIN__)        // Cortex-M85
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #elif \
+    (defined __ARM_ARCH_7A__) || (defined __ARM_ARCH_7R__) || \
+    (defined __ARM_ARCH_8A__) || (defined __ARM_ARCH_8R__)
+      //
+      // Cortex-A/R ARMv7-A/R & ARMv8-A/R
+      //
+      #define _CORE_NEEDS_DMB           1
+      #define RTT__DMB() __asm volatile ("dmb\n" : : :);
+    #else
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+    #endif
+  #elif ((defined __IASMARM__) || (defined __ICCARM__))
+    //
+    // IAR assembler/compiler
+    //
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+    #if (__VER__ < 6300000)
+      #define VOLATILE
+    #else
+      #define VOLATILE volatile
+    #endif
+    #if (defined __ARM7M__)                            // Needed for old versions that do not know the define yet
+      #if (__CORE__ == __ARM7M__)                      // Cortex-M3
+        #define _CORE_HAS_RTT_ASM_SUPPORT 1
+      #endif
+    #endif
+    #if (defined __ARM7EM__)
+      #if (__CORE__ == __ARM7EM__)                     // Cortex-M4/M7
+        #define _CORE_HAS_RTT_ASM_SUPPORT 1
+        #define _CORE_NEEDS_DMB 1
+        #define RTT__DMB() asm VOLATILE ("DMB");
+      #endif
+    #endif
+    #if (defined __ARM8M_BASELINE__)
+      #if (__CORE__ == __ARM8M_BASELINE__)             // Cortex-M23
+        #define _CORE_HAS_RTT_ASM_SUPPORT 0
+        #define _CORE_NEEDS_DMB 1
+        #define RTT__DMB() asm VOLATILE ("DMB");
+      #endif
+    #endif
+    #if (defined __ARM8M_MAINLINE__)
+      #if (__CORE__ == __ARM8M_MAINLINE__)             // Cortex-M33
+        #define _CORE_HAS_RTT_ASM_SUPPORT 1
+        #define _CORE_NEEDS_DMB 1
+        #define RTT__DMB() asm VOLATILE ("DMB");
+      #endif
+    #endif
+    #if (defined __ARM8EM_MAINLINE__)
+      #if (__CORE__ == __ARM8EM_MAINLINE__)            // Cortex-???
+        #define _CORE_HAS_RTT_ASM_SUPPORT 1
+        #define _CORE_NEEDS_DMB 1
+        #define RTT__DMB() asm VOLATILE ("DMB");
+      #endif
+    #endif
+    #if\
+    ((defined __ARM7A__) && (__CORE__ == __ARM7A__)) || \
+    ((defined __ARM7R__) && (__CORE__ == __ARM7R__)) || \
+    ((defined __ARM8A__) && (__CORE__ == __ARM8A__)) || \
+    ((defined __ARM8R__) && (__CORE__ == __ARM8R__))
+      //
+      // Cortex-A/R ARMv7-A/R & ARMv8-A/R
+      //
+       #define _CORE_NEEDS_DMB 1
+      #define RTT__DMB() asm VOLATILE ("DMB");
+    #endif
+  #else
+    //
+    // Other compilers
+    //
+    #define _CC_HAS_RTT_ASM_SUPPORT   0
+    #define _CORE_HAS_RTT_ASM_SUPPORT 0
+  #endif
+  //
+  // If IDE and core support the ASM version, enable ASM version by default
+  //
+  #ifndef _CORE_HAS_RTT_ASM_SUPPORT
+    #define _CORE_HAS_RTT_ASM_SUPPORT 0              // Default for unknown cores
+  #endif
+  #if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT)
+    #define RTT_USE_ASM                           (1)
+  #else
+    #define RTT_USE_ASM                           (0)
+  #endif
+#endif
+
+#ifndef _CORE_NEEDS_DMB
+  #define _CORE_NEEDS_DMB 0
+#endif
+
+#ifndef RTT__DMB
+  #if _CORE_NEEDS_DMB
+    #error "Don't know how to place inline assembly for DMB"
+  #else
+    #define RTT__DMB()
+  #endif
+#endif
+
+#ifndef SEGGER_RTT_CPU_CACHE_LINE_SIZE
+  #define SEGGER_RTT_CPU_CACHE_LINE_SIZE (0)   // On most target systems where RTT is used, we do not have a CPU cache, therefore 0 is a good default here
+#endif
+
+#ifndef SEGGER_RTT_UNCACHED_OFF
+  #if SEGGER_RTT_CPU_CACHE_LINE_SIZE
+    #error "SEGGER_RTT_UNCACHED_OFF must be defined when setting SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+  #else
+    #define SEGGER_RTT_UNCACHED_OFF (0)
+  #endif
+#endif
+#if RTT_USE_ASM
+  #if SEGGER_RTT_CPU_CACHE_LINE_SIZE
+    #error "RTT_USE_ASM is not available if SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0"
+  #endif
+#endif
+
+#ifndef SEGGER_RTT_ASM  // defined when SEGGER_RTT.h is included from assembly file
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+
+//
+// Determine how much we must pad the control block to make it a multiple of a cache line in size
+// Assuming: U8 = 1B
+//           U16 = 2B
+//           U32 = 4B
+//           U8/U16/U32* = 4B
+//
+#if SEGGER_RTT_CPU_CACHE_LINE_SIZE    // Avoid division by zero in case we do not have any cache
+  #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (((NumBytes + SEGGER_RTT_CPU_CACHE_LINE_SIZE - 1) / SEGGER_RTT_CPU_CACHE_LINE_SIZE) * SEGGER_RTT_CPU_CACHE_LINE_SIZE)
+#else
+  #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes)
+#endif
+#define SEGGER_RTT__CB_SIZE                              (16 + 4 + 4 + (SEGGER_RTT_MAX_NUM_UP_BUFFERS * 24) + (SEGGER_RTT_MAX_NUM_DOWN_BUFFERS * 24))
+#define SEGGER_RTT__CB_PADDING                           (SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(SEGGER_RTT__CB_SIZE) - SEGGER_RTT__CB_SIZE)
+
+/*********************************************************************
+*
+*       Types
+*
+**********************************************************************
+*/
+
+//
+// Description for a circular buffer (also called "ring buffer")
+// which is used as up-buffer (T->H)
+//
+typedef struct {
+  const     char*    sName;         // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+            char*    pBuffer;       // Pointer to start of buffer
+            unsigned SizeOfBuffer;  // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+            unsigned WrOff;         // Position of next item to be written by either target.
+  volatile  unsigned RdOff;         // Position of next item to be read by host. Must be volatile since it may be modified by host.
+            unsigned Flags;         // Contains configuration flags. Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode.
+} SEGGER_RTT_BUFFER_UP;
+
+//
+// Description for a circular buffer (also called "ring buffer")
+// which is used as down-buffer (H->T)
+//
+typedef struct {
+  const     char*    sName;         // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+            char*    pBuffer;       // Pointer to start of buffer
+            unsigned SizeOfBuffer;  // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+  volatile  unsigned WrOff;         // Position of next item to be written by host. Must be volatile since it may be modified by host.
+            unsigned RdOff;         // Position of next item to be read by target (down-buffer).
+            unsigned Flags;         // Contains configuration flags. Flags[31:24] are used for validity check and must be zero. Flags[23:2] are reserved for future use. Flags[1:0] = RTT operating mode.
+} SEGGER_RTT_BUFFER_DOWN;
+
+//
+// RTT control block which describes the number of buffers available
+// as well as the configuration for each buffer
+//
+//
+typedef struct {
+  char                    acID[16];                                 // Initialized to "SEGGER RTT"
+  int                     MaxNumUpBuffers;                          // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2)
+  int                     MaxNumDownBuffers;                        // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2)
+  SEGGER_RTT_BUFFER_UP    aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS];       // Up buffers, transferring information up from target via debug probe to host
+  SEGGER_RTT_BUFFER_DOWN  aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS];   // Down buffers, transferring information down from host via debug probe to target
+#if SEGGER_RTT__CB_PADDING
+  unsigned char           aDummy[SEGGER_RTT__CB_PADDING];
+#endif
+} SEGGER_RTT_CB;
+
+/*********************************************************************
+*
+*       Global data
+*
+**********************************************************************
+*/
+extern SEGGER_RTT_CB _SEGGER_RTT;
+
+/*********************************************************************
+*
+*       RTT API functions
+*
+**********************************************************************
+*/
+#ifdef __cplusplus
+  extern "C" {
+#endif
+int          SEGGER_RTT_AllocDownBuffer         (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_AllocUpBuffer           (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_ConfigUpBuffer          (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_ConfigDownBuffer        (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_GetKey                  (void);
+unsigned     SEGGER_RTT_HasData                 (unsigned BufferIndex);
+int          SEGGER_RTT_HasKey                  (void);
+unsigned     SEGGER_RTT_HasDataUp               (unsigned BufferIndex);
+void         SEGGER_RTT_Init                    (void);
+unsigned     SEGGER_RTT_Read                    (unsigned BufferIndex,       void* pBuffer, unsigned BufferSize);
+unsigned     SEGGER_RTT_ReadNoLock              (unsigned BufferIndex,       void* pData,   unsigned BufferSize);
+int          SEGGER_RTT_SetNameDownBuffer       (unsigned BufferIndex, const char* sName);
+int          SEGGER_RTT_SetNameUpBuffer         (unsigned BufferIndex, const char* sName);
+int          SEGGER_RTT_SetFlagsDownBuffer      (unsigned BufferIndex, unsigned Flags);
+int          SEGGER_RTT_SetFlagsUpBuffer        (unsigned BufferIndex, unsigned Flags);
+int          SEGGER_RTT_WaitKey                 (void);
+unsigned     SEGGER_RTT_Write                   (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteNoLock             (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteSkipNoLock         (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_ASM_WriteSkipNoLock     (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteString             (unsigned BufferIndex, const char* s);
+void         SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_PutChar                 (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_PutCharSkip             (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_PutCharSkipNoLock       (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_GetAvailWriteSpace      (unsigned BufferIndex);
+unsigned     SEGGER_RTT_GetBytesInBuffer        (unsigned BufferIndex);
+//
+// Function macro for performance optimization
+//
+#define      SEGGER_RTT_HASDATA(n)       (((SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_DOWN*)((uintptr_t)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff)
+
+#if RTT_USE_ASM
+  #define SEGGER_RTT_WriteSkipNoLock  SEGGER_RTT_ASM_WriteSkipNoLock
+#endif
+
+/*********************************************************************
+*
+*       RTT transfer functions to send RTT data via other channels.
+*
+**********************************************************************
+*/
+unsigned     SEGGER_RTT_ReadUpBuffer            (unsigned BufferIndex, void* pBuffer, unsigned BufferSize);
+unsigned     SEGGER_RTT_ReadUpBufferNoLock      (unsigned BufferIndex, void* pData, unsigned BufferSize);
+unsigned     SEGGER_RTT_WriteDownBuffer         (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteDownBufferNoLock   (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+
+#define      SEGGER_RTT_HASDATA_UP(n)    (((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((uintptr_t)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff)   // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
+
+/*********************************************************************
+*
+*       RTT "Terminal" API functions
+*
+**********************************************************************
+*/
+int     SEGGER_RTT_SetTerminal        (unsigned char TerminalId);
+int     SEGGER_RTT_TerminalOut        (unsigned char TerminalId, const char* s);
+
+/*********************************************************************
+*
+*       RTT printf functions (require SEGGER_RTT_printf.c)
+*
+**********************************************************************
+*/
+int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...);
+int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif // ifndef(SEGGER_RTT_ASM)
+
+//
+// For some environments, NULL may not be defined until certain headers are included
+//
+#ifndef NULL
+  #define NULL  ((void*)0)
+#endif
+
+/*********************************************************************
+*
+*       Defines
+*
+**********************************************************************
+*/
+
+//
+// Operating modes. Define behavior if buffer is full (not enough space for entire message)
+//
+#define SEGGER_RTT_MODE_NO_BLOCK_SKIP         (0)     // Skip. Do not block, output nothing. (Default)
+#define SEGGER_RTT_MODE_NO_BLOCK_TRIM         (1)     // Trim: Do not block, output as much as fits.
+#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL    (2)     // Block: Wait until there is space in the buffer.
+#define SEGGER_RTT_MODE_MASK                  (3)
+
+//
+// Control sequences, based on ANSI.
+// Can be used to control color, and clear the screen
+//
+#define RTT_CTRL_RESET                "\x1B[0m"         // Reset to default colors
+#define RTT_CTRL_CLEAR                "\x1B[2J"         // Clear screen, reposition cursor to top left
+
+#define RTT_CTRL_TEXT_BLACK           "\x1B[2;30m"
+#define RTT_CTRL_TEXT_RED             "\x1B[2;31m"
+#define RTT_CTRL_TEXT_GREEN           "\x1B[2;32m"
+#define RTT_CTRL_TEXT_YELLOW          "\x1B[2;33m"
+#define RTT_CTRL_TEXT_BLUE            "\x1B[2;34m"
+#define RTT_CTRL_TEXT_MAGENTA         "\x1B[2;35m"
+#define RTT_CTRL_TEXT_CYAN            "\x1B[2;36m"
+#define RTT_CTRL_TEXT_WHITE           "\x1B[2;37m"
+
+#define RTT_CTRL_TEXT_BRIGHT_BLACK    "\x1B[1;30m"
+#define RTT_CTRL_TEXT_BRIGHT_RED      "\x1B[1;31m"
+#define RTT_CTRL_TEXT_BRIGHT_GREEN    "\x1B[1;32m"
+#define RTT_CTRL_TEXT_BRIGHT_YELLOW   "\x1B[1;33m"
+#define RTT_CTRL_TEXT_BRIGHT_BLUE     "\x1B[1;34m"
+#define RTT_CTRL_TEXT_BRIGHT_MAGENTA  "\x1B[1;35m"
+#define RTT_CTRL_TEXT_BRIGHT_CYAN     "\x1B[1;36m"
+#define RTT_CTRL_TEXT_BRIGHT_WHITE    "\x1B[1;37m"
+
+#define RTT_CTRL_BG_BLACK             "\x1B[24;40m"
+#define RTT_CTRL_BG_RED               "\x1B[24;41m"
+#define RTT_CTRL_BG_GREEN             "\x1B[24;42m"
+#define RTT_CTRL_BG_YELLOW            "\x1B[24;43m"
+#define RTT_CTRL_BG_BLUE              "\x1B[24;44m"
+#define RTT_CTRL_BG_MAGENTA           "\x1B[24;45m"
+#define RTT_CTRL_BG_CYAN              "\x1B[24;46m"
+#define RTT_CTRL_BG_WHITE             "\x1B[24;47m"
+
+#define RTT_CTRL_BG_BRIGHT_BLACK      "\x1B[4;40m"
+#define RTT_CTRL_BG_BRIGHT_RED        "\x1B[4;41m"
+#define RTT_CTRL_BG_BRIGHT_GREEN      "\x1B[4;42m"
+#define RTT_CTRL_BG_BRIGHT_YELLOW     "\x1B[4;43m"
+#define RTT_CTRL_BG_BRIGHT_BLUE       "\x1B[4;44m"
+#define RTT_CTRL_BG_BRIGHT_MAGENTA    "\x1B[4;45m"
+#define RTT_CTRL_BG_BRIGHT_CYAN       "\x1B[4;46m"
+#define RTT_CTRL_BG_BRIGHT_WHITE      "\x1B[4;47m"
+
+
+#endif
+
+/*************************** End of file ****************************/

Middlewares/trice/cobs.h

@@ -0,0 +1,24 @@
+//! \file cobs.h
+//! \author Thomas.Hoehenleitner [at] seerose.net
+
+#ifndef COBS_H_
+#define COBS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h> //lint !e537 !e451  Warning 537: Repeated include file,  Warning 451: Header file repeatedly included but does not have a standard
+#include <stdint.h> //lint !e537 !e451  Warning 537: Repeated include file,  Warning 451: Header file repeatedly included but does not have a standard
+
+//! If your compiler uses a pre-C99 C dialect and does not know The "__restrict" keyword, you can define it in the project settings.
+size_t COBSEncode(void* __restrict out, const void* __restrict in, size_t length);
+
+//! If your compiler uses a pre-C99 C dialect and does not know The "__restrict" keyword, you can define it in the project settings.
+size_t COBSDecode(void* __restrict out, const void* __restrict in, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Middlewares/trice/cobsDecode.c

@@ -0,0 +1,32 @@
+//! \file cobsDecode.c copied from https://github.com/rokath/cobs
+//! \author Thomas.Hoehenleitner [at] seerose.net
+
+#include "cobs.h"
+
+//! COBSDecode decodes data from in buffer.
+//! @param in Pointer to encoded input bytes.
+//! @param length Number of bytes to decode.
+//! @param out Pointer to decoded output data.
+//! @return Number of bytes successfully decoded.
+//! @note Stops decoding if delimiter byte is found. Code taken from Wikipedia and slightly modified.
+size_t COBSDecode(void* __restrict out, const void* __restrict in, size_t length) {
+	uint8_t* data = out;
+	const uint8_t* buffer = in;
+	const uint8_t* byte = buffer;     // Encoded input byte pointer
+	uint8_t* decode = (uint8_t*)data; // Decoded output byte pointer
+
+	for (uint8_t code = 0xff, block = 0; byte < buffer + length; --block) {
+		if (block) { // Decode block byte
+			*decode++ = *byte++;
+		} else {
+			if (code != 0xff) { // Encoded zero, write it
+				*decode++ = 0;
+			}
+			block = code = *byte++; // Next block length
+			if (!code) {            // Delimiter code found
+				break;
+			}
+		}
+	}
+	return (size_t)(decode - data);
+}

Middlewares/trice/cobsEncode.c

@@ -0,0 +1,31 @@
+//! \file cobsEncode.c copied from https://github.com/rokath/cobs
+//! \author Thomas.Hoehenleitner [at] seerose.net
+
+#include "cobs.h"
+
+//! COBSEncode encodes data to output.
+//! @param in Pointer to input data to encode.
+//! @param length Number of bytes to encode.
+//! @param out Pointer to encoded output buffer.
+//! @return Encoded buffer length in bytes.
+//! @note Does not output delimiter byte. Code taken from Wikipedia and slightly adapted.
+size_t COBSEncode(void* __restrict out, const void* __restrict in, size_t length) {
+	uint8_t* buffer = out;
+	uint8_t* encode = buffer;  // Encoded byte pointer
+	uint8_t* codep = encode++; // Output code pointer
+	uint8_t code = 1;          // Code value
+
+	for (const uint8_t* byte = (const uint8_t*)in; length--; ++byte) {
+		if (*byte) { // Byte not zero, write it
+			*encode++ = *byte, ++code;
+		}
+		if (!*byte || code == 0xff) { // Input is zero or block completed, restart
+			*codep = code, code = 1, codep = encode;
+			if (!*byte || length) {
+				++encode;
+			}
+		}
+	}
+	*codep = code; // Write final code value
+	return (size_t)(encode - buffer);
+}

Middlewares/trice/example/ReadMe.md

@@ -0,0 +1,3 @@
+# <div id="top">Folder info
+
+The `*.c` files here are used by some example projects.

Middlewares/trice/example/triceConfig.h

@@ -0,0 +1,53 @@
+/*!
+ *  \file triceConfig.h
+   \author Thomas.Hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+#ifndef TRICE_CONFIG_H_
+#define TRICE_CONFIG_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+//! TRICE_CLEAN, if found inside triceConfig.h, is modified by the Trice tool to silent editor warnings in the cleaned state.
+#define TRICE_CLEAN 0 // Do not define this at an other place! But you can delete this here.
+
+extern uint32_t ms32; //! ms32 is a 32-bit millisecond counter, counting circular in steps of 1 every ms.
+#include "stm32f1xx_hal.h"
+#define TriceStamp16 (SysTick->VAL) // Counts from 31999 -> 0 in each ms.
+#define TriceStamp32 ms32           // 1ms, wraps after 2^32 ms ~= 49,7 days
+
+#define TRICE_BUFFER TRICE_DOUBLE_BUFFER
+#define TRICE_DEFERRED_BUFFER_SIZE 2048
+
+// Windows: trice log -p jlink -args "-Device STM32F030R8" -pf none -prefix off -hs off -d16 -showID "deb:%5d" -i ../../demoTIL.json -li ../../demoLI.json
+// Unix:   ./RTTLogUnix.sh or manually:
+//      Terminal 1: rm ./temp/trice.bin && JLinkRTTLogger -Device STM32G0B1RE -If SWD -Speed 4000 -RTTChannel 0 ./temp/trice.bin
+//      Terminal 2: touch ./temp/trice.bin && trice log -p FILE -args ./temp/trice.bin -pf none -prefix off -hs off -d16 -ts16 time:tick #%6d -i ../../demoTIL.json -li ../../demoLI.json
+#define TRICE_DIRECT_OUTPUT 1
+#define TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE 1
+
+// Windows: trice log -p com4         -ts16 "time:tick #%6d" -i ../../demoTIL.json -li ../../demoLI.json
+// Unix:    trice log -p /dev/ttyACM0 -ts16 "time:tick #%6d" -i ../../demoTIL.json -li ../../demoLI.json
+#define TRICE_DEFERRED_OUTPUT 1
+#define TRICE_DEFERRED_UARTA 1
+#define TRICE_UARTA USART1
+
+#define TRICE_MCU_IS_BIG_ENDIAN 0
+
+//#include "cmsis_gcc.h"
+#define TRICE_ENTER_CRITICAL_SECTION { uint32_t primaskstate = __get_PRIMASK(); __disable_irq(); {
+#define TRICE_LEAVE_CRITICAL_SECTION } __set_PRIMASK(primaskstate); }
+
+void TriceHeadLine(char *name);
+void LogTriceConfiguration(void);
+void SomeExampleTrices(int burstCount);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TRICE_CONFIG_H_ */

Middlewares/trice/example/triceExamples.c

@@ -0,0 +1,93 @@
+/*!
+ *  \file triceExamples.c
+   \author Thomas.Hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+#include "trice.h"
+
+#if !TRICE_OFF
+
+//! TriceHeadLine emits a decorated name. The name length should be 18 characters.
+void TriceHeadLine(char *name)
+{
+    //! This is usable as the very first trice sequence after restart. Adapt it. Use a UTF-8 capable editor like VS-Code or use pure ASCII.
+    //TriceS("w: Hello! 👋🙂\n\n        ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨        \n        🎈🎈🎈🎈%s🎈🎈🎈🎈\n        🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃🍃        \n\n\n", name);
+}
+
+//! SomeExampleTrices generates a few Trice example logs and a burst of Trices.
+void SomeExampleTrices(int burstCount)
+{
+    // TRICE32_0(ID(0), "att:🐁 Speedy Gonzales A  32-bit time stamp\n");
+    // TRICE32_0(ID(0), "att:🐁 Speedy Gonzales B  32-bit time stamp\n");
+    // TRICE32_0(ID(0), "att:🐁 Speedy Gonzales C  32-bit time stamp\n");
+    // TRICE32_0(ID(0), "att:🐁 Speedy Gonzales D  32-bit time stamp\n");
+    // TRICE32_0(Id(0), "att:🐁 Speedy Gonzales E  16-bit time stamp\n");
+    // TRICE32_0(Id(0), "att:🐁 Speedy Gonzales F  16-bit time stamp\n");
+    // TRICE32_0(Id(0), "att:🐁 Speedy Gonzales G  16-bit time stamp\n");
+    // TRICE32_0(Id(0), "att:🐁 Speedy Gonzales H  16-bit time stamp\n");
+    // TRICE32_0(id(0), "att:🐁 Speedy Gonzales I without time stamp\n");
+    // TRICE32_0(id(0), "att:🐁 Speedy Gonzales J without time stamp\n");
+    // TRICE32_0(id(0), "att:🐁 Speedy Gonzales K without time stamp\n");
+    // TRICE32_0(id(0), "att:🐁 Speedy Gonzales L without time stamp\n");
+  
+    TRICE32_0(id(0), "att:🐁 Speedy Gonzales L without time stamp\n");
+#if 0
+    TRice("att:🐁 Speedy Gonzales a  32-bit time stamp\n");
+    TRice("att:🐁 Speedy Gonzales b  32-bit time stamp\n");
+    TRice("att:🐁 Speedy Gonzales c  32-bit time stamp\n");
+    TRice("att:🐁 Speedy Gonzales d  32-bit time stamp\n");
+    Trice("att:🐁 Speedy Gonzales e  16-bit time stamp\n");
+    Trice("att:🐁 Speedy Gonzales f  16-bit time stamp\n");
+    Trice("att:🐁 Speedy Gonzales g  16-bit time stamp\n");
+    Trice("att:🐁 Speedy Gonzales h  16-bit time stamp\n");
+    // trice("att:🐁 Speedy Gonzales i without time stamp\n");
+    // trice("att:🐁 Speedy Gonzales j without time stamp\n");
+    // trice("att:🐁 Speedy Gonzales k without time stamp\n");
+    // trice("att:🐁 Speedy Gonzales l without time stamp\n");
+    char *aString = "2.71828182845904523536";
+    TriceS("rd:%s <- float number as string\n", aString);
+    Trice64("msg:%.20f (double with more ciphers than precision)\n", aDouble(2.71828182845904523536));
+    Trice("msg:%.20f (float  with more ciphers than precision)\n", aFloat(2.71828182845904523536));
+    Trice("msg:%f (default rounded float)\n", aFloat(2.71828182845904523536));
+    Trice("info:A Buffer:\n");
+    Trice8B("msg:%02x \n", aString, strlen(aString));
+    Trice32B("msg:%08x  \n", aString, strlen(aString) >> 2);
+    Trice16F("att:ARemoteFunctionName", aString, strlen(aString) >> 1);
+    trice("info:%d times a 16 byte long Trice messages, which may not be written all if the buffer is too small:\n", burstCount);
+    for (int i = 0; i < burstCount; i++)
+    {
+        Trice("i=%x %x\n", 0x44444400 + i, 0xaaaaaa00 + i);
+    }
+#endif
+}
+
+//! LogTriceConfiguration shows a few configuration settings.
+void LogTriceConfiguration(void)
+{
+#ifdef LogConfigInfo
+    LogConfigInfo();
+#endif
+
+#if 0
+    trice("deb:TRICE_DIRECT_OUTPUT == %d, TRICE_DEFERRED_OUTPUT == %d\n", TRICE_DIRECT_OUTPUT, TRICE_DEFERRED_OUTPUT);
+#if TRICE_BUFFER == TRICE_STACK_BUFFER
+    trice("deb:TRICE_STACK_BUFFER, ");
+#elif TRICE_BUFFER == TRICE_STATIC_BUFFER
+    trice("deb:TRICE_STATIC_BUFFER, ");
+#elif TRICE_BUFFER == TRICE_DOUBLE_BUFFER
+    trice("deb:TRICE_DOUBLE_BUFFER, ");
+#elif TRICE_BUFFER == TRICE_RING_BUFFER
+    trice("deb:TRICE_RING_BUFFER, ");
+#endif
+#if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+    trice("deb:TRICE_SINGLE_PACK_MODE\n");
+#else
+    trice("deb:TRICE_MULTI_PACK_MODE\n");
+#endif
+    trice("deb:_CYCLE == %d, _PROTECT == %d, _DIAG == %d, XTEA == %d\n", TRICE_CYCLE_COUNTER, TRICE_PROTECT, TRICE_DIAGNOSTICS, TRICE_DEFERRED_XTEA_ENCRYPT);
+    trice("d:_SINGLE_MAX_SIZE=%d, _BUFFER_SIZE=%d, _DEFERRED_BUFFER_SIZE=%d\n", TRICE_SINGLE_MAX_SIZE, TRICE_BUFFER_SIZE, TRICE_DEFERRED_BUFFER_SIZE);
+#endif
+}
+
+#endif // #if !TRICE_OFF

Middlewares/trice/example/triceLogDiagData.c

@@ -0,0 +1,104 @@
+/*!
+ *  \file triceLogDiagData.c
+ * \author Thomas.Hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+#include "trice.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !TRICE_OFF && TRICE_DIAGNOSTICS == 1
+
+//! TriceLogDiagnosticData shows the max used buffer space.
+void TriceLogDiagnosticData(void)
+{
+#ifdef SEGGER_RTT
+    int RTT0_wrSpaceMin = BUFFER_SIZE_UP - RTT0_writeDepthMax;
+    if ((RTT0_wrSpaceMin < TRICE_BUFFER_SIZE))
+    {
+        //trice16("WARNING:RTT0_writeDepthMax=%u (BUFFER_SIZE_UP=%u)\n", RTT0_writeDepthMax, BUFFER_SIZE_UP);
+    }
+    else
+    {
+        //trice16("diag:RTT0_writeDepthMax=%u (BUFFER_SIZE_UP=%u)\n", RTT0_writeDepthMax, BUFFER_SIZE_UP);
+    }
+#endif // #ifdef SEGGER_RTT
+
+    if (TriceErrorCount > 0)
+    {
+        //trice16("err:TriceErrorCount = %u\n", TriceErrorCount);
+    }
+
+#if TRICE_PROTECT == 1
+#if TRICE_DIRECT_OUTPUT == 1
+    if (TriceDirectOverflowCount != 0)
+    {
+        //trice16("err:TriceDirectOverflowCount = %u\n", TriceDirectOverflowCount);
+    }
+#endif // #if TRICE_DIRECT_OUTPUT == 1
+#if TRICE_DEFERRED_OUTPUT == 1
+    if (TriceDeferredOverflowCount != 0)
+    {
+        //trice16("err:TriceDeferredOverflowCount = %u\n", TriceDeferredOverflowCount);
+    }
+#endif // #if TRICE_DEFERRED_OUTPUT == 1
+#endif // #if TRICE_PROTECT == 1
+
+    unsigned triceSingleDepthMax = TRICE_DATA_OFFSET + (TriceSingleMaxWordCount << 2); // lint !e845 Info 845: The left argument to operator '<<' is certain to be 0
+    if (triceSingleDepthMax <= TRICE_BUFFER_SIZE)
+    {
+        //trice16("diag:triceSingleDepthMax =%4u of %d (TRICE_BUFFER_SIZE)\n", triceSingleDepthMax, TRICE_BUFFER_SIZE);
+    }
+    else
+    {
+        //trice16("err:triceSingleDepthMax =%4u of %d (TRICE_BUFFER_SIZE overflow!)\n", triceSingleDepthMax, TRICE_BUFFER_SIZE);
+    }
+
+    if (TriceDataOffsetDepthMax < 0 || TriceDataOffsetDepthMax >= TRICE_DATA_OFFSET)
+    {
+        //trice16("err:TriceDataOffsetDepthMax = %d of %d (TRICE_DATA_OFFSET)\n", TriceDataOffsetDepthMax, TRICE_DATA_OFFSET);
+    }
+    else if (TriceDataOffsetDepthMax != 0)
+    {
+        //trice16("diag:TriceDataOffsetDepthMax = %d of %d (TRICE_DATA_OFFSET)\n", TriceDataOffsetDepthMax, TRICE_DATA_OFFSET);
+    }
+
+    if (TriceDynStringBufTruncateCount != 0)
+    {
+        //trice16("wrn:TriceDynStringBufTruncateCount = %u\n", TriceDynStringBufTruncateCount);
+    }
+
+#if TRICE_BUFFER == TRICE_STACK_BUFFER
+#endif // #if TRICE_BUFFER == TRICE_STACK_BUFFER
+
+#if TRICE_BUFFER == TRICE_STATIC_BUFFER
+#endif // #if TRICE_BUFFER == TRICE_STATIC_BUFFER
+
+#if TRICE_BUFFER == TRICE_DOUBLE_BUFFER
+    if (TriceHalfBufferDepthMax <= TRICE_DEFERRED_BUFFER_SIZE / 2)
+    {
+        //trice16("diag:TriceHalfBufferDepthMax =%4u of%5d\n", TriceHalfBufferDepthMax, TRICE_DEFERRED_BUFFER_SIZE / 2);
+    }
+    else
+    {
+        //trice16("err:TriceHalfBufferDepthMax =%4u of%5d (overflow!)\n", TriceHalfBufferDepthMax, TRICE_DEFERRED_BUFFER_SIZE / 2);
+    }
+#endif // #if TRICE_BUFFER == TRICE_DOUBLE_BUFFER
+
+#if TRICE_BUFFER == TRICE_RING_BUFFER
+    if (TriceRingBufferDepthMax <= TRICE_DEFERRED_BUFFER_SIZE)
+    {
+        //trice16("diag:triceRingBufferDepthMax =%4u of%5d\n", TriceRingBufferDepthMax, TRICE_DEFERRED_BUFFER_SIZE);
+    }
+    else
+    {
+        //trice16("err:triceRingBufferDepthMax =%4u of%5d (overflow!)\n", TriceRingBufferDepthMax, TRICE_DEFERRED_BUFFER_SIZE);
+    }
+#endif // #if TRICE_BUFFER == TRICE_RING_BUFFER
+}
+
+#endif // #if !TRICE_OFF && TRICE_DIAGNOSTICS == 1

Middlewares/trice/example/triceUart.h

@@ -0,0 +1,85 @@
+/*! \file triceUart.h
+\author Thomas.Hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#ifndef TRICE_UART_H_
+#define TRICE_UART_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "trice.h"
+#include "main.h" // hardware specific definitions
+
+TRICE_INLINE void ToggleOpticalFeedbackLED( void ){
+    //LL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
+}
+
+#if TRICE_DEFERRED_UARTA == 1
+
+//! Check if a new byte can be written into trice transmit register.
+//! \retval 0 == not empty
+//! \retval !0 == empty
+//! User must provide this function.
+TRICE_INLINE uint32_t triceTxDataRegisterEmptyUartA(void) {
+    return LL_USART_IsActiveFlag_TXE(TRICE_UARTA);
+}
+
+//! Write value v into trice transmit register.
+//! \param v byte to transmit
+//! User must provide this function.
+TRICE_INLINE void triceTransmitData8UartA(uint8_t v) {
+    LL_USART_TransmitData8(TRICE_UARTA, v);
+    ToggleOpticalFeedbackLED();
+}
+
+//! Allow interrupt for empty trice data transmit register.
+//! User must provide this function.
+TRICE_INLINE void triceEnableTxEmptyInterruptUartA(void) {
+    //LL_USART_EnableIT_TXE(TRICE_UARTA);
+}
+
+//! Disallow interrupt for empty trice data transmit register.
+//! User must provide this function.
+TRICE_INLINE void triceDisableTxEmptyInterruptUartA(void) {
+    //LL_USART_DisableIT_TXE(TRICE_UARTA);
+}
+#endif // #if TRICE_DEFERRED_UARTA == 1
+
+#if TRICE_DEFERRED_UARTB == 1
+
+//! Check if a new byte can be written into trice transmit register.
+//! \retval 0 == not empty
+//! \retval !0 == empty
+//! User must provide this function.
+TRICE_INLINE uint32_t triceTxDataRegisterEmptyUartB(void) {
+    return LL_USART_IsActiveFlag_TXE(TRICE_UARTB);
+}
+
+//! Write value v into trice transmit register.
+//! \param v byte to transmit
+//! User must provide this function.
+TRICE_INLINE void triceTransmitData8UartB(uint8_t v) {
+    LL_USART_TransmitData8(TRICE_UARTB, v);
+    ToggleOpticalFeedbackLED();
+}
+
+//! Allow interrupt for empty trice data transmit register.
+//! User must provide this function.
+TRICE_INLINE void triceEnableTxEmptyInterruptUartB(void) {
+    LL_USART_EnableIT_TXE(TRICE_UARTB);
+}
+
+//! Disallow interrupt for empty trice data transmit register.
+//! User must provide this function.
+TRICE_INLINE void triceDisableTxEmptyInterruptUartB(void) {
+    LL_USART_DisableIT_TXE(TRICE_UARTB);
+}
+#endif // #if TRICE_DEFERRED_UARTB == 1
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TRICE_UART_H_ */

Middlewares/trice/tcobs.h

@@ -0,0 +1,42 @@
+/*! \file tcobs.h
+\author thomas.hoehenleitner [at] seerose.net
+\details See ./TCOBSv1Specification.md.
+*******************************************************************************/
+
+#ifndef TCOBS_H_
+#define TCOBS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+//! TCOBSEncode stuffs "length" bytes of data beginning at the location pointed to by "input" and writes the output to the
+//! location pointed to by "output". Returns the number of bytes written to "output" or a negative value in error case.
+//! A 0-delimiter is NOT added as last byte allowing concatenating TCOBS encoded buffers to one bigger buffer before the
+//! 00-byte delimiting. Buffer overlapping is allowed, when input lays inside output with a sufficient offset. The offset
+//! should be >= next large whole number of length/31. because in the worst case for each 31 bytes an additional sigil byte
+//! is inserted. The provided output buffer size should be >= length + next large whole number of length/31. This is a
+//! responsibility of the caller and not checked for efficiency.
+//! If your compiler uses a pre-C99 C dialect and does not know The "__restrict" keyword, you can define it in the project settings.
+int TCOBSEncode(void* __restrict output, const void* __restrict input, size_t length);
+
+//! TCOBSDecode decodes data ending at the location pointed to by "input" backwards (starting with the last byte)
+//! and writes the output also backwards to the location pointed to by "output" with a maximum size of max.
+//! Returns the number of bytes written to "output". Only max bytes are written. If the returned value is
+//! > max, this is an error "output buffer too small". In case of an error, a negative value is returned.
+//! THIS IS **IMPORTANT**: The decoded data start at output+max-returned, because output is filled from the end.
+//! Buffer overlapping is partially possible if output limit is _behind_ input limit with sufficient distance,
+//! but data can get much longer.
+//! If your compiler uses a pre-C99 C dialect and does not know The "__restrict" keyword, you can define it in the project settings.
+int TCOBSDecode(void* __restrict output, size_t max, const void* __restrict input, size_t length);
+
+#define OUT_BUFFER_TOO_SMALL -1000000 //!< OUT_BUFFER_TOO_SMALL is TCOBSDecode return error code.
+#define INPUT_DATA_CORRUPTED -2000000 //!< INPUT_DATA_CORRUPTED is TCOBSDecode return error code.
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TCOBS_H_

Middlewares/trice/tcobsv1Decode.c

@@ -0,0 +1,117 @@
+/*! \file tcobsv1Decode.c
+\author Thomas.Hoehenleitner [at] seerose.net
+\details See ./TCOBSv1Specification.md.
+*******************************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h> // memcpy
+#include "tcobs.h"
+#include "tcobsv1Internal.h"
+
+static int sigilAndOffset(uint8_t* sigil, uint8_t b);
+static uint8_t repeatByte(int offset, uint8_t* in, int len);
+
+int TCOBSDecode(void* __restrict output, size_t max, const void* __restrict input, size_t length) {
+	uint8_t* in = (uint8_t*)input;
+	int ilen = (int)length; // remaining input length
+	uint8_t* out = (uint8_t*)output;
+	int olen = 0; // output length
+	while (ilen > 0) {
+		uint8_t next = in[ilen - 1]; // get next sigil byte (starting from the end)
+		uint8_t sigil;
+		uint8_t r;
+		int offset = sigilAndOffset(&sigil, next);
+		if (offset + 1 > ilen) {
+			return INPUT_DATA_CORRUPTED - __LINE__;
+		}
+		ilen -= 1; // remove sigil byte from buffer
+		switch (sigil) {
+		case N:
+			goto copyBytes;
+
+		case Z3:
+			olen += 1;
+			out[max - olen] = 0;
+			// fallthrough
+		case Z2:
+			olen += 1;
+			out[max - olen] = 0;
+			// fallthrough
+		case Z1:
+			olen += 1;
+			out[max - olen] = 0;
+			goto copyBytes;
+
+		case F4:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			// fallthrough
+		case F3:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			// fallthrough
+		case F2:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			olen += 1;
+			out[max - olen] = 0xFF;
+			goto copyBytes;
+
+		case R4:
+			olen += 1;
+			out[max - olen] = repeatByte(offset, in, ilen);
+			// fallthrough
+		case R3:
+			olen += 1;
+			out[max - olen] = repeatByte(offset, in, ilen);
+			// fallthrough
+		case R2:
+			r = repeatByte(offset, in, ilen);
+			olen += 1;
+			out[max - olen] = r;
+			olen += 1;
+			out[max - olen] = r;
+			goto copyBytes;
+
+		default:
+			return INPUT_DATA_CORRUPTED - __LINE__;
+		}
+
+	copyBytes: {
+		uint8_t* to = out + max - olen - offset; // to := len(d) - n - offset
+		uint8_t* from = in + ilen - offset;      // from := len(in) - offset // sigil byte is already removed
+		if (to < out) {
+			return OUT_BUFFER_TOO_SMALL - __LINE__;
+		}
+		memcpy(to, from, offset); // n += copy(d[to:], in[from:])
+		olen += offset;
+		ilen -= offset; // in = in[:len(in)-offset] // remove copied bytes
+		continue;
+	}
+	}
+	return olen;
+}
+
+// sigilAndOffset interprets b as sigil byte with offset, fills sigil and returns offset.
+// For details see TCOBSv1Specification.md.
+static int sigilAndOffset(uint8_t* sigil, uint8_t b) {
+	int offset;
+	*sigil = b & 0xE0; // 0x11100000
+	if (*sigil == 0) {
+		*sigil = b & 0xF8; // 0x11111000
+		offset = 7 & b;    // 0x00000111
+	} else {
+		offset = 0x1F & b; // 0x00011111
+	}
+	return offset;
+}
+
+// repeatByte returns the value to repeat
+static uint8_t repeatByte(int offset, uint8_t* in, int len) {
+	if (offset == 0) {      // left byte of Ri is a sigil byte (probably N)
+		return in[len - 2]; // a buffer cannot start with Ri
+	} else {
+		return in[len - 1];
+	}
+}

Middlewares/trice/tcobsv1Encode.c

@@ -0,0 +1,400 @@
+/*! \file tcobsv1Encode.c
+\author Thomas.Hoehenleitner [at] seerose.net
+\details See ./TCOBSv1Specification.md.
+*******************************************************************************/
+
+#include <stdint.h>
+#include <stddef.h>
+#include "tcobs.h"
+#include "tcobsv1Internal.h"
+
+// lint -e801 Info 801: Use of goto is deprecated
+
+//! ASSERT checks for a true condition, otherwise stop.
+//! This macro was used during development to verify the code.
+#define ASSERT(condition) //  do{ if( !(condition) ){ for(;;){} } }while(0);
+
+//! OUTB writes a non-sigil byte to output and increments offset.
+//! If offset reaches 31, a NOP sigil byte is inserted and offset is then set to 0.
+#define OUTB(by)              \
+	{                         \
+		*o++ = by;            \
+		offset++;             \
+		ASSERT(offset <= 31); \
+		if (offset == 31) {   \
+			*o++ = N | 31;    \
+			offset = 0;       \
+		}                     \
+	}
+
+//! OUT_zeroSigil writes one of the sigil bytes Z1, Z3, Z3
+//! according to zeroCount and sets zeroCount=0 and offset=0.
+#define OUT_zeroSigil                             \
+	{                                             \
+		ASSERT(b_1 == 0);                         \
+		ASSERT((fullCount | reptCount) == 0);     \
+		ASSERT(1 <= zeroCount && zeroCount <= 3); \
+		ASSERT(offset <= 31);                     \
+		*o++ = (zeroCount << 5) | offset;         \
+		offset = 0;                               \
+		zeroCount = 0;                            \
+	}
+
+//! OUT_fullSigil writes one of the sigil bytes F2, F3, F4
+//! according to fullCount and sets fullCount=0 and offset=0.
+#define OUT_fullSigil                             \
+	{                                             \
+		ASSERT(b_1 == 0xFF);                      \
+		ASSERT((zeroCount | reptCount) == 0);     \
+		ASSERT(2 <= fullCount && fullCount <= 4); \
+		ASSERT(offset <= 31);                     \
+		*o++ = 0x80 | (fullCount << 5) | offset;  \
+		offset = 0;                               \
+		fullCount = 0;                            \
+	}
+
+//! OUT_reptSigil writes one of the sigil bytes R2, R3, R4
+//! according to reptCount and sets reptCount=0 and offset=0.
+//! If offset is bigger than 7 a NOP sigil byte is inserted.
+#define OUT_reptSigil                             \
+	{                                             \
+		ASSERT((zeroCount | fullCount) == 0);     \
+		ASSERT(2 <= reptCount && reptCount <= 4); \
+		ASSERT(offset <= 31);                     \
+		if (offset > 7) {                         \
+			*o++ = N | offset;                    \
+			offset = 0;                           \
+		}                                         \
+		*o++ = ((reptCount - 1) << 3) | offset;   \
+		offset = 0;                               \
+		reptCount = 0;                            \
+	}
+
+int TCOBSEncode(void* __restrict output, const void* __restrict input, size_t length) {
+	uint8_t* o = output; // write pointer
+	uint8_t* out = output;
+	uint8_t const* i = input;                        // read pointer
+	uint8_t const* limit = (uint8_t*)input + length; // read limit
+	uint8_t zeroCount = 0;                           // counts zero bytes 1-3 for Z1-Z3
+	uint8_t fullCount = 0;                           // counts 0xFF bytes 1-4 for FF and F2-F4
+	uint8_t reptCount = 0;                           // counts repeat bytes 1-4 for !00 and R2-R4,
+	uint8_t b_1 = 0;                                 // previous byte
+	uint8_t b = 0;                                   // current byte
+	uint8_t offset = 0;                              // link to next sigil or buffer start looking backwards
+	// comment syntax:
+	//     Sigil bytes chaining is done with offset and not shown explicitly.
+	//     All left from comma is already written to o and if, only partially shown.
+	//     n is 0...3|4 and m is n+1, representing count number.
+	//     zn, fn, rn right from comma is count in variables, if not shown, then 0.
+	//     At any moment only one of the 3 counters can be different from 0.
+	//     Zn, Fn, Rn, Nn are (written) sigil bytes.
+	//     Between comma and dot are the 2 values b_1 and b.
+	//     3 dots ... means it is unknown if bytes follow.
+	//     !00 is a byte != 00.
+	//     !FF is a byte != FF.
+	//     aa is not 00 and not FF and all aa in a row are equal.
+	//     xx yy and zz are any bytes.
+	//     Invalid b_1 and b are displayed as --.
+
+	if (length >= 2) { // , -- --. xx yy ...
+		b = *i++;      // , -- xx. yy ...
+		for (;;) {     // , zn|fn|rn -- xx. yy ...
+			b_1 = b;   // , xx --. yy ...
+			b = *i++;  // , xx yy. ...
+
+			if (limit - i > 0) { // , xx yy. zz ...
+
+				// , z0 00 00. -> , z1 -- 00.
+				// , z0 00 00. 00 -> , z2 -- 00.
+
+				if ((b_1 | b) == 0) {         // , zn 00 00. zz ...
+					zeroCount++;              // , zm -- 00. zz ...
+					if (zeroCount == 2) {     // , z2 -- 00. zz ...
+						zeroCount = 3;        // , z3 -- --. zz ...
+						OUT_zeroSigil         // Z3, -- --. zz ...
+						    b = *i++;         // , -- zz. ...
+						if (limit - i == 0) { // , -- zz.
+							goto lastByte;
+						}
+						// , -- xx. yy ...
+					}
+					continue; // , zn -- xx. yy ...
+				}
+
+				// , f0 FF FF. -> , f1 -- FF.
+				// , f0 FF FF. FF -> , f2 -- FF.
+				// , f0 FF FF. FF FF -> , f3 -- FF.
+
+				if ((b_1 & b) == 0xFF) {      // , fn FF FF. zz ...
+					fullCount++;              // , fm -- FF. zz ...
+					if (fullCount == 3) {     // , f3 -- FF. zz ...
+						fullCount = 4;        // , f4 -- --. zz ...
+						OUT_fullSigil         // F4, -- --. zz ...
+						    b = *i++;         // , -- zz. ...
+						if (limit - i == 0) { // , -- zz.
+							goto lastByte;
+						}
+						// , -- xx. yy ...
+					}
+					continue; // , fn -- xx. yy ...
+				}
+
+				// , r0 aa aa. -> , r1 -- aa.
+				// , r0 aa aa. aa -> , r2 -- aa.
+				// , r0 aa aa. aa aa -> , r3 -- aa.
+				// , r0 aa aa. aa aa aa -> , r4 -- aa.
+
+				if (b_1 == b) { // , rn aa aa. xx ...
+					ASSERT(b_1 != 0);
+					ASSERT(b_1 != 0xFF);
+					reptCount++;              // , rm -- aa. xx ...
+					if (reptCount == 4) {     // , r4 -- aa. xx ...
+						OUTB(b)               // aa, r4 -- --. xx ...
+						OUT_reptSigil         // aa R4, -- --. xx ...
+						    b = *i++;         // , -- xx. ...
+						if (limit - i == 0) { // , -- xx.
+							goto lastByte;
+						}
+						// , -- xx. yy ...
+					}
+					continue; // , r1|r2|r3 -- aa. yy ...
+				} // OR // , -- xx. yy ...
+
+				// , zn|fn|rn xx yy. zz ... (at this point is b_1 != b)
+
+				// handle counts
+				if (zeroCount) { // , z1|z2 00 aa. xx ...
+					ASSERT(1 <= zeroCount && zeroCount <= 2)
+					ASSERT(b_1 == 0)
+					ASSERT(b_1 != b)
+					zeroCount++;  // , z2|z3 -- aa. xx ...
+					OUT_zeroSigil // Z2|Z3, -- aa. xx ...
+					    continue;
+				}
+				if (fullCount) { // , f1|f2|f3 FF !FF. xx ...
+					ASSERT(1 <= fullCount && fullCount <= 3)
+					ASSERT(b_1 == 0xFF)
+					ASSERT(b_1 != b)
+					fullCount++;  // , f2|f3|f4 -- !FF. xx ...
+					OUT_fullSigil // Fn, -- !FF. xx ...
+					    continue;
+				}
+				if (reptCount) { // , r1|r2|r3 aa !aa. xx ...
+					ASSERT(1 <= reptCount && reptCount <= 3)
+					ASSERT(b_1 != 0)
+					ASSERT(b_1 != 0xFF)
+					ASSERT(b_1 != b)
+					if (reptCount == 1) { // , r1 aa !aa. xx ...
+						reptCount = 0;    // clear
+						OUTB(b_1)         // aa, r0 aa !aa. xx ...
+						OUTB(b_1)         // aa aa, -- !aa. xx ...
+						continue;
+					}
+					*o++ = b_1; // aa, r2|r3 -- !aa. xx ...
+					offset++;
+					OUT_reptSigil // aa R1|R2|R3, -- !aa. xx ...
+					    continue;
+				}
+
+				// at this point all counts are 0, b_1 != b and b_1 = xx, b == yy
+				ASSERT(zeroCount == 0)
+				ASSERT(fullCount == 0)
+				ASSERT(reptCount == 0)
+				ASSERT(b_1 != b)
+
+				// , xx yy. zz ...
+				if (b_1 == 0) { // , 00 !00. xx ...
+					ASSERT(b != 0)
+					zeroCount++;            // , z1 -- !00. xx ...
+					OUT_zeroSigil continue; // Z1, -- !00. xx ...
+				}
+				if (b_1 == 0xFF) { // , FF !FF. xx ...
+					ASSERT(b != 0xFF)
+					OUTB(0xFF); // FF, -- !FF. xx ...
+					continue;
+				}
+
+				// , aa xx. yy ...
+				ASSERT(1 <= b_1 && b_1 <= 0xFE)
+				OUTB(b_1) // aa, -- xx. yy ...
+				continue;
+
+			} else { // last 2 bytes
+				// , zn|fn|rn xx yy.
+				if ((zeroCount | fullCount | reptCount) == 0) { // , xx yy.
+					if (b_1 == 0 && b == 0) {                   // , 00 00.
+						*o++ = Z2 | offset;                     // Z2, -- --.
+						return o - out;
+					}
+					if (b_1 == 0xFF && b == 0xFF) { // , FF FF.
+						*o++ = F2 | offset;         // F2, -- --.
+						return o - out;
+					}
+					if (b_1 == 0) {    // , 00 xx.
+						zeroCount = 1; // , z1 -- xx.
+						OUT_zeroSigil  // Z1, -- xx.
+						    goto lastByte;
+					}
+					// , aa xx.
+					ASSERT(b_1 != 0)
+					OUTB(b_1) // aa, -- xx.
+					goto lastByte;
+				}
+
+				// At this point exactly one count was incremented.
+				// If a count is >0 it is necessarily related to b_1.
+
+				if (zeroCount == 1) { // , z1 00 yy
+					ASSERT(fullCount == 0)
+					ASSERT(reptCount == 0)
+					ASSERT(b_1 == 0)
+					if (b != 0) {     // , z1 00 !00.
+						zeroCount++;  // , z2 -- !00.
+						OUT_zeroSigil // Z2, -- !00.
+						    goto lastByte;
+					}
+					if (b == 0) {           // , z1 00 00.
+						*o++ = Z3 | offset; // Z3, -- --.
+						return o - out;
+					}
+					ASSERT(0)
+				}
+
+				if (zeroCount == 2) { // , z2 00 !00.
+					ASSERT(fullCount == 0)
+					ASSERT(reptCount == 0)
+					ASSERT(b_1 == 0)
+					ASSERT(b != 0)
+					zeroCount = 3; // , z3 -- aa.
+					OUT_zeroSigil  // Z3, -- aa.
+					    goto lastByte;
+				}
+
+				if (fullCount == 1) { // , f1 FF yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(reptCount == 0)
+					ASSERT(b_1 == 0xFF)
+					if (b == 0xFF) { // , f1 FF FF.
+						ASSERT(offset <= 31);
+						*o++ = F3 | offset; // F3, -- --.
+						return o - out;
+					}
+					fullCount = 2; // , f2 -- yy.
+					OUT_fullSigil  // F2, -- yy.
+					    goto lastByte;
+				}
+
+				if (fullCount == 2) { // , f2 FF yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(reptCount == 0)
+					ASSERT(b_1 == 0xFF)
+					if (b == 0xFF) { // , f2 FF FF.
+						ASSERT(offset <= 31);
+						*o++ = F4 | offset; // F4, -- --.
+						return o - out;
+					}
+					// , f2 FF !FF
+					fullCount++;  // , f3 -- !FF.
+					OUT_fullSigil // F3, -- !FF.
+					    goto lastByte;
+				}
+
+				if (fullCount == 3) { // , f3 FF yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(reptCount == 0)
+					ASSERT(b_1 == 0xFF)
+					if (b == 0xFF) {  // , f3 FF FF.
+						OUT_fullSigil // F3, FF FF.
+						    ASSERT(offset <= 31);
+						*o++ = F2 | offset; // F3 F2, -- --.
+						return o - out;     // option: F4 FF, -- --. is also right
+					}
+					// , f3 FF !FF.
+					fullCount = 4; // , f4 -- xx.
+					OUT_fullSigil  // F4, -- xx.
+					    goto lastByte;
+				}
+
+				if (reptCount == 1) { // , r1 aa yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(fullCount == 0)
+					ASSERT(b_1 != 0)
+					ASSERT(b_1 != 0xFF)
+					if (b_1 == b) { // , r1 aa aa.
+						OUTB(b_1)   // aa, r1 -- aa.
+						ASSERT(offset <= 31);
+						if (offset > 7) {
+							*o++ = N | offset;
+							offset = 0;
+						}
+						*o++ = R2 | offset; // aa R2, -- --.
+						return o - out;
+					}
+					OUTB(b_1) // aa, r0 aa -- yy.
+					OUTB(b_1) // aa aa, -- yy.
+					goto lastByte;
+				}
+				if (reptCount == 2) { // , r2 aa yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(fullCount == 0)
+					ASSERT(b_1 != 0)
+					ASSERT(b_1 != 0xFF)
+					if (b_1 == b) { // , r2 aa aa.
+						OUTB(b_1)   // aa, r2 -- aa.
+						ASSERT(offset <= 31);
+						if (offset > 7) {
+							*o++ = N | offset;
+							offset = 0;
+						}
+						*o++ = R3 | offset; // aa R3, -- --.
+						return o - out;
+					}
+					OUTB(b_1)     // aa, r2 -- yy.
+					OUT_reptSigil // aa R2, -- xx.
+					    goto lastByte;
+				}
+				if (reptCount == 3) { // , r3 aa yy.
+					ASSERT(zeroCount == 0)
+					ASSERT(fullCount == 0)
+					ASSERT(b_1 != 0)
+					ASSERT(b_1 != 0xFF)
+					OUTB(b_1)       // aa, r3 -- yy.
+					if (b_1 == b) { // , r3 aa aa.
+						ASSERT(offset <= 31);
+						if (offset > 7) {
+							*o++ = N | offset;
+							offset = 0;
+						}
+						*o++ = R4 | offset; // aa R4, -- --.
+						return o - out;
+					}
+					// aa, r3 -- yy.
+					OUT_reptSigil // aa R3, -- xx.
+					    goto lastByte;
+				}
+
+				ASSERT(0) // will not be reached
+			}
+		}
+	}
+	if (length == 0) { // , -- --.
+		return 0;
+	}
+	if (length == 1) { // , . xx
+		b = *i;        // , -- xx.
+		goto lastByte;
+	}
+
+lastByte:         // , -- xx.
+	if (b == 0) { // , -- 00.
+		ASSERT(offset <= 31);
+		*o++ = Z1 | offset; // Z1, -- --.
+		return o - out;
+	} else {      // , -- aa.
+		*o++ = b; // aa|ff, -- --.
+		offset++;
+		ASSERT(offset <= 31);
+		*o++ = N | offset; // aa Nn, -- --.
+		return o - out;
+	}
+}

Middlewares/trice/tcobsv1Internal.h

@@ -0,0 +1,28 @@
+/*! \file tcobsInternal.h
+\author Thomas.Hoehenleitner [at] seerose.net
+\details See ./TCOBSv1Specification.md. Only internal usage.
+*******************************************************************************/
+
+#ifndef TCOBS_INTERNAL_H_
+#define TCOBS_INTERNAL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define N 0xA0  //!< sigil byte 0x101ooooo, offset 0-31
+#define Z1 0x20 //!< sigil byte 0x001ooooo, offset 0-31
+#define Z2 0x40 //!< sigil byte 0x010ooooo, offset 0-31
+#define Z3 0x60 //!< sigil byte 0x011ooooo, offset 0-31
+#define F2 0xC0 //!< sigil byte 0x110ooooo, offset 0-31
+#define F3 0xE0 //!< sigil byte 0x111ooooo, offset 0-31
+#define F4 0x80 //!< sigil byte 0x100ooooo, offset 0-31
+#define R2 0x08 //!< sigil byte 0x00001ooo, offset 0-7
+#define R3 0x10 //!< sigil byte 0x00010ooo, offset 0-7
+#define R4 0x18 //!< sigil byte 0x00011ooo, offset 0-7
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TCOBS_INTERNAL_H_

Middlewares/trice/trice.h

@@ -0,0 +1,787 @@
+/*!
+ *  \file trice.h
+   \author thomas.hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+#ifndef TRICE_H_
+#define TRICE_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#undef ID //!< avoid name clashes in case ID was used by an other library
+#undef Id //!< avoid name clashes in case Id was used by an other library
+#undef id //!< avoid name clashes in case id was used by an other library
+#undef iD //!< avoid name clashes in case iD was used by an other library
+
+#define TRICE_UNUSED(x) (void)(x); //!< https://stackoverflow.com/questions/3599160/how-can-i-suppress-unused-parameter-warnings-in-c
+
+// lint -e529  Warning 529: Symbol '_SEGGER_RTT__LockState' not subsequently referenced
+// lint -e629  Warning 629: static class for function '' is non standard
+// lint -emacro( 701, TRICE* ) Info 701: Shift left of signed quantity (int)
+// lint -emacro( 123, TRICE* )
+// lint -emacro( 571, TRICE* )
+// lint -emacro( 572, TRICE* )
+// lint -emacro( 578, TRICE* )
+// lint -emacro( 648, TRICE* )
+// lint -emacro( 665, TRICE* )
+// lint -emacro( 666, TRICE* )
+// lint -emacro( 670, TRICE* )
+// lint -emacro( 694, TRICE* )
+// lint -emacro( 717, TRICE* )
+// lint -emacro( 718, TRICE* )
+// lint -emacro( 732, TRICE* )
+// lint -emacro( 734, TRICE* )
+// lint -emacro( 736, TRICE* )
+// lint -emacro( 740, TRICE* )
+// lint -emacro( 746, TRICE* )
+// lint -emacro( 747, TRICE* )
+// lint -emacro( 774, TRICE* )
+// lint -emacro( 778, TRICE* )
+// lint -emacro( 826, TRICE* )
+// lint -emacro( 830, TRICE* )
+// lint -emacro( 831, TRICE* )
+// lint -emacro( 835, TRICE* )
+// lint -emacro( 545, SCOPY, DCOPY )
+// lint -ecall( 666, aFloat, aDouble )
+// lint -efunc( 666, aFloat, aDouble )
+// lint -esym( 666, aFloat, aDouble )
+// lint -emacro( 732, SCOPY )
+// lint -emacro( 717, DCOPY, SCOPY )
+// lint -emacro( 732, DCOPY )
+
+// helper macros (the numbers are 32-bit random values)
+
+//! TRICE_SINGLE_PACK_MODE is the recommended TRICE_DEFERRED_TRANSFER_MODE. It packs each trice in a separate TCOBS package with a following 0-delimiter byte.
+//! Single trices need a bit more transfer data. In case of a data disruption, only a single trice messages can get lost.
+#define TRICE_SINGLE_PACK_MODE 787345706U
+
+//! TRICE_MULTI_PACK_MODE packs all trices of a buffer in a single TCOBS package and a following 0-delimiter byte.
+//! Grouped trices need a bit less transfer data. In case of a data disruption, multiple trice messages can get lost.
+//! Olny relevant when TRICE_DOUBLE_BUFFER is selected
+#define TRICE_MULTI_PACK_MODE 3987862482U
+
+//! With TRICE_BUFFER == TRICE_STACK_BUFFER  the internal macro TRICE_PUT writes to the stack.
+//! This is direct logging. This reduces memory needs if only one stack is used.
+#define TRICE_STACK_BUFFER 2645382063U
+
+//! With TRICE_BUFFER == TRICE_STATIC_BUFFER the internal macro TRICE_PUT writes to a static buffer.
+//! This reduces memory needs if many stacks are used.
+#define TRICE_STATIC_BUFFER 1763551404U
+
+//! With TRICE_BUFFER == TRICE_DOUBLE_BUFFER the internal macro TRICE_PUT writes to a double buffer half.
+//! This is deferred logging using more space but the TRICE macros are executed faster.
+#define TRICE_DOUBLE_BUFFER 1950870368U
+
+//! With TRICE_BUFFER == TRICE_RING_BUFFER the internal macro TRICE_PUT writes to a ring buffer segment.
+//! This is deferred logging using less space but the TRICE macros are executed a bit slower.
+#define TRICE_RING_BUFFER 2237719049U
+
+//! TRICE_FRAMING_TCOBS is recommended for trice transfer over UART.
+#define TRICE_FRAMING_TCOBS 3745917584U
+
+//! TRICE_FRAMING_COBS is recommended for encrypted trices.
+#define TRICE_FRAMING_COBS 2953804234U
+
+//! TRICE_FRAMING_NONE is recommended for RTT in direct mode. One trice costs about 100 clocks and is completely done.
+#define TRICE_FRAMING_NONE 1431860787U
+
+#include <stdint.h>
+#include <string.h>
+#include "triceConfig.h"        // Project specific settings are overwriting the default settings.
+#include "triceDefaultConfig.h" // default settings
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// These converter functions need to be visible in the TRICE_OFF == 1 case to avoid compiler warnings then.
+//
+
+// pre C99
+//  // aFloat returns passed float value x as bit pattern in a uint32_t type.
+//  TRICE_INLINE uint32_t aFloat( float x ){
+//      union {
+//          float f;
+//          uint32_t u;
+//      } t;
+//      t.f = x;
+//      return t.u;
+//  }
+
+// aFloat returns passed float value x as bit pattern in a uint32_t type.
+TRICE_INLINE uint32_t aFloat(float f)
+{
+    union
+    {
+        float from;
+        uint32_t to;
+    } pun = {.from = f};
+    return pun.to;
+}
+
+// aDouble returns passed double value x as bit pattern in a uint64_t type.
+TRICE_INLINE uint64_t aDouble(double x)
+{
+    union
+    {
+        double d;
+        uint64_t u;
+    } t;
+    t.d = x;
+    return t.u;
+}
+
+// Just in case you are receiving Trice messages containing uint32_t values to be interpreted as float:
+//
+//  // asFloat returns passed uint32_t value x bit pattern as float type.
+//  TRICE_INLINE float asFloat(uint32_t x) {
+//      union {
+//          uint32_t from;
+//          float to;
+//      } pun = {.from = x};
+//      return pun.to;
+//  }
+
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Do not generate trice code
+// - when defining TRICE_CLEAN to 1 inside "triceConfig.h" or
+// - when defining TRICE_OFF to 1 before including "trice.h".
+// It is possible to `#define TRICE_OFF 1` inside the project settings to disable all Trice code.
+#if ((defined(TRICE_OFF) && TRICE_OFF == 1)) || ((defined(TRICE_CLEAN) && TRICE_CLEAN == 1))
+
+// When the user defines TRICE_CLEAN to 0 or 1 inside triceConfig.h, this value is set to 0 with "trice insert" and to 1 with "trice clean".
+// This gives the option to silence editor warnings in the "trice clean" state.
+// To avoid a re-build on files including trice.h, the Trice cache will be helpful. See issue #488.
+#include "triceOff.h"
+
+#else // #if ((defined(TRICE_OFF) && TRICE_OFF == 1)) || ((defined(TRICE_CLEAN) && TRICE_CLEAN == 1))
+/***************************************************************************************************/
+/**/
+/**/
+
+#include "triceOn.h"
+
+#if (TRICE_DIRECT_SEGGER_RTT_8BIT_WRITE == 1) || (TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE == 1) || (TRICE_DEFERRED_SEGGER_RTT_8BIT_WRITE == 1)
+
+#define SEGGER_RTT
+
+#endif
+
+#if defined(SEGGER_RTT) || (USE_SEGGER_RTT_LOCK_UNLOCK_MACROS == 1)
+
+#include "SEGGER_RTT.h"
+
+#endif
+
+// global defines
+
+#define TRICE_TYPE_X0 0 //!< TRICE_TYPE_X0 is an unspecified trice (reserved)
+#define TRICE_TYPE_S0 1 //!< TRICE_TYPE_S0 is a trice without stamp.
+#define TRICE_TYPE_S2 2 //!< TRICE_TYPE_S2 is a trice with 16-bit stamp.
+#define TRICE_TYPE_S4 3 //!< TRICE_TYPE_S4 is a trice with 32-bit stamp.
+
+// global variables:
+
+extern uint32_t *const triceSingleBufferStartWritePosition;
+extern unsigned TricesCountRingBuffer;
+extern char triceCommandBuffer[];
+extern int triceCommandFlag;
+extern uint8_t TriceCycle;
+extern unsigned RTT0_writeDepthMax;
+extern unsigned TriceErrorCount;
+
+#if (TRICE_BUFFER == TRICE_RING_BUFFER)
+
+extern uint32_t *const TriceRingBufferStart;
+extern uint32_t *const TriceRingBufferLimit;
+
+extern uint32_t *const TriceRingBufferProtectLimit;
+
+#if (TRICE_DIAGNOSTICS == 1)
+
+extern int TriceRingBufferDepthMax;
+
+#endif
+
+#if TRICE_RING_BUFFER_OVERFLOW_WATCH == 1
+
+void TriceInitRingBufferMargins(void);
+void WatchRingBufferMargins(void);
+
+#endif
+
+#endif // #if (TRICE_BUFFER == TRICE_RING_BUFFER)
+
+#if (TRICE_DIAGNOSTICS == 1)
+
+extern int TriceDataOffsetDepthMax;
+extern unsigned TriceSingleMaxWordCount;
+extern unsigned TriceDynStringBufTruncateCount;
+extern unsigned TriceHalfBufferDepthMax;
+
+#if TRICE_PROTECT == 1
+
+extern unsigned TriceDirectOverflowCount;
+extern unsigned TriceDeferredOverflowCount;
+
+#endif // #if TRICE_PROTECT == 1
+
+#define TRICE_DYN_STRG_BUF_TRUNCATE_COUNT_INCREMENT() \
+    do {                                         \
+        TriceDynStringBufTruncateCount++;              \
+    } while (0)
+
+#else // #if (TRICE_DIAGNOSTICS == 1)
+
+#define TRICE_DYN_STRG_BUF_TRUNCATE_COUNT_INCREMENT()
+
+#endif // #else // #if (TRICE_DIAGNOSTICS == 1)
+
+#if (TRICE_BUFFER == TRICE_RING_BUFFER) || (TRICE_BUFFER == TRICE_DOUBLE_BUFFER)
+
+extern uint32_t *TriceBufferWritePosition;
+
+#endif
+
+//! TRICE_BUFFER_SIZE is
+//! \li the additional needed stack space when TRICE_BUFFER == TRICE_STACK_BUFFER
+//! \li the statically allocated buffer size when TRICE_BUFFER == TRICE_STATIC_BUFFER
+//! \li the value before Ringbuffer wraps, when TRICE_BUFFER == TRICE_RING_BUFFER
+//!
+//! The trice buffer needs 4 additional scratch bytes, when the longest possible
+//! trice gets formally the padding space cleared.
+#define TRICE_BUFFER_SIZE (TRICE_DATA_OFFSET + TRICE_SINGLE_MAX_SIZE + 4)
+
+#if TRICE_CYCLE_COUNTER == 1
+
+#define TRICE_CYCLE TriceCycle++ //!< TRICE_CYCLE is the trice cycle counter as 8 bit count 0-255.
+
+#else // #if TRICE_CYCLE_COUNTER == 1
+
+#define TRICE_CYCLE 0xC0 //!< TRICE_CYCLE is no trice cycle counter, just a static value.
+
+#endif // #else // #if TRICE_CYCLE_COUNTER == 1
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// "Declare" endian dependent macros, needed in trice8.h, trice16.h, trice32.h, trice64.h:
+//
+#define TRICE_HTOTS(x) TRICE_HTOTS(x)
+#define TRICE_HTOTL(x) TRICE_HTOTL(x)
+#define TRICE_TTOHS(x) TRICE_TTOHS(x)
+#define TRICE_PUT16_1616(x, ts) TRICE_PUT16_1616(x, ts)
+#define TRICE_PUT64(x) TRICE_PUT64(x)
+#define TRICE_SWAPINT16(x) TRICE_SWAPINT16(x)
+#define TRICE_SWAPINT32(x) TRICE_SWAPINT32(x)
+#define idLH idLH
+#define IdLH IdLH
+#define IDLH IDLH
+#define tsL tsL
+#define tsH tsH
+#define tsHH tsHH
+#define tsHL tsHL
+#define tsLH tsLH
+#define tsLL tsLL
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//! TRICE_PUT16 copies 16-bit value x into the Trice buffer.
+#define TRICE_PUT16(x)                                     \
+    do {                                                   \
+        uint16_t* p = (uint16_t*)TriceBufferWritePosition; \
+        *p++ = TRICE_HTOTS(x);                             \
+        TriceBufferWritePosition = (uint32_t*)p;           \
+    } while (0)
+
+#include "trice8.h"
+#include "trice16.h"
+#include "trice32.h"
+#include "trice64.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Endian dependent macros and code:
+//
+#undef TRICE_HTOTS
+#undef TRICE_HTOTL
+#undef TRICE_TTOHS
+#undef TRICE_PUT16_1616
+#undef TRICE_PUT64
+#undef TRICE_SWAPINT16
+#undef TRICE_SWAPINT32
+#undef idLH
+#undef IdLH
+#undef IDLH
+#undef tsL
+#undef tsH
+#undef tsHH
+#undef tsHL
+#undef tsLH
+#undef tsLL
+
+#if (__STDC_VERSION__ >= 202000) //! C23 standard specification for endianess detection (Note N3022)
+
+// https://github.com/rokath/trice/pull/505
+
+#if __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__
+#define TRICE_MCU_IS_BIG_ENDIAN 0
+#else
+#define TRICE_MCU_IS_BIG_ENDIAN 1
+#endif // __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__
+
+#else
+
+//! Try detect endianess by using compilers macros
+#if (defined(BYTE_ORDER) && defined(ORDER_LITTLE_ENDIAN) && BYTE_ORDER == ORDER_LITTLE_ENDIAN) ||         \
+    (defined(__BYTE_ORDER) && defined(__ORDER_LITTLE_ENDIAN) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define TRICE_MCU_IS_BIG_ENDIAN 0
+
+#elif (defined(BYTE_ORDER) && defined(ORDER_BIG_ENDIAN) && BYTE_ORDER == ORDER_BIG_ENDIAN) ||       \
+    (defined(__BYTE_ORDER) && defined(__ORDER_BIG_ENDIAN) && __BYTE_ORDER == __ORDER_BIG_ENDIAN) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define TRICE_MCU_IS_BIG_ENDIAN 1
+
+#else
+
+#ifndef TRICE_MCU_IS_BIG_ENDIAN
+#error Bytes order not supported or not detected, set TRICE_MCU_IS_BIG_ENDIAN to 0 or 1 in your triceConfig.h file.
+#endif // #ifndef TRICE_MCU_IS_BIG_ENDIAN
+
+#endif // __BYTE_ORDER__
+
+#endif // __STDC_VERSION__
+
+#if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == TRICE_MCU_IS_BIG_ENDIAN
+
+// TRICE_REVERSE == 0 uses no byte swapping inside the Trice macros resulting in less code and faster execution.
+#include "triceMcuOrder.h"
+#include "trice8McuOrder.h"
+#include "trice16McuOrder.h"
+#include "trice32McuOrder.h"
+#include "trice64McuOrder.h"
+
+#else // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == TRICE_MCU_IS_BIG_ENDIAN
+
+// TRICE_REVERSE == 1 causes byte swapping inside the Trice macros resulting in more code and slower execution.
+#include "triceMcuReverse.h"
+#include "trice8McuReverse.h"
+#include "trice16McuReverse.h"
+#include "trice32McuReverse.h"
+#include "trice64McuReverse.h"
+
+#endif // #else // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == TRICE_MCU_IS_BIG_ENDIAN
+
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if TRICE_DIAGNOSTICS == 1
+
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START \
+    uint32_t* const triceSingleBufferStartWritePosition = TriceBufferWritePosition;
+
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER                                                                        \
+    do {                                                                                                       \
+        unsigned wordCount = TriceBufferWritePosition - triceSingleBufferStartWritePosition;                   \
+        TriceSingleMaxWordCount = (wordCount < TriceSingleMaxWordCount) ? TriceSingleMaxWordCount : wordCount; \
+    } while (0);
+
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER_USING_WORD_COUNT                                                       \
+    do {                                                                                                       \
+        TriceSingleMaxWordCount = (wordCount < TriceSingleMaxWordCount) ? TriceSingleMaxWordCount : wordCount; \
+    } while (0);
+
+#else // #if TRICE_DIAGNOSTICS == 1
+
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER
+#define TRICE_DIAGNOSTICS_SINGLE_BUFFER_USING_WORD_COUNT
+
+#endif // #else // #if TRICE_DIAGNOSTICS == 1
+
+// clang-format off
+
+#ifndef TRICE_ENTER
+
+#if TRICE_BUFFER == TRICE_STACK_BUFFER
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                                                                                           \
+            TRICE_ENTER_CRITICAL_SECTION {                                                                            \
+                {                                                                                                     \
+                    uint32_t triceSingleBuffer[TRICE_BUFFER_SIZE >> 2]; /* no = {0} here for speed */                 \
+                    uint32_t* const triceSingleBufferStartWritePosition = &triceSingleBuffer[TRICE_DATA_OFFSET >> 2]; \
+                    uint32_t* TriceBufferWritePosition = triceSingleBufferStartWritePosition;
+
+#endif // #if TRICE_BUFFER == TRICE_STACK_BUFFER
+
+#if TRICE_BUFFER == TRICE_STATIC_BUFFER
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                \
+            TRICE_ENTER_CRITICAL_SECTION { \
+                {                          \
+                    uint32_t* TriceBufferWritePosition = triceSingleBufferStartWritePosition;
+
+#endif // #if TRICE_BUFFER == TRICE_STATIC_BUFFER
+
+#if (TRICE_BUFFER == TRICE_DOUBLE_BUFFER) && (TRICE_DIRECT_OUTPUT == 1)
+
+#if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                \
+                TRICE_ENTER_CRITICAL_SECTION { \
+                    if (TriceEnoughSpace()) {  \
+                        uint32_t* const triceSingleBufferStartWritePosition = TriceBufferWritePosition;
+
+#else //  #if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                \
+                TRICE_ENTER_CRITICAL_SECTION { \
+                    {                          \
+                        uint32_t* const triceSingleBufferStartWritePosition = TriceBufferWritePosition;
+
+#endif // #else //  #if TRICE_PROTECT == 1
+
+#endif // #if (TRICE_BUFFER == TRICE_DOUBLE_BUFFER) && (TRICE_DIRECT_OUTPUT == 1)
+
+#if (TRICE_BUFFER == TRICE_DOUBLE_BUFFER) && (TRICE_DIRECT_OUTPUT == 0)
+
+#if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                \
+                TRICE_ENTER_CRITICAL_SECTION { \
+                    if (TriceEnoughSpace()) {  \
+                        TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START
+
+#else //  #if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                \
+                TRICE_ENTER_CRITICAL_SECTION { \
+                    {                          \
+                        TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START
+
+#endif // #else //  #if TRICE_PROTECT == 1
+
+#endif // #if (TRICE_BUFFER == TRICE_DOUBLE_BUFFER) && (TRICE_DIRECT_OUTPUT == 0)
+
+#if (TRICE_BUFFER == TRICE_RING_BUFFER) && (TRICE_DIRECT_OUTPUT == 1)
+
+#if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                                                                                                                                                     \
+                TRICE_ENTER_CRITICAL_SECTION {                                                                                                                                      \
+                /* The TriceBufferWritePosition stays unchanged, when there is enough space for the next trice at the current write position.*/                                 \
+                /* Because the the size of the next trice message is unknown here, the biggest value is assumed, that is TRICE_SINGLE_MAX_SIZE bytes. */                        \
+                /* If this space is not given anymore, the `TriceBufferWritePosition` is reset to the start address of the ring buffer. */                                      \
+                TriceBufferWritePosition = TriceBufferWritePosition <= TriceRingBufferProtectLimit ? TriceBufferWritePosition : TriceRingBufferStart; \
+                if (TriceEnoughSpace()) {                                                                                                                                           \
+                    uint32_t* const triceSingleBufferStartWritePosition = TriceBufferWritePosition;                                                                             \
+                    TricesCountRingBuffer++; // Because TRICE macros are an atomic instruction normally, this can be done here.
+
+#else //  #if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                                                                                                                                                     \
+                TRICE_ENTER_CRITICAL_SECTION {                                                                                                                                      \
+                    {                                                                                                                                                               \
+                        /* The TriceBufferWritePosition stays unchanged, when there is enough space for the next trice at the current write position.*/                             \
+                        /* Because the the size of the next trice message is unknown here, the biggest value is assumed, that is TRICE_BUFFER_SIZE bytes. */                        \
+                        /* If this space is not given anymore, the `TriceBufferWritePosition` is reset to the start address of the ring buffer. */                                  \
+                        /* This implementation is a bit different than a ring buffer is usually implemented. */                                                                     \
+                        TriceBufferWritePosition = TriceBufferWritePosition <= TriceRingBufferProtectLimit ? TriceBufferWritePosition : TriceRingBufferStart; \
+                        uint32_t* const triceSingleBufferStartWritePosition = TriceBufferWritePosition;                                                                             \
+                        TricesCountRingBuffer++; // Because TRICE macros are an atomic instruction normally, this can be done here.
+
+#endif // #else //  #if TRICE_PROTECT == 1
+
+#endif // #if TRICE_BUFFER == TRICE_RING_BUFFER && (TRICE_DIRECT_OUTPUT == 1)
+
+#if (TRICE_BUFFER == TRICE_RING_BUFFER) && (TRICE_DIRECT_OUTPUT == 0)
+
+#if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                                                                                                                                                     \
+                TRICE_ENTER_CRITICAL_SECTION {                                                                                                                                      \
+                    TriceBufferWritePosition = TriceBufferWritePosition <= TriceRingBufferProtectLimit ? TriceBufferWritePosition : TriceRingBufferStart; \
+                    if (TriceEnoughSpace()) {                                                                                                                                       \
+                        TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START                                                                                                                  \
+                        TricesCountRingBuffer++; // Because TRICE macros are an atomic instruction normally, this can be done here.
+
+#else //  #if TRICE_PROTECT == 1
+
+//! TRICE_ENTER is the start of TRICE macro.
+#define TRICE_ENTER                                                                                                                                                     \
+                TRICE_ENTER_CRITICAL_SECTION {                                                                                                                                      \
+                    {                                                                                                                                                               \
+                        TriceBufferWritePosition = TriceBufferWritePosition <= TriceRingBufferProtectLimit ? TriceBufferWritePosition : TriceRingBufferStart; \
+                        TRICE_DIAGNOSTICS_SINGLE_BUFFER_KEEP_START                                                                                                                  \
+                        TricesCountRingBuffer++; // Because TRICE macros are an atomic instruction normally, this can be done here.
+
+#endif // #else //  #if TRICE_PROTECT == 1
+
+#endif // #if TRICE_BUFFER == TRICE_RING_BUFFER && (TRICE_DIRECT_OUTPUT == 0)
+
+#endif // #ifndef TRICE_ENTER
+
+#ifndef TRICE_LEAVE
+
+#if TRICE_DIRECT_OUTPUT == 1
+
+//! TRICE_LEAVE is the end of TRICE macro. It is the same for all buffer variants.
+#define TRICE_LEAVE                                                                                          \
+            /* wordCount is the amount of steps, the TriceBufferWritePosition went forward for the actual trice.  */ \
+            /* The last written uint32_t trice value can contain 1 to 3 padding bytes. */                            \
+            unsigned wordCount = TriceBufferWritePosition - triceSingleBufferStartWritePosition;                     \
+            TRICE_DIAGNOSTICS_SINGLE_BUFFER_USING_WORD_COUNT                                                         \
+            TriceNonBlockingDirectWrite(triceSingleBufferStartWritePosition, wordCount);                             \
+            }                                                                                                        \
+            }                                                                                                        \
+            TRICE_LEAVE_CRITICAL_SECTION
+
+#else // #if TRICE_DIRECT_OUTPUT == 1
+
+//! TRICE_LEAVE is the end of TRICE macro. It is the same for all buffer variants.
+#define TRICE_LEAVE                 \
+            TRICE_DIAGNOSTICS_SINGLE_BUFFER \
+            }                               \
+            }                               \
+            TRICE_LEAVE_CRITICAL_SECTION
+
+#endif // #else  //#if TRICE_DIRECT_OUTPUT == 1
+
+#endif // #ifndef TRICE_LEAVE
+
+#ifndef TRICE_PUT
+
+//! TRICE_PUT writes x as 32-bit value into the Trice buffer without changing the endianness.
+//! This macro does not use internally TRICE_HTOTL and therefore it is usable without speed loss, when TRICE_REVERSE == 1.
+//! In that case the byte order needs to be provided by the written code.
+#define TRICE_PUT(x)              \
+    do {                                 \
+        *TriceBufferWritePosition++ = x; \
+    } while (0);
+
+#endif
+
+#ifndef TRICE_PUT_BUFFER
+
+//! TRICE_PUT_BUFFER copies a buffer into the TRICE buffer.
+#define TRICE_PUT_BUFFER(buf, len)                                                               \
+        do {                                                                                         \
+            memcpy(TriceBufferWritePosition, buf, len);                                              \
+            unsigned len4 = ((unsigned)len + 3) & ~3;                                                \
+            memset((uint8_t*)TriceBufferWritePosition + len, 0, len4 - len); /*clear padding space*/ \
+            TriceBufferWritePosition += len4 >> 2;                                                   \
+        } while (0)
+
+#endif
+
+// clang-format on
+
+///////////////////////////////////////////////////////////////////////////////
+// TRICE macros
+//
+
+#define TRICE_0 TRICE0 //!< Only the format string without parameter values.
+#define TRice_0 TRice0 //!< Only the format string without parameter values.
+#define Trice_0 Trice0 //!< Only the format string without parameter values.
+#define trice_0 trice0 //!< Only the format string without parameter values.
+
+#ifndef TRICE_N
+
+//! TRICE_N writes id and buffer of size len.
+//! \param tid trice identifier
+//! \param pFmt formatstring for trice (ignored here but used by the trice tool), could contain any add on information. The trice tool "sees" the "TRICE_N" and can handle that.
+//! \param dynString 0-terminated runtime generated string
+//!     After the 4 byte trice message header are following 4 bytes coding n (only 2 used) and the buffer
+//!     transfer format:
+//!     idH    idL    len    cycle <- trice header
+//!     n0     n1     n2     n3    <- payload count without paddings bytes (transmittable len)
+//!     c0     c1     c2     c3    <- buffer
+//!     ...                        <- buffer
+//!     cLen-3 cLen-2 cLen-1 cLen  <- buffer ending with maybe 1-3 undetermined padding bytes
+//!
+//! todo: for some reason this macro is not working well wit name len instead of len_, probably when injected len as value.
+//!
+#define TRICE_N(tid, pFmt, buf, n)                                                                                                   \
+    do {                                                                                                                             \
+        TRICE_UNUSED(pFmt);                                                                                                          \
+        uint32_t limit = TRICE_SINGLE_MAX_SIZE - 12; /* 12 = head(2) + max timestamp size(4) + count(2) + max 3 zeroes, we take 4 */ \
+        uint32_t len_ = n;                           /* n could be a constant */                                                     \
+        if (len_ > limit) {                                                                                                          \
+            TRICE_DYN_STRG_BUF_TRUNCATE_COUNT_INCREMENT();                                                                                \
+            len_ = limit;                                                                                                            \
+        }                                                                                                                            \
+        TRICE_ENTER tid;                                                                                                             \
+        if (len_ <= 127) {                                                                                                           \
+            TRICE_CNTC(len_);                                                                                                        \
+        } else {                                                                                                                     \
+            TRICE_LCNT(len_);                                                                                                        \
+        }                                                                                                                            \
+        TRICE_PUT_BUFFER(buf, len_);                                                                                                 \
+        TRICE_LEAVE                                                                                                                  \
+    } while (0)
+
+void triceN(int tid, char* fmt, void* buf, uint32_t n);
+void TriceN(int tid, char* fmt, void* buf, uint32_t n);
+void TRiceN(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice8B(int tid, char* fmt, void* buf, uint32_t n);
+void Trice8B(int tid, char* fmt, void* buf, uint32_t n);
+void TRice8B(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice16B(int tid, char* fmt, void* buf, uint32_t n);
+void Trice16B(int tid, char* fmt, void* buf, uint32_t n);
+void TRice16B(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice32B(int tid, char* fmt, void* buf, uint32_t n);
+void Trice32B(int tid, char* fmt, void* buf, uint32_t n);
+void TRice32B(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice64B(int tid, char* fmt, void* buf, uint32_t n);
+void Trice64B(int tid, char* fmt, void* buf, uint32_t n);
+void TRice64B(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice8F(int tid, char* fmt, void* buf, uint32_t n);
+void Trice8F(int tid, char* fmt, void* buf, uint32_t n);
+void TRice8F(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice16F(int tid, char* fmt, void* buf, uint32_t n);
+void Trice16F(int tid, char* fmt, void* buf, uint32_t n);
+void TRice16F(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice32F(int tid, char* fmt, void* buf, uint32_t n);
+void Trice32F(int tid, char* fmt, void* buf, uint32_t n);
+void TRice32F(int tid, char* fmt, void* buf, uint32_t n);
+
+void trice64F(int tid, char* fmt, void* buf, uint32_t n);
+void Trice64F(int tid, char* fmt, void* buf, uint32_t n);
+void TRice64F(int tid, char* fmt, void* buf, uint32_t n);
+
+#endif // #ifndef TRICE_N
+
+#ifndef TRICE_S
+
+//! TRICE_S writes id and runtimeGeneratedString.
+//! \param tid trice identifier
+//! \param pFmt format string for trice (ignored here but used by the trice tool)
+//! \param runtimeGeneratedString 0-terminated runtime generated string
+#define TRICE_S(tid, pFmt, runtimeGeneratedString)        \
+    do {                                                  \
+        uint32_t ssiz = strlen(runtimeGeneratedString);   \
+        TRICE_N(tid, pFmt, runtimeGeneratedString, ssiz); \
+    } while (0)
+
+void triceS(int tid, char* fmt, char* runtimeGeneratedString);
+void TriceS(int tid, char* fmt, char* runtimeGeneratedString);
+void TRiceS(int tid, char* fmt, char* runtimeGeneratedString);
+
+#endif // #ifndef TRICE_S
+
+//! ID writes 14-bit id with 11 as 2 most significant bits, followed by a 32-bit stamp.
+//! 11iiiiiiI TT | TT (NC) | ...
+//! C000 = 1100 0000 0000 0000
+#define ID(n)                                 \
+    do {                                      \
+        uint32_t ts = TriceStamp32;           \
+        TRICE_PUT16_1616((0xC000 | (n)), ts); \
+    } while (0)
+
+//! Id writes 14-bit id with 10 as 2 most significant bits two times, followed by a 16-bit stamp.
+//! 10iiiiiiI 10iiiiiiI | TT (NC) | ...
+//! 8000 = 1000 0000 0000 0000
+#define Id(n)                                                   \
+    do {                                                        \
+        uint16_t ts = TriceStamp16;                             \
+        TRICE_PUT(TRICE_HTOTL(0x80008000 | ((n) << 16) | (n))); \
+        TRICE_PUT16(ts);                                        \
+    } while (0)
+
+//! id writes 14-bit id with 01 as 2 most significant bits, followed by no stamp.
+//! 01iiiiiiI (NC) | ...
+//! 4000 = 0100 0000 0000 0000
+#define id(n) TRICE_PUT16(0x4000 | (n));
+
+//! iD is just a code parsing helper.
+#define iD(n) (n)
+
+//! TRICE_CNTC writes 7-bit byte count and 8-bit cycle counter.
+#define TRICE_CNTC(count)                          \
+    do {                                           \
+        uint16_t v = ((count) << 8) | TRICE_CYCLE; \
+        TRICE_PUT16(v);                            \
+    } while (0)
+
+#if TRICE_CYCLE_COUNTER == 1
+
+//! TRICE_LCNT writes 1 as most significant bit and 15-bit byte count. It does not write the cycle counter but increments the cycle counter.
+#define TRICE_LCNT(count)            \
+    TRICE_PUT16((0x8000 | (count))); \
+    TRICE_CYCLE // increment TRICE_CYCLE but do not transmit it
+
+#else
+
+//! TRICE_LCNT writes 1 as most significant bit and 15-bit byte count. It does not write the cycle counter but increments the cycle counter.
+#define TRICE_LCNT(count) TRICE_PUT16((0x8000 | (count))); // no TRICE_CYCLE
+
+#endif
+
+//! TRICE0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define TRICE0(tid, pFmt) \
+    TRICE_ENTER tid;      \
+    TRICE_CNTC(0);        \
+    TRICE_LEAVE
+
+TRICE_INLINE void trice0(uint16_t tid, const char* pFmt)
+{
+    trice32m_0(tid);
+    TRICE_UNUSED(pFmt)
+}
+
+TRICE_INLINE void Trice0(uint16_t tid, const char *pFmt)
+{
+    Trice32m_0(tid);
+    TRICE_UNUSED(pFmt)
+}
+
+TRICE_INLINE void TRice0(uint16_t tid, const char *pFmt)
+{
+    TRice32m_0(tid);
+    TRICE_UNUSED(pFmt)
+}
+
+void triceAssertTrue(int idN, char *msg, int flag);
+void TriceAssertTrue(int idN, char *msg, int flag);
+void TRiceAssertTrue(int idN, char *msg, int flag);
+
+void triceAssertFalse(int idN, char *msg, int flag);
+void TriceAssertFalse(int idN, char *msg, int flag);
+void TRiceAssertFalse(int idN, char *msg, int flag);
+
+typedef void (*Write8AuxiliaryFn_t)(const uint8_t *enc, size_t encLen);
+extern Write8AuxiliaryFn_t UserNonBlockingDirectWrite8AuxiliaryFn;
+extern Write8AuxiliaryFn_t UserNonBlockingDeferredWrite8AuxiliaryFn;
+
+typedef void (*Write32AuxiliaryFn_t)(const uint32_t *enc, unsigned count);
+extern Write32AuxiliaryFn_t UserNonBlockingDirectWrite32AuxiliaryFn;
+extern Write32AuxiliaryFn_t UserNonBlockingDeferredWrite32AuxiliaryFn;
+
+/**/
+/**/
+/***************************************************************************************************/
+#endif // #else // #if ((defined(TRICE_OFF) && TRICE_OFF == 1)) || ((defined(TRICE_CLEAN) && TRICE_CLEAN == 1))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TRICE_H_

Middlewares/trice/trice16.c

@@ -0,0 +1,560 @@
+//! \file trice16.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//! ///////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+// lint -e529  Warning 529: Symbol '_SEGGER_RTT__LockState' not subsequently referenced
+// lint -e701  Info 701: Shift left of signed quantity (int)
+
+#if TRICE_16_BIT_SUPPORT == 1 && TRICE_OFF == 0
+
+// no-stamp 16-bit values functions
+#ifndef ENABLE_trice16fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 0 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_0 0 //!< Disables no-stamp 16-bit 0 values functions.
+#else
+#define ENABLE_trice16fn_0 1 //!< Enables  no-stamp 16-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 1 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_1 0 //!< Disables no-stamp 16-bit 1 values functions.
+#else
+#define ENABLE_trice16fn_1 1 //!< Enables  no-stamp 16-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 2 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_2 0 //!< Disables no-stamp 16-bit 2 values functions.
+#else
+#define ENABLE_trice16fn_2 1 //!< Enables  no-stamp 16-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 3 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_3 0 //!< Disables no-stamp 16-bit 3 values functions.
+#else
+#define ENABLE_trice16fn_3 1 //!< Enables  no-stamp 16-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 4 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_4 0 //!< Disables no-stamp 16-bit 4 values functions.
+#else
+#define ENABLE_trice16fn_4 1 //!< Enables  no-stamp 16-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 5 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_5 0 //!< Disables no-stamp 16-bit 5 values functions.
+#else
+#define ENABLE_trice16fn_5 1 //!< Enables  no-stamp 16-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 6 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_6 0 //!< Disables no-stamp 16-bit 6 values functions.
+#else
+#define ENABLE_trice16fn_6 1 //!< Enables  no-stamp 16-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 7 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_7 0 //!< Disables no-stamp 16-bit 7 values functions.
+#else
+#define ENABLE_trice16fn_7 1 //!< Enables  no-stamp 16-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 8 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_8 0 //!< Disables no-stamp 16-bit 8 values functions.
+#else
+#define ENABLE_trice16fn_8 1 //!< Enables  no-stamp 16-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 9 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_9 0 //!< Disables no-stamp 16-bit 9 values functions.
+#else
+#define ENABLE_trice16fn_9 1 //!< Enables  no-stamp 16-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 10 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_10 0 //!< Disables no-stamp 16-bit 10 values functions.
+#else
+#define ENABLE_trice16fn_10 1 //!< Enables  no-stamp 16-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 11 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_11 0 //!< Disables no-stamp 16-bit 11 values functions.
+#else
+#define ENABLE_trice16fn_11 1 //!< Enables  no-stamp 16-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice16fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 12 * 2) + 3) & ~3)
+#define ENABLE_trice16fn_12 0 //!< Disables no-stamp 16-bit 12 values functions.
+#else
+#define ENABLE_trice16fn_12 1 //!< Enables  no-stamp 16-bit 12 values functions.
+#endif
+#endif
+
+// with 16-bit-stamp 16-bit values functions (16-bit-stamps need 4 bytes for allocation reasons)
+#ifndef ENABLE_Trice16fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_0 0 //!< Disables 16-bit-stamp 16-bit 0 values functions.
+#else
+#define ENABLE_Trice16fn_0 1 //!< Enables  16-bit-stamp 16-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_1 0 //!< Disables 16-bit-stamp 16-bit 1 values functions.
+#else
+#define ENABLE_Trice16fn_1 1 //!< Enables  16-bit-stamp 16-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_2 0 //!< Disables 16-bit-stamp 16-bit 2 values functions.
+#else
+#define ENABLE_Trice16fn_2 1 //!< Enables  16-bit-stamp 16-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_3 0 //!< Disables 16-bit-stamp 16-bit 3 values functions.
+#else
+#define ENABLE_Trice16fn_3 1 //!< Enables  16-bit-stamp 16-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_4 0 //!< Disables 16-bit-stamp 16-bit 4 values functions.
+#else
+#define ENABLE_Trice16fn_4 1 //!< Enables  16-bit-stamp 16-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_5 0 //!< Disables 16-bit-stamp 16-bit 5 values functions.
+#else
+#define ENABLE_Trice16fn_5 1 //!< Enables  16-bit-stamp 16-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_6 0 //!< Disables 16-bit-stamp 16-bit 6 values functions.
+#else
+#define ENABLE_Trice16fn_6 1 //!< Enables  16-bit-stamp 16-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_7 0 //!< Disables 16-bit-stamp 16-bit 7 values functions.
+#else
+#define ENABLE_Trice16fn_7 1 //!< Enables  16-bit-stamp 16-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_8 0 //!< Disables 16-bit-stamp 16-bit 8 values functions.
+#else
+#define ENABLE_Trice16fn_8 1 //!< Enables  16-bit-stamp 16-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_9 0 //!< Disables 16-bit-stamp 16-bit 9 values functions.
+#else
+#define ENABLE_Trice16fn_9 1 //!< Enables  16-bit-stamp 16-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_10 0 //!< Disables 16-bit-stamp 16-bit 10 values functions.
+#else
+#define ENABLE_Trice16fn_10 1 //!< Enables  16-bit-stamp 16-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_11 0 //!< Disables 16-bit-stamp 16-bit 11 values functions.
+#else
+#define ENABLE_Trice16fn_11 1 //!< Enables  16-bit-stamp 16-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice16fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 2) + 3) & ~3)
+#define ENABLE_Trice16fn_12 0 //!< Disables 16-bit-stamp 16-bit 12 values functions.
+#else
+#define ENABLE_Trice16fn_12 1 //!< Enables  16-bit-stamp 16-bit 12 values functions.
+#endif
+#endif
+
+// with 32-bit-stamp 16-bit values functions
+#ifndef ENABLE_TRice16fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_0 0 //!< Disables 32-bit-stamp 16-bit 0 values functions.
+#else
+#define ENABLE_TRice16fn_0 1 //!< Enables  32-bit-stamp 16-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_1 0 //!< Disables 32-bit-stamp 16-bit 1 values functions.
+#else
+#define ENABLE_TRice16fn_1 1 //!< Enables  32-bit-stamp 16-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_2 0 //!< Disables 32-bit-stamp 16-bit 2 values functions.
+#else
+#define ENABLE_TRice16fn_2 1 //!< Enables  32-bit-stamp 16-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_3 0 //!< Disables 32-bit-stamp 16-bit 3 values functions.
+#else
+#define ENABLE_TRice16fn_3 1 //!< Enables  32-bit-stamp 16-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_4 0 //!< Disables 32-bit-stamp 16-bit 4 values functions.
+#else
+#define ENABLE_TRice16fn_4 1 //!< Enables  32-bit-stamp 16-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_5 0 //!< Disables 32-bit-stamp 16-bit 5 values functions.
+#else
+#define ENABLE_TRice16fn_5 1 //!< Enables  32-bit-stamp 16-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_6 0 //!< Disables 32-bit-stamp 16-bit 6 values functions.
+#else
+#define ENABLE_TRice16fn_6 1 //!< Enables  32-bit-stamp 16-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_7 0 //!< Disables 32-bit-stamp 16-bit 7 values functions.
+#else
+#define ENABLE_TRice16fn_7 1 //!< Enables  32-bit-stamp 16-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_8 0 //!< Disables 32-bit-stamp 16-bit 8 values functions.
+#else
+#define ENABLE_TRice16fn_8 1 //!< Enables  32-bit-stamp 16-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_9 0 //!< Disables 32-bit-stamp 16-bit 9 values functions.
+#else
+#define ENABLE_TRice16fn_9 1 //!< Enables  32-bit-stamp 16-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_10 0 //!< Disables 32-bit-stamp 16-bit 10 values functions.
+#else
+#define ENABLE_TRice16fn_10 1 //!< Enables  32-bit-stamp 16-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_11 0 //!< Disables 32-bit-stamp 16-bit 11 values functions.
+#else
+#define ENABLE_TRice16fn_11 1 //!< Enables  32-bit-stamp 16-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice16fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 2) + 3) & ~3)
+#define ENABLE_TRice16fn_12 0 //!< Disables 32-bit-stamp 16-bit 12 values functions.
+#else
+#define ENABLE_TRice16fn_12 1 //!< Enables  32-bit-stamp 16-bit 12 values functions.
+#endif
+#endif
+
+#if ENABLE_trice16fn_0
+void trice16fn_0(uint16_t tid) {
+	trice16m_0(tid);
+}
+#endif
+
+#if ENABLE_trice16fn_1
+void trice16fn_1(uint16_t tid, uint16_t v0) {
+	trice16m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_trice16fn_2
+void trice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1) {
+	trice16m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_trice16fn_3
+void trice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2) {
+	trice16m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_trice16fn_4
+void trice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3) {
+	trice16m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_trice16fn_5
+void trice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4) {
+	trice16m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_trice16fn_6
+void trice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5) {
+	trice16m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_trice16fn_7
+void trice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6) {
+	trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_trice16fn_8
+void trice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7) {
+	trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_trice16fn_9
+void trice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8) {
+	trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_trice16fn_10
+void trice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9) {
+	trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_trice16fn_11
+void trice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10) {
+	trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_trice16fn_12
+void trice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11) {
+	trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_Trice16fn_0
+void Trice16fn_0(uint16_t tid) {
+	Trice16m_0(tid);
+}
+#endif
+
+#if ENABLE_Trice16fn_1
+void Trice16fn_1(uint16_t tid, uint16_t v0) {
+	Trice16m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_Trice16fn_2
+void Trice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1) {
+	Trice16m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_Trice16fn_3
+void Trice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2) {
+	Trice16m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_Trice16fn_4
+void Trice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3) {
+	Trice16m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_Trice16fn_5
+void Trice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4) {
+	Trice16m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_Trice16fn_6
+void Trice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5) {
+	Trice16m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_Trice16fn_7
+void Trice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6) {
+	Trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_Trice16fn_8
+void Trice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7) {
+	Trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_Trice16fn_9
+void Trice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8) {
+	Trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_Trice16fn_10
+void Trice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9) {
+	Trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_Trice16fn_11
+void Trice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10) {
+	Trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_Trice16fn_12
+void Trice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11) {
+	Trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_TRice16fn_0
+void TRice16fn_0(uint16_t tid) {
+	TRice16m_0(tid);
+}
+#endif
+
+#if ENABLE_TRice16fn_1
+void TRice16fn_1(uint16_t tid, uint16_t v0) {
+	TRice16m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_TRice16fn_2
+void TRice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1) {
+	TRice16m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_TRice16fn_3
+void TRice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2) {
+	TRice16m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_TRice16fn_4
+void TRice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3) {
+	TRice16m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_TRice16fn_5
+void TRice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4) {
+	TRice16m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_TRice16fn_6
+void TRice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5) {
+	TRice16m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_TRice16fn_7
+void TRice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6) {
+	TRice16m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_TRice16fn_8
+void TRice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7) {
+	TRice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_TRice16fn_9
+void TRice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8) {
+	TRice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_TRice16fn_10
+void TRice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9) {
+	TRice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_TRice16fn_11
+void TRice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10) {
+	TRice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_TRice16fn_12
+void TRice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11) {
+	TRice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#endif // #if TRICE_16_BIT_SUPPORT == 1 && TRICE_OFF == 0

Middlewares/trice/trice16.h

@@ -0,0 +1,265 @@
+/*! \file internalTrice16.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 16
+
+// #define TRICE_0  TRICE16_0  //!< Default parameter bit width for 0  parameter count TRICE is 16.
+#define TRICE_1 TRICE16_1   //!< Default parameter bit width for 1  parameter count TRICE is 16.
+#define TRICE_2 TRICE16_2   //!< Default parameter bit width for 2  parameter count TRICE is 16.
+#define TRICE_3 TRICE16_3   //!< Default parameter bit width for 3  parameter count TRICE is 16.
+#define TRICE_4 TRICE16_4   //!< Default parameter bit width for 4  parameter count TRICE is 16.
+#define TRICE_5 TRICE16_5   //!< Default parameter bit width for 5  parameter count TRICE is 16.
+#define TRICE_6 TRICE16_6   //!< Default parameter bit width for 6  parameter count TRICE is 16.
+#define TRICE_7 TRICE16_7   //!< Default parameter bit width for 7  parameter count TRICE is 16.
+#define TRICE_8 TRICE16_8   //!< Default parameter bit width for 8  parameter count TRICE is 16.
+#define TRICE_9 TRICE16_9   //!< Default parameter bit width for 9  parameter count TRICE is 16.
+#define TRICE_10 TRICE16_10 //!< Default parameter bit width for 10 parameter count TRICE is 16.
+#define TRICE_11 TRICE16_11 //!< Default parameter bit width for 11 parameter count TRICE is 16.
+#define TRICE_12 TRICE16_12 //!< Default parameter bit width for 12 parameter count TRICE is 16.
+
+// #define trice_0  trice16_0  //!< Default parameter bit width for 0  parameter count trice is 16.
+#define trice_1 trice16_1   //!< Default parameter bit width for 1  parameter count trice is 16.
+#define trice_2 trice16_2   //!< Default parameter bit width for 2  parameter count trice is 16.
+#define trice_3 trice16_3   //!< Default parameter bit width for 3  parameter count trice is 16.
+#define trice_4 trice16_4   //!< Default parameter bit width for 4  parameter count trice is 16.
+#define trice_5 trice16_5   //!< Default parameter bit width for 5  parameter count trice is 16.
+#define trice_6 trice16_6   //!< Default parameter bit width for 6  parameter count trice is 16.
+#define trice_7 trice16_7   //!< Default parameter bit width for 7  parameter count trice is 16.
+#define trice_8 trice16_8   //!< Default parameter bit width for 8  parameter count trice is 16.
+#define trice_9 trice16_9   //!< Default parameter bit width for 9  parameter count trice is 16.
+#define trice_10 trice16_10 //!< Default parameter bit width for 10 parameter count trice is 16.
+#define trice_11 trice16_11 //!< Default parameter bit width for 11 parameter count trice is 16.
+#define trice_12 trice16_12 //!< Default parameter bit width for 12 parameter count trice is 16.
+
+// #define Trice_0  Trice16_0  //!< Default parameter bit width for 0  parameter count Trice is 16.
+#define Trice_1 Trice16_1   //!< Default parameter bit width for 1  parameter count Trice is 16.
+#define Trice_2 Trice16_2   //!< Default parameter bit width for 2  parameter count Trice is 16.
+#define Trice_3 Trice16_3   //!< Default parameter bit width for 3  parameter count Trice is 16.
+#define Trice_4 Trice16_4   //!< Default parameter bit width for 4  parameter count Trice is 16.
+#define Trice_5 Trice16_5   //!< Default parameter bit width for 5  parameter count Trice is 16.
+#define Trice_6 Trice16_6   //!< Default parameter bit width for 6  parameter count Trice is 16.
+#define Trice_7 Trice16_7   //!< Default parameter bit width for 7  parameter count Trice is 16.
+#define Trice_8 Trice16_8   //!< Default parameter bit width for 8  parameter count Trice is 16.
+#define Trice_9 Trice16_9   //!< Default parameter bit width for 9  parameter count Trice is 16.
+#define Trice_10 Trice16_10 //!< Default parameter bit width for 10 parameter count Trice is 16.
+#define Trice_11 Trice16_11 //!< Default parameter bit width for 11 parameter count Trice is 16.
+#define Trice_12 Trice16_12 //!< Default parameter bit width for 12 parameter count Trice is 16.
+
+// #define TRice_0  TRice16_0  //!< Default parameter bit width for 0  parameter count TRice is 16.
+#define TRice_1 TRice16_1   //!< Default parameter bit width for 1  parameter count TRice is 16.
+#define TRice_2 TRice16_2   //!< Default parameter bit width for 2  parameter count TRice is 16.
+#define TRice_3 TRice16_3   //!< Default parameter bit width for 3  parameter count TRice is 16.
+#define TRice_4 TRice16_4   //!< Default parameter bit width for 4  parameter count TRice is 16.
+#define TRice_5 TRice16_5   //!< Default parameter bit width for 5  parameter count TRice is 16.
+#define TRice_6 TRice16_6   //!< Default parameter bit width for 6  parameter count TRice is 16.
+#define TRice_7 TRice16_7   //!< Default parameter bit width for 7  parameter count TRice is 16.
+#define TRice_8 TRice16_8   //!< Default parameter bit width for 8  parameter count TRice is 16.
+#define TRice_9 TRice16_9   //!< Default parameter bit width for 9  parameter count TRice is 16.
+#define TRice_10 TRice16_10 //!< Default parameter bit width for 10 parameter count TRice is 16.
+#define TRice_11 TRice16_11 //!< Default parameter bit width for 11 parameter count TRice is 16.
+#define TRice_12 TRice16_12 //!< Default parameter bit width for 12 parameter count TRice is 16.
+
+#endif // #if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 16
+
+#define TRICE_SHORT0(v) TRICE_HTOTS((uint16_t)(v))                   //!< TRICE_SHORT0(v) is the 16-bit value v moved to the LLLL position in a 32-bit value 0xHHHH_LLLL.
+#define TRICE_SHORT1(v) ((uint32_t)TRICE_HTOTS((uint16_t)(v)) << 16) //!< TRICE_SHORT1(v) is the 16-bit value v moved to the HHHH position in a 32-bit value 0xHHHH_LLLL.
+
+#define TRICE16(tid, fmt, ...) TRICE_CONCAT2(TRICE16_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+
+//! TRICE16_B expects inside pFmt only one format specifier, which is used n times by using pFmt n times.
+//!  It is usable for showing n 16-bit values.
+#define TRICE16_B(id, pFmt, buf, n)    \
+	do {                               \
+		TRICE_N(id, pFmt, buf, 2 * n); \
+	} while (0)
+
+//! TRICE16_F expects inside pFmt just a string which is assumed to be a remote function name.
+//!  The trice tool displays the pFmt string followed by n times (16-bit value i).
+//!  The idea behind is to generate an id - function pointer referece list from the generated til.json file to
+//!  compile it into a remote device and execute the inside pFmt named function remotely.
+//!  Look for "TRICE16_F example" inside triceCheck.c.
+#define TRICE16_F TRICE16_B
+
+#define TRICE_PUT16_1(v0) TRICE_PUT(TRICE_SHORT0(v0));
+
+#define TRICE_PUT16_2(v0, v1) TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));
+
+#define TRICE_PUT16_3(v0, v1, v2)                   \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1)); \
+	TRICE_PUT(TRICE_SHORT0(v2));
+
+#define TRICE_PUT16_4(v0, v1, v2, v3)               \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1)); \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));
+
+#define TRICE_PUT16_5(v0, v1, v2, v3, v4)           \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1)); \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3)); \
+	TRICE_PUT(TRICE_SHORT0(v4));
+
+#define TRICE_PUT16_6(v0, v1, v2, v3, v4, v5)       \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1)); \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3)); \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));
+
+#define TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6)   \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1)); \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3)); \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5)); \
+	TRICE_PUT(TRICE_SHORT0(v6));
+
+#define TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));   \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));   \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));   \
+	TRICE_PUT(TRICE_SHORT0(v6) | TRICE_SHORT1(v7));
+
+#define TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));       \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));       \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));       \
+	TRICE_PUT(TRICE_SHORT0(v6) | TRICE_SHORT1(v7));       \
+	TRICE_PUT(TRICE_SHORT0(v8));
+
+#define TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));            \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));            \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));            \
+	TRICE_PUT(TRICE_SHORT0(v6) | TRICE_SHORT1(v7));            \
+	TRICE_PUT(TRICE_SHORT0(v8) | TRICE_SHORT1(v9));
+
+#define TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));                 \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));                 \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));                 \
+	TRICE_PUT(TRICE_SHORT0(v6) | TRICE_SHORT1(v7));                 \
+	TRICE_PUT(TRICE_SHORT0(v8) | TRICE_SHORT1(v9));                 \
+	TRICE_PUT(TRICE_SHORT0(v10));
+
+#define TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_PUT(TRICE_SHORT0(v0) | TRICE_SHORT1(v1));                      \
+	TRICE_PUT(TRICE_SHORT0(v2) | TRICE_SHORT1(v3));                      \
+	TRICE_PUT(TRICE_SHORT0(v4) | TRICE_SHORT1(v5));                      \
+	TRICE_PUT(TRICE_SHORT0(v6) | TRICE_SHORT1(v7));                      \
+	TRICE_PUT(TRICE_SHORT0(v8) | TRICE_SHORT1(v9));                      \
+	TRICE_PUT(TRICE_SHORT0(v10) | TRICE_SHORT1(v11));
+
+// The following `TRICE` macro definitions uses the C preprocess to concatenate the code behind the sub-macros.
+// The sequence `tid` in this context is executable code `id(n)`, `Id(n)` or `ID(n)` defined in trice.h.
+// This works only with tid=`id(n)`, `Id(n)`, `ID(n)`.
+
+//! TRICE16_0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define TRICE16_0(tid, pFmt) \
+	TRICE_ENTER tid;         \
+	TRICE_CNTC(0);           \
+	TRICE_LEAVE
+
+//! TRICE16_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 16 bit value
+#define TRICE16_1(tid, pFmt, v0) \
+	TRICE_ENTER tid;             \
+	TRICE_CNTC(2);               \
+	TRICE_PUT16_1(v0)            \
+	TRICE_LEAVE
+
+//! TRICE16_2 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v1 are 16 bit values
+#define TRICE16_2(id, pFmt, v0, v1) \
+	TRICE_ENTER id;                 \
+	TRICE_CNTC(4);                  \
+	TRICE_PUT16_2(v0, v1);          \
+	TRICE_LEAVE
+
+//! TRICE16_3 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v2 are 16 bit values
+#define TRICE16_3(id, pFmt, v0, v1, v2) \
+	TRICE_ENTER id;                     \
+	TRICE_CNTC(6);                      \
+	TRICE_PUT16_3(v0, v1, v2);          \
+	TRICE_LEAVE
+
+//! TRICE16_4 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v3 are 16 bit values
+#define TRICE16_4(id, pFmt, v0, v1, v2, v3) \
+	TRICE_ENTER id;                         \
+	TRICE_CNTC(8);                          \
+	TRICE_PUT16_4(v0, v1, v2, v3);          \
+	TRICE_LEAVE
+
+//! TRICE16_5 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v4 are 16 bit values
+#define TRICE16_5(id, pFmt, v0, v1, v2, v3, v4) \
+	TRICE_ENTER id;                             \
+	TRICE_CNTC(10);                             \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);          \
+	TRICE_LEAVE
+
+//! TRICE16_6 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v5 are 16 bit values
+#define TRICE16_6(id, pFmt, v0, v1, v2, v3, v4, v5) \
+	TRICE_ENTER id;                                 \
+	TRICE_CNTC(12);                                 \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+//! TRICE16_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v6 are 16 bit values
+#define TRICE16_7(id, pFmt, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER id;                                     \
+	TRICE_CNTC(14);                                     \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);          \
+	TRICE_LEAVE
+
+//! TRICE16_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 16 bit values
+#define TRICE16_8(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER id;                                         \
+	TRICE_CNTC(16);                                         \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+//! TRICE16_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 16 bit values
+#define TRICE16_9(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER id;                                             \
+	TRICE_CNTC(18);                                             \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);          \
+	TRICE_LEAVE
+
+//! TRICE16_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 16 bit values
+#define TRICE16_10(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER id;                                                  \
+	TRICE_CNTC(20);                                                  \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);          \
+	TRICE_LEAVE
+
+//! TRICE16_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 16 bit values
+#define TRICE16_11(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER id;                                                       \
+	TRICE_CNTC(22);                                                       \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);          \
+	TRICE_LEAVE
+
+//! TRICE16_12 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v11 are 16 bit values
+#define TRICE16_12(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER id;                                                            \
+	TRICE_CNTC(24);                                                            \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)           \
+	TRICE_LEAVE

Middlewares/trice/trice16McuOrder.h

@@ -0,0 +1,286 @@
+/*! \file trice16McuOrder.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice16m_0(tid)                                              \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((0 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_LEAVE
+
+#define trice16m_1(tid, v0)                                          \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((2 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_1(v0)                                                \
+	TRICE_LEAVE
+
+#define trice16m_2(tid, v0, v1)                                      \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((4 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_2(v0, v1);                                           \
+	TRICE_LEAVE
+
+#define trice16m_3(tid, v0, v1, v2)                                  \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((6 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_3(v0, v1, v2);                                       \
+	TRICE_LEAVE
+
+#define trice16m_4(tid, v0, v1, v2, v3)                              \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((8 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_4(v0, v1, v2, v3);                                   \
+	TRICE_LEAVE
+
+#define trice16m_5(tid, v0, v1, v2, v3, v4)                           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((10 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);                                \
+	TRICE_LEAVE
+
+#define trice16m_6(tid, v0, v1, v2, v3, v4, v5)                       \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((12 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);                            \
+	TRICE_LEAVE
+
+#define trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6)                   \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((14 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);                        \
+	TRICE_LEAVE
+
+#define trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)               \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((16 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);                    \
+	TRICE_LEAVE
+
+#define trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((18 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);                \
+	TRICE_LEAVE
+
+#define trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)      \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((20 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);           \
+	TRICE_LEAVE
+
+#define trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((22 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT((24 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid)));      \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice16m_0(tid)                            \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid)); \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_LEAVE
+
+#define Trice16m_1(tid, v0)                        \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid)); \
+	TRICE_PUT(2 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_1(v0)                              \
+	TRICE_LEAVE
+
+#define Trice16m_2(tid, v0, v1)                    \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid)); \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_2(v0, v1);                         \
+	TRICE_LEAVE
+
+#define Trice16m_3(tid, v0, v1, v2)                \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid)); \
+	TRICE_PUT(6 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_3(v0, v1, v2);                     \
+	TRICE_LEAVE
+
+#define Trice16m_4(tid, v0, v1, v2, v3)            \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid)); \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_4(v0, v1, v2, v3);                 \
+	TRICE_LEAVE
+
+#define Trice16m_5(tid, v0, v1, v2, v3, v4)         \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));  \
+	TRICE_PUT(10 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);              \
+	TRICE_LEAVE
+
+#define Trice16m_6(tid, v0, v1, v2, v3, v4, v5)     \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));  \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+#define Trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));  \
+	TRICE_PUT(14 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);      \
+	TRICE_LEAVE
+
+#define Trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER                                         \
+	uint16_t ts = TriceStamp16;                         \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));      \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | ts);     \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);      \
+	TRICE_LEAVE
+
+#define Trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));          \
+	TRICE_PUT(18 << 24 | (TRICE_CYCLE << 16) | ts);         \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define Trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));               \
+	TRICE_PUT(20 << 24 | (TRICE_CYCLE << 16) | ts);              \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));                    \
+	TRICE_PUT(22 << 24 | (TRICE_CYCLE << 16) | ts);                   \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(0x80008000 | ((tid) << 16) | (tid));                         \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | ts);                        \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice16m_0(tid)                                    \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_LEAVE
+
+#define TRice16m_1(tid, v0)                                \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(2 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_1(v0)                                      \
+	TRICE_LEAVE
+
+#define TRice16m_2(tid, v0, v1)                            \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_2(v0, v1);                                 \
+	TRICE_LEAVE
+
+#define TRice16m_3(tid, v0, v1, v2)                        \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(6 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_3(v0, v1, v2);                             \
+	TRICE_LEAVE
+
+#define TRice16m_4(tid, v0, v1, v2, v3)                    \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_4(v0, v1, v2, v3);                         \
+	TRICE_LEAVE
+
+#define TRice16m_5(tid, v0, v1, v2, v3, v4)                 \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(10 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);                      \
+	TRICE_LEAVE
+
+#define TRice16m_6(tid, v0, v1, v2, v3, v4, v5)             \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);                  \
+	TRICE_LEAVE
+
+#define TRice16m_7(tid, v0, v1, v2, v3, v4, v5, v6)         \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(14 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);              \
+	TRICE_LEAVE
+
+#define TRice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)     \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+#define TRice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(18 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define TRice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                      \
+	TRICE_PUT(20 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));      \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                           \
+	TRICE_PUT(22 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));           \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                                \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));                \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice16McuReverse.h

@@ -0,0 +1,298 @@
+/*! \file trice16McuReverse.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+//! trice16m_0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define trice16m_0(tid)                      \
+	TRICE_ENTER                              \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | idLH); \
+	TRICE_LEAVE
+
+//! trice16m_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 16 bit value
+#define trice16m_1(tid, v0)                                                    \
+	TRICE_ENTER                                                                \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (2 << 16) | idLH);                       \
+	/*TRICE_PUT((2 << 8) | ((TRICE_CYCLE) << 0) | ((0x4000 | (tid)) << 16));*/ \
+	TRICE_PUT16_1(v0)                                                          \
+	TRICE_LEAVE
+
+#define trice16m_2(tid, v0, v1)                          \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (4 << 16) | idLH); \
+	TRICE_PUT16_2(v0, v1);                               \
+	TRICE_LEAVE
+
+#define trice16m_3(tid, v0, v1, v2)                      \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (6 << 16) | idLH); \
+	TRICE_PUT16_3(v0, v1, v2);                           \
+	TRICE_LEAVE
+
+#define trice16m_4(tid, v0, v1, v2, v3)                  \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (8 << 16) | idLH); \
+	TRICE_PUT16_4(v0, v1, v2, v3);                       \
+	TRICE_LEAVE
+
+#define trice16m_5(tid, v0, v1, v2, v3, v4)               \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (10 << 16) | idLH); \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);                    \
+	TRICE_LEAVE
+
+#define trice16m_6(tid, v0, v1, v2, v3, v4, v5)           \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (12 << 16) | idLH); \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);                \
+	TRICE_LEAVE
+
+#define trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6)       \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (14 << 16) | idLH); \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);            \
+	TRICE_LEAVE
+
+#define trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)   \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (16 << 16) | idLH); \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);        \
+	TRICE_LEAVE
+
+#define trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (18 << 16) | idLH);   \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (20 << 16) | idLH);        \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (22 << 16) | idLH);             \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (24 << 16) | idLH);                  \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice16m_0(tid)                         \
+	TRICE_ENTER                                 \
+	uint16_t ts = TriceStamp16;                 \
+	TRICE_PUT(((IdLH) << 16) | IdLH)            \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsL | tsH); \
+	TRICE_LEAVE
+
+//! Trice16m_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 16 bit value
+#define Trice16m_1(tid, v0)                                 \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (2 << 16) | tsL | tsH); \
+	TRICE_PUT16_1(v0)                                       \
+	TRICE_LEAVE
+
+#define Trice16m_2(tid, v0, v1)                             \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsL | tsH); \
+	TRICE_PUT16_2(v0, v1);                                  \
+	TRICE_LEAVE
+
+#define Trice16m_3(tid, v0, v1, v2)                         \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (6 << 16) | tsL | tsH); \
+	TRICE_PUT16_3(v0, v1, v2);                              \
+	TRICE_LEAVE
+
+#define Trice16m_4(tid, v0, v1, v2, v3)                     \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsL | tsH); \
+	TRICE_PUT16_4(v0, v1, v2, v3);                          \
+	TRICE_LEAVE
+
+#define Trice16m_5(tid, v0, v1, v2, v3, v4)                  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (10 << 16) | tsL | tsH); \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);                       \
+	TRICE_LEAVE
+
+#define Trice16m_6(tid, v0, v1, v2, v3, v4, v5)              \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsL | tsH); \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);                   \
+	TRICE_LEAVE
+
+#define Trice16m_7(tid, v0, v1, v2, v3, v4, v5, v6)          \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (14 << 16) | tsL | tsH); \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);               \
+	TRICE_LEAVE
+
+#define Trice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)      \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsL | tsH); \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+#define Trice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (18 << 16) | tsL | tsH); \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);       \
+	TRICE_LEAVE
+
+#define Trice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (20 << 16) | tsL | tsH);     \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                  \
+	TRICE_PUT((TRICE_CYCLE << 24) | (22 << 16) | tsL | tsH);          \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                       \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsL | tsH);               \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice16m_0(tid)                          \
+	TRICE_ENTER                                  \
+	uint32_t ts = TriceStamp32;                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsLL | tsLH) \
+	TRICE_LEAVE
+
+//! TRice16m_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 14 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 16 bit value
+#define TRice16m_1(tid, v0)                                  \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (2 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_1(v0)                                        \
+	TRICE_LEAVE
+
+#define TRice16m_2(tid, v0, v1)                              \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_2(v0, v1);                                   \
+	TRICE_LEAVE
+
+#define TRice16m_3(tid, v0, v1, v2)                          \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (6 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_3(v0, v1, v2);                               \
+	TRICE_LEAVE
+
+#define TRice16m_4(tid, v0, v1, v2, v3)                      \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_4(v0, v1, v2, v3);                           \
+	TRICE_LEAVE
+
+#define TRice16m_5(tid, v0, v1, v2, v3, v4)                   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (10 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_5(v0, v1, v2, v3, v4);                        \
+	TRICE_LEAVE
+
+#define TRice16m_6(tid, v0, v1, v2, v3, v4, v5)               \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_6(v0, v1, v2, v3, v4, v5);                    \
+	TRICE_LEAVE
+
+#define TRice16m_7(tid, v0, v1, v2, v3, v4, v5, v6)           \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (14 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_7(v0, v1, v2, v3, v4, v5, v6);                \
+	TRICE_LEAVE
+
+#define TRice16m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)       \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_8(v0, v1, v2, v3, v4, v5, v6, v7);            \
+	TRICE_LEAVE
+
+#define TRice16m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (18 << 16) | tsLL | tsLH) \
+	TRICE_PUT16_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);        \
+	TRICE_LEAVE
+
+#define TRice16m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                \
+	TRICE_PUT((TRICE_CYCLE << 24) | (20 << 16) | tsLL | tsLH)    \
+	TRICE_PUT16_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice16m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                     \
+	TRICE_PUT((TRICE_CYCLE << 24) | (22 << 16) | tsLL | tsLH)         \
+	TRICE_PUT16_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice16m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                          \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsLL | tsLH)              \
+	TRICE_PUT16_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice32.c

@@ -0,0 +1,560 @@
+//! \file trice32.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//! ///////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+// lint -e529  Warning 529: Symbol '_SEGGER_RTT__LockState' not subsequently referenced
+// lint -e701  Info 701: Shift left of signed quantity (int)
+
+#if TRICE_32_BIT_SUPPORT == 1 && TRICE_OFF == 0
+
+// no-stamp 32-bit-values functions
+#ifndef ENABLE_trice32fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 0 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_0 0 //!< Disables no-stamp 32-bit 0 values functions.
+#else
+#define ENABLE_trice32fn_0 1 //!< Enables  no-stamp 32-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 1 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_1 0 //!< Disables no-stamp 32-bit 1 values functions.
+#else
+#define ENABLE_trice32fn_1 1 //!< Enables  no-stamp 32-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 2 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_2 0 //!< Disables no-stamp 32-bit 2 values functions.
+#else
+#define ENABLE_trice32fn_2 1 //!< Enables  no-stamp 32-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 3 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_3 0 //!< Disables no-stamp 32-bit 3 values functions.
+#else
+#define ENABLE_trice32fn_3 1 //!< Enables  no-stamp 32-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 4 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_4 0 //!< Disables no-stamp 32-bit 4 values functions.
+#else
+#define ENABLE_trice32fn_4 1 //!< Enables  no-stamp 32-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 5 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_5 0 //!< Disables no-stamp 32-bit 5 values functions.
+#else
+#define ENABLE_trice32fn_5 1 //!< Enables  no-stamp 32-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 6 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_6 0 //!< Disables no-stamp 32-bit 6 values functions.
+#else
+#define ENABLE_trice32fn_6 1 //!< Enables  no-stamp 32-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 7 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_7 0 //!< Disables no-stamp 32-bit 7 values functions.
+#else
+#define ENABLE_trice32fn_7 1 //!< Enables  no-stamp 32-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 8 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_8 0 //!< Disables no-stamp 32-bit 8 values functions.
+#else
+#define ENABLE_trice32fn_8 1 //!< Enables  no-stamp 32-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 9 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_9 0 //!< Disables no-stamp 32-bit 9 values functions.
+#else
+#define ENABLE_trice32fn_9 1 //!< Enables  no-stamp 32-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 10 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_10 0 //!< Disables no-stamp 32-bit 10 values functions.
+#else
+#define ENABLE_trice32fn_10 1 //!< Enables  no-stamp 32-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 11 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_11 0 //!< Disables no-stamp 32-bit 11 values functions.
+#else
+#define ENABLE_trice32fn_11 1 //!< Enables  no-stamp 32-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice32fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 12 * 4) + 3) & ~3)
+#define ENABLE_trice32fn_12 0 //!< Disables no-stamp 32-bit 12 values functions.
+#else
+#define ENABLE_trice32fn_12 1 //!< Enables  no-stamp 32-bit 12 values functions.
+#endif
+#endif
+
+// 16-bit-stamp 32-bit-values functions (16-bit-stamps need 4 bytes for allocation reasons)
+#ifndef ENABLE_Trice32fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_0 0 //!< Disables 16-bit-stamp 32-bit 0 values functions.
+#else
+#define ENABLE_Trice32fn_0 1 //!< Enables  16-bit-stamp 32-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_1 0 //!< Disables 16-bit-stamp 32-bit 1 values functions.
+#else
+#define ENABLE_Trice32fn_1 1 //!< Enables  16-bit-stamp 32-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_2 0 //!< Disables 16-bit-stamp 32-bit 2 values functions.
+#else
+#define ENABLE_Trice32fn_2 1 //!< Enables  16-bit-stamp 32-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_3 0 //!< Disables 16-bit-stamp 32-bit 3 values functions.
+#else
+#define ENABLE_Trice32fn_3 1 //!< Enables  16-bit-stamp 32-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_4 0 //!< Disables 16-bit-stamp 32-bit 4 values functions.
+#else
+#define ENABLE_Trice32fn_4 1 //!< Enables  16-bit-stamp 32-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_5 0 //!< Disables 16-bit-stamp 32-bit 5 values functions.
+#else
+#define ENABLE_Trice32fn_5 1 //!< Enables  16-bit-stamp 32-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_6 0 //!< Disables 16-bit-stamp 32-bit 6 values functions.
+#else
+#define ENABLE_Trice32fn_6 1 //!< Enables  16-bit-stamp 32-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_7 0 //!< Disables 16-bit-stamp 32-bit 7 values functions.
+#else
+#define ENABLE_Trice32fn_7 1 //!< Enables  16-bit-stamp 32-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_8 0 //!< Disables 16-bit-stamp 32-bit 8 values functions.
+#else
+#define ENABLE_Trice32fn_8 1 //!< Enables  16-bit-stamp 32-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_9 0 //!< Disables 16-bit-stamp 32-bit 9 values functions.
+#else
+#define ENABLE_Trice32fn_9 1 //!< Enables  16-bit-stamp 32-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_10 0 //!< Disables 16-bit-stamp 32-bit 10 values functions.
+#else
+#define ENABLE_Trice32fn_10 1 //!< Enables  16-bit-stamp 32-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_11 0 //!< Disables 16-bit-stamp 32-bit 11 values functions.
+#else
+#define ENABLE_Trice32fn_11 1 //!< Enables  16-bit-stamp 32-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice32fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 4) + 3) & ~3)
+#define ENABLE_Trice32fn_12 0 //!< Disables 16-bit-stamp 32-bit 12 values functions.
+#else
+#define ENABLE_Trice32fn_12 1 //!< Enables  16-bit-stamp 32-bit 12 values functions.
+#endif
+#endif
+
+// with 32-bit-stamp 32-bit-values functions
+#ifndef ENABLE_TRice32fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_0 0 //!< Disables 32-bit-stamp 32-bit 0 values functions.
+#else
+#define ENABLE_TRice32fn_0 1 //!< Enables  32-bit-stamp 32-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_1 0 //!< Disables 32-bit-stamp 32-bit 1 values functions.
+#else
+#define ENABLE_TRice32fn_1 1 //!< Enables  32-bit-stamp 32-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_2 0 //!< Disables 32-bit-stamp 32-bit 2 values functions.
+#else
+#define ENABLE_TRice32fn_2 1 //!< Enables  32-bit-stamp 32-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_3 0 //!< Disables 32-bit-stamp 32-bit 3 values functions.
+#else
+#define ENABLE_TRice32fn_3 1 //!< Enables  32-bit-stamp 32-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_4 0 //!< Disables 32-bit-stamp 32-bit 4 values functions.
+#else
+#define ENABLE_TRice32fn_4 1 //!< Enables  32-bit-stamp 32-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_5 0 //!< Disables 32-bit-stamp 32-bit 5 values functions.
+#else
+#define ENABLE_TRice32fn_5 1 //!< Enables  32-bit-stamp 32-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_6 0 //!< Disables 32-bit-stamp 32-bit 6 values functions.
+#else
+#define ENABLE_TRice32fn_6 1 //!< Enables  32-bit-stamp 32-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_7 0 //!< Disables 32-bit-stamp 32-bit 7 values functions.
+#else
+#define ENABLE_TRice32fn_7 1 //!< Enables  32-bit-stamp 32-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_8 0 //!< Disables 32-bit-stamp 32-bit 8 values functions.
+#else
+#define ENABLE_TRice32fn_8 1 //!< Enables  32-bit-stamp 32-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_9 0 //!< Disables 32-bit-stamp 32-bit 9 values functions.
+#else
+#define ENABLE_TRice32fn_9 1 //!< Enables  32-bit-stamp 32-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_10 0 //!< Disables 32-bit-stamp 32-bit 10 values functions.
+#else
+#define ENABLE_TRice32fn_10 1 //!< Enables  32-bit-stamp 32-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_11 0 //!< Disables 32-bit-stamp 32-bit 11 values functions.
+#else
+#define ENABLE_TRice32fn_11 1 //!< Enables  32-bit-stamp 32-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice32fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 4) + 3) & ~3)
+#define ENABLE_TRice32fn_12 0 //!< Disables 32-bit-stamp 32-bit 12 values functions.
+#else
+#define ENABLE_TRice32fn_12 1 //!< Enables  32-bit-stamp 32-bit 12 values functions.
+#endif
+#endif
+
+#if ENABLE_trice32fn_0
+void trice32fn_0(uint16_t tid) {
+	trice32m_0(tid);
+}
+#endif
+
+#if ENABLE_trice32fn_1
+void trice32fn_1(uint16_t tid, uint32_t v0) {
+	trice32m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_trice32fn_2
+void trice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1) {
+	trice32m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_trice32fn_3
+void trice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2) {
+	trice32m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_trice32fn_4
+void trice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3) {
+	trice32m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_trice32fn_5
+void trice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4) {
+	trice32m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_trice32fn_6
+void trice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5) {
+	trice32m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_trice32fn_7
+void trice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6) {
+	trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_trice32fn_8
+void trice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7) {
+	trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_trice32fn_9
+void trice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8) {
+	trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_trice32fn_10
+void trice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9) {
+	trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_trice32fn_11
+void trice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10) {
+	trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_trice32fn_12
+void trice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11) {
+	trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_Trice32fn_0
+void Trice32fn_0(uint16_t tid) {
+	Trice32m_0(tid);
+}
+#endif
+
+#if ENABLE_Trice32fn_1
+void Trice32fn_1(uint16_t tid, uint32_t v0) {
+	Trice32m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_Trice32fn_2
+void Trice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1) {
+	Trice32m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_Trice32fn_3
+void Trice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2) {
+	Trice32m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_Trice32fn_4
+void Trice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3) {
+	Trice32m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_Trice32fn_5
+void Trice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4) {
+	Trice32m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_Trice32fn_6
+void Trice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5) {
+	Trice32m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_Trice32fn_7
+void Trice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6) {
+	Trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_Trice32fn_8
+void Trice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7) {
+	Trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_Trice32fn_9
+void Trice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8) {
+	Trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_Trice32fn_10
+void Trice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9) {
+	Trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_Trice32fn_11
+void Trice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10) {
+	Trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_Trice32fn_12
+void Trice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11) {
+	Trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_TRice32fn_0
+void TRice32fn_0(uint16_t tid) {
+	TRice32m_0(tid);
+}
+#endif
+
+#if ENABLE_TRice32fn_1
+void TRice32fn_1(uint16_t tid, uint32_t v0) {
+	TRice32m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_TRice32fn_2
+void TRice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1) {
+	TRice32m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_TRice32fn_3
+void TRice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2) {
+	TRice32m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_TRice32fn_4
+void TRice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3) {
+	TRice32m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_TRice32fn_5
+void TRice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4) {
+	TRice32m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_TRice32fn_6
+void TRice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5) {
+	TRice32m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_TRice32fn_7
+void TRice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6) {
+	TRice32m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_TRice32fn_8
+void TRice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7) {
+	TRice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_TRice32fn_9
+void TRice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8) {
+	TRice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_TRice32fn_10
+void TRice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9) {
+	TRice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_TRice32fn_11
+void TRice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10) {
+	TRice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_TRice32fn_12
+void TRice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11) {
+	TRice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#endif // #if TRICE_32_BIT_SUPPORT == 1 && TRICE_OFF == 0

Middlewares/trice/trice32.h

@@ -0,0 +1,299 @@
+/*! \file internalTrice32.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 32
+
+// #define TRICE_0  TRICE32_0  //!< Default parameter bit width for 0  parameter count TRICE is 32.
+#define TRICE_1 TRICE32_1   //!< Default parameter bit width for 1  parameter count TRICE is 32.
+#define TRICE_2 TRICE32_2   //!< Default parameter bit width for 2  parameter count TRICE is 32.
+#define TRICE_3 TRICE32_3   //!< Default parameter bit width for 3  parameter count TRICE is 32.
+#define TRICE_4 TRICE32_4   //!< Default parameter bit width for 4  parameter count TRICE is 32.
+#define TRICE_5 TRICE32_5   //!< Default parameter bit width for 5  parameter count TRICE is 32.
+#define TRICE_6 TRICE32_6   //!< Default parameter bit width for 6  parameter count TRICE is 32.
+#define TRICE_7 TRICE32_7   //!< Default parameter bit width for 7  parameter count TRICE is 32.
+#define TRICE_8 TRICE32_8   //!< Default parameter bit width for 8  parameter count TRICE is 32.
+#define TRICE_9 TRICE32_9   //!< Default parameter bit width for 9  parameter count TRICE is 32.
+#define TRICE_10 TRICE32_10 //!< Default parameter bit width for 10 parameter count TRICE is 32.
+#define TRICE_11 TRICE32_11 //!< Default parameter bit width for 11 parameter count TRICE is 32.
+#define TRICE_12 TRICE32_12 //!< Default parameter bit width for 12 parameter count TRICE is 32.
+
+// #define trice_0  trice32_0  //!< Default parameter bit width for 0  parameter count trice is 32.
+#define trice_1 trice32_1   //!< Default parameter bit width for 1  parameter count trice is 32.
+#define trice_2 trice32_2   //!< Default parameter bit width for 2  parameter count trice is 32.
+#define trice_3 trice32_3   //!< Default parameter bit width for 3  parameter count trice is 32.
+#define trice_4 trice32_4   //!< Default parameter bit width for 4  parameter count trice is 32.
+#define trice_5 trice32_5   //!< Default parameter bit width for 5  parameter count trice is 32.
+#define trice_6 trice32_6   //!< Default parameter bit width for 6  parameter count trice is 32.
+#define trice_7 trice32_7   //!< Default parameter bit width for 7  parameter count trice is 32.
+#define trice_8 trice32_8   //!< Default parameter bit width for 8  parameter count trice is 32.
+#define trice_9 trice32_9   //!< Default parameter bit width for 9  parameter count trice is 32.
+#define trice_10 trice32_10 //!< Default parameter bit width for 10 parameter count trice is 32.
+#define trice_11 trice32_11 //!< Default parameter bit width for 11 parameter count trice is 32.
+#define trice_12 trice32_12 //!< Default parameter bit width for 12 parameter count trice is 32.
+
+// #define Trice_0  Trice32_0  //!< Default parameter bit width for 0  parameter count Trice is 32.
+#define Trice_1 Trice32_1   //!< Default parameter bit width for 1  parameter count Trice is 32.
+#define Trice_2 Trice32_2   //!< Default parameter bit width for 2  parameter count Trice is 32.
+#define Trice_3 Trice32_3   //!< Default parameter bit width for 3  parameter count Trice is 32.
+#define Trice_4 Trice32_4   //!< Default parameter bit width for 4  parameter count Trice is 32.
+#define Trice_5 Trice32_5   //!< Default parameter bit width for 5  parameter count Trice is 32.
+#define Trice_6 Trice32_6   //!< Default parameter bit width for 6  parameter count Trice is 32.
+#define Trice_7 Trice32_7   //!< Default parameter bit width for 7  parameter count Trice is 32.
+#define Trice_8 Trice32_8   //!< Default parameter bit width for 8  parameter count Trice is 32.
+#define Trice_9 Trice32_9   //!< Default parameter bit width for 9  parameter count Trice is 32.
+#define Trice_10 Trice32_10 //!< Default parameter bit width for 10 parameter count Trice is 32.
+#define Trice_11 Trice32_11 //!< Default parameter bit width for 11 parameter count Trice is 32.
+#define Trice_12 Trice32_12 //!< Default parameter bit width for 12 parameter count Trice is 32.
+
+// #define TRice_0  TRice32_0  //!< Default parameter bit width for 0  parameter count TRice is 32.
+#define TRice_1 TRice32_1   //!< Default parameter bit width for 1  parameter count TRice is 32.
+#define TRice_2 TRice32_2   //!< Default parameter bit width for 2  parameter count TRice is 32.
+#define TRice_3 TRice32_3   //!< Default parameter bit width for 3  parameter count TRice is 32.
+#define TRice_4 TRice32_4   //!< Default parameter bit width for 4  parameter count TRice is 32.
+#define TRice_5 TRice32_5   //!< Default parameter bit width for 5  parameter count TRice is 32.
+#define TRice_6 TRice32_6   //!< Default parameter bit width for 6  parameter count TRice is 32.
+#define TRice_7 TRice32_7   //!< Default parameter bit width for 7  parameter count TRice is 32.
+#define TRice_8 TRice32_8   //!< Default parameter bit width for 8  parameter count TRice is 32.
+#define TRice_9 TRice32_9   //!< Default parameter bit width for 9  parameter count TRice is 32.
+#define TRice_10 TRice32_10 //!< Default parameter bit width for 10 parameter count TRice is 32.
+#define TRice_11 TRice32_11 //!< Default parameter bit width for 11 parameter count TRice is 32.
+#define TRice_12 TRice32_12 //!< Default parameter bit width for 12 parameter count TRice is 32.
+
+#endif // #if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 32
+
+#define TRICE32(tid, fmt, ...) TRICE_CONCAT2(TRICE32_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+
+//! TRICE32_B expects inside pFmt only one format specifier, which is used n times by using pFmt n times.
+//!  It is usable for showing n 32-bit values.
+#define TRICE32_B(id, pFmt, buf, n)    \
+	do {                               \
+		TRICE_N(id, pFmt, buf, 4 * n); \
+	} while (0)
+
+//! TRICE32_F expects inside pFmt just a string which is assumed to be a remote function name.
+//!  The trice tool displays the pFmt string followed by n times (32-bit value i).
+//!  The idea behind is to generate an id - function pointer referece list from the generated til.json file to
+//!  compile it into a remote device and execute the inside pFmt named function remotely.
+//!  Look for "TRICE32_F example" inside triceCheck.c.
+#define TRICE32_F TRICE32_B
+
+#define TRICE_PUT32_1(v0) TRICE_PUT(TRICE_HTOTL(v0));
+
+#define TRICE_PUT32_2(v0, v1)   \
+	TRICE_PUT(TRICE_HTOTL(v0)); \
+	TRICE_PUT(TRICE_HTOTL(v1));
+
+#define TRICE_PUT32_3(v0, v1, v2) \
+	TRICE_PUT(TRICE_HTOTL(v0));   \
+	TRICE_PUT(TRICE_HTOTL(v1));   \
+	TRICE_PUT(TRICE_HTOTL(v2));
+
+#define TRICE_PUT32_4(v0, v1, v2, v3) \
+	TRICE_PUT(TRICE_HTOTL(v0));       \
+	TRICE_PUT(TRICE_HTOTL(v1));       \
+	TRICE_PUT(TRICE_HTOTL(v2));       \
+	TRICE_PUT(TRICE_HTOTL(v3));
+
+#define TRICE_PUT32_5(v0, v1, v2, v3, v4) \
+	TRICE_PUT(TRICE_HTOTL(v0));           \
+	TRICE_PUT(TRICE_HTOTL(v1));           \
+	TRICE_PUT(TRICE_HTOTL(v2));           \
+	TRICE_PUT(TRICE_HTOTL(v3));           \
+	TRICE_PUT(TRICE_HTOTL(v4));
+
+#define TRICE_PUT32_6(v0, v1, v2, v3, v4, v5) \
+	TRICE_PUT(TRICE_HTOTL(v0));               \
+	TRICE_PUT(TRICE_HTOTL(v1));               \
+	TRICE_PUT(TRICE_HTOTL(v2));               \
+	TRICE_PUT(TRICE_HTOTL(v3));               \
+	TRICE_PUT(TRICE_HTOTL(v4));               \
+	TRICE_PUT(TRICE_HTOTL(v5));
+
+#define TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_PUT(TRICE_HTOTL(v0));                   \
+	TRICE_PUT(TRICE_HTOTL(v1));                   \
+	TRICE_PUT(TRICE_HTOTL(v2));                   \
+	TRICE_PUT(TRICE_HTOTL(v3));                   \
+	TRICE_PUT(TRICE_HTOTL(v4));                   \
+	TRICE_PUT(TRICE_HTOTL(v5));                   \
+	TRICE_PUT(TRICE_HTOTL(v6));
+
+#define TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_PUT(TRICE_HTOTL(v0));                       \
+	TRICE_PUT(TRICE_HTOTL(v1));                       \
+	TRICE_PUT(TRICE_HTOTL(v2));                       \
+	TRICE_PUT(TRICE_HTOTL(v3));                       \
+	TRICE_PUT(TRICE_HTOTL(v4));                       \
+	TRICE_PUT(TRICE_HTOTL(v5));                       \
+	TRICE_PUT(TRICE_HTOTL(v6));                       \
+	TRICE_PUT(TRICE_HTOTL(v7));
+
+#define TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_PUT(TRICE_HTOTL(v0));                           \
+	TRICE_PUT(TRICE_HTOTL(v1));                           \
+	TRICE_PUT(TRICE_HTOTL(v2));                           \
+	TRICE_PUT(TRICE_HTOTL(v3));                           \
+	TRICE_PUT(TRICE_HTOTL(v4));                           \
+	TRICE_PUT(TRICE_HTOTL(v5));                           \
+	TRICE_PUT(TRICE_HTOTL(v6));                           \
+	TRICE_PUT(TRICE_HTOTL(v7));                           \
+	TRICE_PUT(TRICE_HTOTL(v8));
+
+#define TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_PUT(TRICE_HTOTL(v0));                                \
+	TRICE_PUT(TRICE_HTOTL(v1));                                \
+	TRICE_PUT(TRICE_HTOTL(v2));                                \
+	TRICE_PUT(TRICE_HTOTL(v3));                                \
+	TRICE_PUT(TRICE_HTOTL(v4));                                \
+	TRICE_PUT(TRICE_HTOTL(v5));                                \
+	TRICE_PUT(TRICE_HTOTL(v6));                                \
+	TRICE_PUT(TRICE_HTOTL(v7));                                \
+	TRICE_PUT(TRICE_HTOTL(v8));                                \
+	TRICE_PUT(TRICE_HTOTL(v9));
+
+#define TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_PUT(TRICE_HTOTL(v0));                                     \
+	TRICE_PUT(TRICE_HTOTL(v1));                                     \
+	TRICE_PUT(TRICE_HTOTL(v2));                                     \
+	TRICE_PUT(TRICE_HTOTL(v3));                                     \
+	TRICE_PUT(TRICE_HTOTL(v4));                                     \
+	TRICE_PUT(TRICE_HTOTL(v5));                                     \
+	TRICE_PUT(TRICE_HTOTL(v6));                                     \
+	TRICE_PUT(TRICE_HTOTL(v7));                                     \
+	TRICE_PUT(TRICE_HTOTL(v8));                                     \
+	TRICE_PUT(TRICE_HTOTL(v9));                                     \
+	TRICE_PUT(TRICE_HTOTL(v10));
+
+#define TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_PUT(TRICE_HTOTL(v0));                                          \
+	TRICE_PUT(TRICE_HTOTL(v1));                                          \
+	TRICE_PUT(TRICE_HTOTL(v2));                                          \
+	TRICE_PUT(TRICE_HTOTL(v3));                                          \
+	TRICE_PUT(TRICE_HTOTL(v4));                                          \
+	TRICE_PUT(TRICE_HTOTL(v5));                                          \
+	TRICE_PUT(TRICE_HTOTL(v6));                                          \
+	TRICE_PUT(TRICE_HTOTL(v7));                                          \
+	TRICE_PUT(TRICE_HTOTL(v8));                                          \
+	TRICE_PUT(TRICE_HTOTL(v9));                                          \
+	TRICE_PUT(TRICE_HTOTL(v10));                                         \
+	TRICE_PUT(TRICE_HTOTL(v11));
+
+// The following `TRICE` macro definitions uses the C preprocess to concatenate the code behind the sub-macros.
+// The sequence `tid` in this context is executable code `id(n)`, `Id(n)` or `ID(n)` defined in trice.h.
+// This works only with tid=`id(n)`, `Id(n)`, `ID(n)`.
+
+//! TRICE32_0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define TRICE32_0(tid, pFmt) \
+	TRICE_ENTER tid;         \
+	TRICE_CNTC(0);           \
+	TRICE_LEAVE
+
+//! TRICE32_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 32 bit bit value
+#define TRICE32_1(tid, pFmt, v0) \
+	TRICE_ENTER tid;             \
+	TRICE_CNTC(4);               \
+	TRICE_PUT32_1(v0)            \
+	TRICE_LEAVE
+
+//! TRICE32_2 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v1 are 32 bit values
+#define TRICE32_2(tid, pFmt, v0, v1) \
+	TRICE_ENTER tid;                 \
+	TRICE_CNTC(8);                   \
+	TRICE_PUT32_2(v0, v1);           \
+	TRICE_LEAVE
+
+//! TRICE32_3 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v2 are 32 bit bit values
+#define TRICE32_3(tid, pFmt, v0, v1, v2) \
+	TRICE_ENTER tid;                     \
+	TRICE_CNTC(12);                      \
+	TRICE_PUT32_3(v0, v1, v2);           \
+	TRICE_LEAVE
+
+//! TRICE32_4 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v3 are 32 bit bit values
+#define TRICE32_4(tid, pFmt, v0, v1, v2, v3) \
+	TRICE_ENTER tid;                         \
+	TRICE_CNTC(16);                          \
+	TRICE_PUT32_4(v0, v1, v2, v3);           \
+	TRICE_LEAVE
+
+//! TRICE32_5 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v4 are 32 bit bit values
+#define TRICE32_5(tid, pFmt, v0, v1, v2, v3, v4) \
+	TRICE_ENTER tid;                             \
+	TRICE_CNTC(20);                              \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);           \
+	TRICE_LEAVE
+
+//! TRICE32_6 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v5 are 32 bit bit values
+#define TRICE32_6(tid, pFmt, v0, v1, v2, v3, v4, v5) \
+	TRICE_ENTER tid;                                 \
+	TRICE_CNTC(24);                                  \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);           \
+	TRICE_LEAVE
+
+//! TRICE32_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v6 are 32 bit bit values
+#define TRICE32_7(tid, pFmt, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER tid;                                     \
+	TRICE_CNTC(28);                                      \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);           \
+	TRICE_LEAVE
+
+//! TRICE32_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 32 bit bit values
+#define TRICE32_8(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER tid;                                         \
+	TRICE_CNTC(32);                                          \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+//! TRICE32_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 32 bit bit values
+#define TRICE32_9(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER tid;                                             \
+	TRICE_CNTC(36);                                              \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);           \
+	TRICE_LEAVE
+
+//! TRICE32_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 32 bit bit values
+#define TRICE32_10(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER tid;                                                  \
+	TRICE_CNTC(40);                                                   \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);           \
+	TRICE_LEAVE
+
+//! TRICE32_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 32 bit bit values
+#define TRICE32_11(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER tid;                                                       \
+	TRICE_CNTC(44);                                                        \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);           \
+	TRICE_LEAVE
+
+//! TRICE32_12 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v11 are 32 bit bit values
+#define TRICE32_12(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER tid;                                                            \
+	TRICE_CNTC(48);                                                             \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)            \
+	TRICE_LEAVE

Middlewares/trice/trice32McuOrder.h

@@ -0,0 +1,286 @@
+/*! \file trice32McuOrder.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice32m_0(tid)                                              \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((0 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_LEAVE
+
+#define trice32m_1(tid, v0)                                          \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((4 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_1(v0)                                                \
+	TRICE_LEAVE
+
+#define trice32m_2(tid, v0, v1)                                      \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((8 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_2(v0, v1);                                           \
+	TRICE_LEAVE
+
+#define trice32m_3(tid, v0, v1, v2)                                   \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((12 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_3(v0, v1, v2);                                        \
+	TRICE_LEAVE
+
+#define trice32m_4(tid, v0, v1, v2, v3)                               \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((16 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_4(v0, v1, v2, v3);                                    \
+	TRICE_LEAVE
+
+#define trice32m_5(tid, v0, v1, v2, v3, v4)                           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((20 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);                                \
+	TRICE_LEAVE
+
+#define trice32m_6(tid, v0, v1, v2, v3, v4, v5)                       \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((24 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);                            \
+	TRICE_LEAVE
+
+#define trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6)                   \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((28 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);                        \
+	TRICE_LEAVE
+
+#define trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)               \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((32 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);                    \
+	TRICE_LEAVE
+
+#define trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((36 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);                \
+	TRICE_LEAVE
+
+#define trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)      \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((40 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);           \
+	TRICE_LEAVE
+
+#define trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((44 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT((48 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid)));      \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice32m_0(tid)                            \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_LEAVE
+
+#define Trice32m_1(tid, v0)                        \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_1(v0)                              \
+	TRICE_LEAVE
+
+#define Trice32m_2(tid, v0, v1)                    \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_2(v0, v1);                         \
+	TRICE_LEAVE
+
+#define Trice32m_3(tid, v0, v1, v2)                 \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_3(v0, v1, v2);                      \
+	TRICE_LEAVE
+
+#define Trice32m_4(tid, v0, v1, v2, v3)             \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_4(v0, v1, v2, v3);                  \
+	TRICE_LEAVE
+
+#define Trice32m_5(tid, v0, v1, v2, v3, v4)         \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(20 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);              \
+	TRICE_LEAVE
+
+#define Trice32m_6(tid, v0, v1, v2, v3, v4, v5)     \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+#define Trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(28 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);      \
+	TRICE_LEAVE
+
+#define Trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER                                         \
+	uint16_t ts = TriceStamp16;                         \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));        \
+	TRICE_PUT(32 << 24 | (TRICE_CYCLE << 16) | ts);     \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);      \
+	TRICE_LEAVE
+
+#define Trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));            \
+	TRICE_PUT(36 << 24 | (TRICE_CYCLE << 16) | ts);         \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define Trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                 \
+	TRICE_PUT(40 << 24 | (TRICE_CYCLE << 16) | ts);              \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                      \
+	TRICE_PUT(44 << 24 | (TRICE_CYCLE << 16) | ts);                   \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                           \
+	TRICE_PUT(48 << 24 | (TRICE_CYCLE << 16) | ts);                        \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice32m_0(tid)                                    \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_LEAVE
+
+#define TRice32m_1(tid, v0)                                \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_1(v0)                                      \
+	TRICE_LEAVE
+
+#define TRice32m_2(tid, v0, v1)                            \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_2(v0, v1);                                 \
+	TRICE_LEAVE
+
+#define TRice32m_3(tid, v0, v1, v2)                         \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_3(v0, v1, v2);                              \
+	TRICE_LEAVE
+
+#define TRice32m_4(tid, v0, v1, v2, v3)                     \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_4(v0, v1, v2, v3);                          \
+	TRICE_LEAVE
+
+#define TRice32m_5(tid, v0, v1, v2, v3, v4)                 \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(20 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);                      \
+	TRICE_LEAVE
+
+#define TRice32m_6(tid, v0, v1, v2, v3, v4, v5)             \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);                  \
+	TRICE_LEAVE
+
+#define TRice32m_7(tid, v0, v1, v2, v3, v4, v5, v6)         \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(28 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);              \
+	TRICE_LEAVE
+
+#define TRice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)     \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(32 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+#define TRice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(36 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define TRice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                      \
+	TRICE_PUT(40 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));      \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                           \
+	TRICE_PUT(44 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));           \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                                \
+	TRICE_PUT(48 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));                \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice32McuReverse.h

@@ -0,0 +1,286 @@
+/*! \file trice32McuReverse.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice32m_0(tid)                      \
+	TRICE_ENTER                              \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | idLH); \
+	TRICE_LEAVE
+
+#define trice32m_1(tid, v0)                              \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (4 << 16) | idLH); \
+	TRICE_PUT32_1(v0)                                    \
+	TRICE_LEAVE
+
+#define trice32m_2(tid, v0, v1)                          \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (8 << 16) | idLH); \
+	TRICE_PUT32_2(v0, v1);                               \
+	TRICE_LEAVE
+
+#define trice32m_3(tid, v0, v1, v2)                       \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (12 << 16) | idLH); \
+	TRICE_PUT32_3(v0, v1, v2);                            \
+	TRICE_LEAVE
+
+#define trice32m_4(tid, v0, v1, v2, v3)                   \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (16 << 16) | idLH); \
+	TRICE_PUT32_4(v0, v1, v2, v3);                        \
+	TRICE_LEAVE
+
+#define trice32m_5(tid, v0, v1, v2, v3, v4)               \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (20 << 16) | idLH); \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);                    \
+	TRICE_LEAVE
+
+#define trice32m_6(tid, v0, v1, v2, v3, v4, v5)           \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (24 << 16) | idLH); \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);                \
+	TRICE_LEAVE
+
+#define trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6)       \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (28 << 16) | idLH); \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);            \
+	TRICE_LEAVE
+
+#define trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)   \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (32 << 16) | idLH); \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);        \
+	TRICE_LEAVE
+
+#define trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (36 << 16) | idLH);   \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (40 << 16) | idLH);        \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (44 << 16) | idLH);             \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (48 << 16) | idLH);                  \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice32m_0(tid)                         \
+	TRICE_ENTER                                 \
+	uint16_t ts = TriceStamp16;                 \
+	TRICE_PUT(((IdLH) << 16) | IdLH)            \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsL | tsH); \
+	TRICE_LEAVE
+
+#define Trice32m_1(tid, v0)                                 \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsL | tsH); \
+	TRICE_PUT32_1(v0)                                       \
+	TRICE_LEAVE
+
+#define Trice32m_2(tid, v0, v1)                             \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsL | tsH); \
+	TRICE_PUT32_2(v0, v1);                                  \
+	TRICE_LEAVE
+
+#define Trice32m_3(tid, v0, v1, v2)                          \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsL | tsH); \
+	TRICE_PUT32_3(v0, v1, v2);                               \
+	TRICE_LEAVE
+
+#define Trice32m_4(tid, v0, v1, v2, v3)                      \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsL | tsH); \
+	TRICE_PUT32_4(v0, v1, v2, v3);                           \
+	TRICE_LEAVE
+
+#define Trice32m_5(tid, v0, v1, v2, v3, v4)                  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (20 << 16) | tsL | tsH); \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);                       \
+	TRICE_LEAVE
+
+#define Trice32m_6(tid, v0, v1, v2, v3, v4, v5)              \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsL | tsH); \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);                   \
+	TRICE_LEAVE
+
+#define Trice32m_7(tid, v0, v1, v2, v3, v4, v5, v6)          \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (28 << 16) | tsL | tsH); \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);               \
+	TRICE_LEAVE
+
+#define Trice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)      \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (32 << 16) | tsL | tsH); \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+#define Trice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (36 << 16) | tsL | tsH); \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);       \
+	TRICE_LEAVE
+
+#define Trice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (40 << 16) | tsL | tsH);     \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                  \
+	TRICE_PUT((TRICE_CYCLE << 24) | (44 << 16) | tsL | tsH);          \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                       \
+	TRICE_PUT((TRICE_CYCLE << 24) | (48 << 16) | tsL | tsH);               \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice32m_0(tid)                          \
+	TRICE_ENTER                                  \
+	uint32_t ts = TriceStamp32;                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsLL | tsLH) \
+	TRICE_LEAVE
+
+#define TRice32m_1(tid, v0)                                  \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_1(v0)                                        \
+	TRICE_LEAVE
+
+#define TRice32m_2(tid, v0, v1)                              \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_2(v0, v1);                                   \
+	TRICE_LEAVE
+
+#define TRice32m_3(tid, v0, v1, v2)                           \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_3(v0, v1, v2);                                \
+	TRICE_LEAVE
+
+#define TRice32m_4(tid, v0, v1, v2, v3)                       \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_4(v0, v1, v2, v3);                            \
+	TRICE_LEAVE
+
+#define TRice32m_5(tid, v0, v1, v2, v3, v4)                   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (20 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_5(v0, v1, v2, v3, v4);                        \
+	TRICE_LEAVE
+
+#define TRice32m_6(tid, v0, v1, v2, v3, v4, v5)               \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_6(v0, v1, v2, v3, v4, v5);                    \
+	TRICE_LEAVE
+
+#define TRice32m_7(tid, v0, v1, v2, v3, v4, v5, v6)           \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (28 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_7(v0, v1, v2, v3, v4, v5, v6);                \
+	TRICE_LEAVE
+
+#define TRice32m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)       \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (32 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_8(v0, v1, v2, v3, v4, v5, v6, v7);            \
+	TRICE_LEAVE
+
+#define TRice32m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (36 << 16) | tsLL | tsLH) \
+	TRICE_PUT32_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);        \
+	TRICE_LEAVE
+
+#define TRice32m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                \
+	TRICE_PUT((TRICE_CYCLE << 24) | (40 << 16) | tsLL | tsLH)    \
+	TRICE_PUT32_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice32m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                     \
+	TRICE_PUT((TRICE_CYCLE << 24) | (44 << 16) | tsLL | tsLH)         \
+	TRICE_PUT32_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice32m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                          \
+	TRICE_PUT((TRICE_CYCLE << 24) | (48 << 16) | tsLL | tsLH)              \
+	TRICE_PUT32_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice64.c

@@ -0,0 +1,561 @@
+//! \file trice64.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//! ///////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+// lint -e529  Warning 529: Symbol '_SEGGER_RTT__LockState' not subsequently referenced
+// lint -e701  Info 701: Shift left of signed quantity (int)
+// lint -e712  Info 712: Loss of precision (assignment) (unsigned long long to unsigned int)
+
+#if TRICE_64_BIT_SUPPORT == 1 && TRICE_OFF == 0
+
+// no-stamp 64-bit-values functions
+#ifndef ENABLE_trice64fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 0 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_0 0 //!< Disables no-stamp 64-bit 0 values functions.
+#else
+#define ENABLE_trice64fn_0 1 //!< Enables  no-stamp 64-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 1 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_1 0 //!< Disables no-stamp 64-bit 1 values functions.
+#else
+#define ENABLE_trice64fn_1 1 //!< Enables  no-stamp 64-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 2 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_2 0 //!< Disables no-stamp 64-bit 2 values functions.
+#else
+#define ENABLE_trice64fn_2 1 //!< Enables  no-stamp 64-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 3 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_3 0 //!< Disables no-stamp 64-bit 3 values functions.
+#else
+#define ENABLE_trice64fn_3 1 //!< Enables  no-stamp 64-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 4 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_4 0 //!< Disables no-stamp 64-bit 4 values functions.
+#else
+#define ENABLE_trice64fn_4 1 //!< Enables  no-stamp 64-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 5 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_5 0 //!< Disables no-stamp 64-bit 5 values functions.
+#else
+#define ENABLE_trice64fn_5 1 //!< Enables  no-stamp 64-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 6 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_6 0 //!< Disables no-stamp 64-bit 6 values functions.
+#else
+#define ENABLE_trice64fn_6 1 //!< Enables  no-stamp 64-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 7 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_7 0 //!< Disables no-stamp 64-bit 7 values functions.
+#else
+#define ENABLE_trice64fn_7 1 //!< Enables  no-stamp 64-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 8 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_8 0 //!< Disables no-stamp 64-bit 8 values functions.
+#else
+#define ENABLE_trice64fn_8 1 //!< Enables  no-stamp 64-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 9 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_9 0 //!< Disables no-stamp 64-bit 9 values functions.
+#else
+#define ENABLE_trice64fn_9 1 //!< Enables  no-stamp 64-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 10 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_10 0 //!< Disables no-stamp 64-bit 10 values functions.
+#else
+#define ENABLE_trice64fn_10 1 //!< Enables  no-stamp 64-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 11 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_11 0 //!< Disables no-stamp 64-bit 11 values functions.
+#else
+#define ENABLE_trice64fn_11 1 //!< Enables  no-stamp 64-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice64fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 12 * 8) + 3) & ~3)
+#define ENABLE_trice64fn_12 0 //!< Disables no-stamp 64-bit 12 values functions.
+#else
+#define ENABLE_trice64fn_12 1 //!< Enables  no-stamp 64-bit 12 values functions.
+#endif
+#endif
+
+// with 16-bit-stamp 64-bit-values functions (16-bit-stamps need 4 bytes for allocation reasons)
+#ifndef ENABLE_Trice64fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_0 0 //!< Disables 16-bit stamp 64-bit 0 values functions.
+#else
+#define ENABLE_Trice64fn_0 1 //!< Enables  16-bit stamp 64-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_1 0 //!< Disables 16-bit stamp 64-bit 1 values functions.
+#else
+#define ENABLE_Trice64fn_1 1 //!< Enables  16-bit stamp 64-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_2 0 //!< Disables 16-bit stamp 64-bit 2 values functions.
+#else
+#define ENABLE_Trice64fn_2 1 //!< Enables  16-bit stamp 64-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_3 0 //!< Disables 16-bit stamp 64-bit 3 values functions.
+#else
+#define ENABLE_Trice64fn_3 1 //!< Enables  16-bit stamp 64-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_4 0 //!< Disables 16-bit stamp 64-bit 4 values functions.
+#else
+#define ENABLE_Trice64fn_4 1 //!< Enables  16-bit stamp 64-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_5 0 //!< Disables 16-bit stamp 64-bit 5 values functions.
+#else
+#define ENABLE_Trice64fn_5 1 //!< Enables  16-bit stamp 64-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_6 0 //!< Disables 16-bit stamp 64-bit 6 values functions.
+#else
+#define ENABLE_Trice64fn_6 1 //!< Enables  16-bit stamp 64-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_7 0 //!< Disables 16-bit stamp 64-bit 7 values functions.
+#else
+#define ENABLE_Trice64fn_7 1 //!< Enables  16-bit stamp 64-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_8 0 //!< Disables 16-bit stamp 64-bit 8 values functions.
+#else
+#define ENABLE_Trice64fn_8 1 //!< Enables  16-bit stamp 64-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_9 0 //!< Disables 16-bit stamp 64-bit 9 values functions.
+#else
+#define ENABLE_Trice64fn_9 1 //!< Enables  16-bit stamp 64-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_10 0 //!< Disables 16-bit stamp 64-bit 10 values functions.
+#else
+#define ENABLE_Trice64fn_10 1 //!< Enables  16-bit stamp 64-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_11 0 //!< Disables 16-bit stamp 64-bit 11 values functions.
+#else
+#define ENABLE_Trice64fn_11 1 //!< Enables  16-bit stamp 64-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice64fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 8) + 3) & ~3)
+#define ENABLE_Trice64fn_12 0 //!< Disables 16-bit stamp 64-bit 12 values functions.
+#else
+#define ENABLE_Trice64fn_12 1 //!< Enables  16-bit stamp 64-bit 12 values functions.
+#endif
+#endif
+
+// with 32-bit-stamp 64-bit-values functions
+#ifndef ENABLE_TRice64fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_0 0 //!< Disables 32-bit-stamp 64-bit 0 values functions.
+#else
+#define ENABLE_TRice64fn_0 1 //!< Enables  32-bit-stamp 64-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_1 0 //!< Disables 32-bit-stamp 64-bit 1 values functions.
+#else
+#define ENABLE_TRice64fn_1 1 //!< Enables  32-bit-stamp 64-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_2 0 //!< Disables 32-bit-stamp 64-bit 2 values functions.
+#else
+#define ENABLE_TRice64fn_2 1 //!< Enables  32-bit-stamp 64-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_3 0 //!< Disables 32-bit-stamp 64-bit 3 values functions.
+#else
+#define ENABLE_TRice64fn_3 1 //!< Enables  32-bit-stamp 64-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_4 0 //!< Disables 32-bit-stamp 64-bit 4 values functions.
+#else
+#define ENABLE_TRice64fn_4 1 //!< Enables  32-bit-stamp 64-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_5 0 //!< Disables 32-bit-stamp 64-bit 5 values functions.
+#else
+#define ENABLE_TRice64fn_5 1 //!< Enables  32-bit-stamp 64-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_6 0 //!< Disables 32-bit-stamp 64-bit 6 values functions.
+#else
+#define ENABLE_TRice64fn_6 1 //!< Enables  32-bit-stamp 64-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_7 0 //!< Disables 32-bit-stamp 64-bit 7 values functions.
+#else
+#define ENABLE_TRice64fn_7 1 //!< Enables  32-bit-stamp 64-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_8 0 //!< Disables 32-bit-stamp 64-bit 8 values functions.
+#else
+#define ENABLE_TRice64fn_8 1 //!< Enables  32-bit-stamp 64-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_9 0 //!< Disables 32-bit-stamp 64-bit 9 values functions.
+#else
+#define ENABLE_TRice64fn_9 1 //!< Enables  32-bit-stamp 64-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_10 0 //!< Disables 32-bit-stamp 64-bit 10 values functions.
+#else
+#define ENABLE_TRice64fn_10 1 //!< Enables  32-bit-stamp 64-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_11 0 //!< Disables 32-bit-stamp 64-bit 11 values functions.
+#else
+#define ENABLE_TRice64fn_11 1 //!< Enables  32-bit-stamp 64-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice64fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 8) + 3) & ~3)
+#define ENABLE_TRice64fn_12 0 //!< Disables 32-bit-stamp 64-bit 12 values functions.
+#else
+#define ENABLE_TRice64fn_12 1 //!< Enables  32-bit-stamp 64-bit 12 values functions.
+#endif
+#endif
+
+#if ENABLE_trice64fn_0
+void trice64fn_0(uint16_t tid) {
+	trice64m_0(tid);
+}
+#endif
+
+#if ENABLE_trice64fn_1
+void trice64fn_1(uint16_t tid, uint64_t v0) {
+	trice64m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_trice64fn_2
+void trice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1) {
+	trice64m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_trice64fn_3
+void trice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2) {
+	trice64m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_trice64fn_4
+void trice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) {
+	trice64m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_trice64fn_5
+void trice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4) {
+	trice64m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_trice64fn_6
+void trice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5) {
+	trice64m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_trice64fn_7
+void trice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6) {
+	trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_trice64fn_8
+void trice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7) {
+	trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_trice64fn_9
+void trice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8) {
+	trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_trice64fn_10
+void trice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9) {
+	trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_trice64fn_11
+void trice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10) {
+	trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_trice64fn_12
+void trice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11) {
+	trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_Trice64fn_0
+void Trice64fn_0(uint16_t tid) {
+	Trice64m_0(tid);
+}
+#endif
+
+#if ENABLE_Trice64fn_1
+void Trice64fn_1(uint16_t tid, uint64_t v0) {
+	Trice64m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_Trice64fn_2
+void Trice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1) {
+	Trice64m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_Trice64fn_3
+void Trice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2) {
+	Trice64m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_Trice64fn_4
+void Trice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) {
+	Trice64m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_Trice64fn_5
+void Trice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4) {
+	Trice64m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_Trice64fn_6
+void Trice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5) {
+	Trice64m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_Trice64fn_7
+void Trice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6) {
+	Trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_Trice64fn_8
+void Trice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7) {
+	Trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_Trice64fn_9
+void Trice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8) {
+	Trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_Trice64fn_10
+void Trice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9) {
+	Trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_Trice64fn_11
+void Trice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10) {
+	Trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_Trice64fn_12
+void Trice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11) {
+	Trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_TRice64fn_0
+void TRice64fn_0(uint16_t tid) {
+	TRice64m_0(tid);
+}
+#endif
+
+#if ENABLE_TRice64fn_1
+void TRice64fn_1(uint16_t tid, uint64_t v0) {
+	TRice64m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_TRice64fn_2
+void TRice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1) {
+	TRice64m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_TRice64fn_3
+void TRice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2) {
+	TRice64m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_TRice64fn_4
+void TRice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) {
+	TRice64m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_TRice64fn_5
+void TRice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4) {
+	TRice64m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_TRice64fn_6
+void TRice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5) {
+	TRice64m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_TRice64fn_7
+void TRice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6) {
+	TRice64m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_TRice64fn_8
+void TRice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7) {
+	TRice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_TRice64fn_9
+void TRice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8) {
+	TRice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_TRice64fn_10
+void TRice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9) {
+	TRice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_TRice64fn_11
+void TRice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10) {
+	TRice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_TRice64fn_12
+void TRice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11) {
+	TRice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#endif // #if TRICE_64_BIT_SUPPORT == 1 && TRICE_OFF == 0

Middlewares/trice/trice64.h

@@ -0,0 +1,299 @@
+/*! \file internalTrice64.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 64
+
+// #define TRICE_0  TRICE64_0  //!< Default parameter bit width for 0  parameter count TRICE is 64.
+#define TRICE_1 TRICE64_1   //!< Default parameter bit width for 1  parameter count TRICE is 64.
+#define TRICE_2 TRICE64_2   //!< Default parameter bit width for 2  parameter count TRICE is 64.
+#define TRICE_3 TRICE64_3   //!< Default parameter bit width for 3  parameter count TRICE is 64.
+#define TRICE_4 TRICE64_4   //!< Default parameter bit width for 4  parameter count TRICE is 64.
+#define TRICE_5 TRICE64_5   //!< Default parameter bit width for 5  parameter count TRICE is 64.
+#define TRICE_6 TRICE64_6   //!< Default parameter bit width for 6  parameter count TRICE is 64.
+#define TRICE_7 TRICE64_7   //!< Default parameter bit width for 7  parameter count TRICE is 64.
+#define TRICE_8 TRICE64_8   //!< Default parameter bit width for 8  parameter count TRICE is 64.
+#define TRICE_9 TRICE64_9   //!< Default parameter bit width for 9  parameter count TRICE is 64.
+#define TRICE_10 TRICE64_10 //!< Default parameter bit width for 10 parameter count TRICE is 64.
+#define TRICE_11 TRICE64_11 //!< Default parameter bit width for 11 parameter count TRICE is 64.
+#define TRICE_12 TRICE64_12 //!< Default parameter bit width for 12 parameter count TRICE is 64.
+
+// #define trice_0  trice64_0  //!< Default parameter bit width for 1  parameter count trice is 64.
+#define trice_1 trice64_1   //!< Default parameter bit width for 1  parameter count trice is 64.
+#define trice_2 trice64_2   //!< Default parameter bit width for 2  parameter count trice is 64.
+#define trice_3 trice64_3   //!< Default parameter bit width for 3  parameter count trice is 64.
+#define trice_4 trice64_4   //!< Default parameter bit width for 4  parameter count trice is 64.
+#define trice_5 trice64_5   //!< Default parameter bit width for 5  parameter count trice is 64.
+#define trice_6 trice64_6   //!< Default parameter bit width for 6  parameter count trice is 64.
+#define trice_7 trice64_7   //!< Default parameter bit width for 7  parameter count trice is 64.
+#define trice_8 trice64_8   //!< Default parameter bit width for 8  parameter count trice is 64.
+#define trice_9 trice64_9   //!< Default parameter bit width for 9  parameter count trice is 64.
+#define trice_10 trice64_10 //!< Default parameter bit width for 10 parameter count trice is 64.
+#define trice_11 trice64_11 //!< Default parameter bit width for 11 parameter count trice is 64.
+#define trice_12 trice64_12 //!< Default parameter bit width for 12 parameter count trice is 64.
+
+// #define Trice_0  Trice64_0  //!< Default parameter bit width for 0  parameter count Trice is 64.
+#define Trice_1 Trice64_1   //!< Default parameter bit width for 1  parameter count Trice is 64.
+#define Trice_2 Trice64_2   //!< Default parameter bit width for 2  parameter count Trice is 64.
+#define Trice_3 Trice64_3   //!< Default parameter bit width for 3  parameter count Trice is 64.
+#define Trice_4 Trice64_4   //!< Default parameter bit width for 4  parameter count Trice is 64.
+#define Trice_5 Trice64_5   //!< Default parameter bit width for 5  parameter count Trice is 64.
+#define Trice_6 Trice64_6   //!< Default parameter bit width for 6  parameter count Trice is 64.
+#define Trice_7 Trice64_7   //!< Default parameter bit width for 7  parameter count Trice is 64.
+#define Trice_8 Trice64_8   //!< Default parameter bit width for 8  parameter count Trice is 64.
+#define Trice_9 Trice64_9   //!< Default parameter bit width for 9  parameter count Trice is 64.
+#define Trice_10 Trice64_10 //!< Default parameter bit width for 10 parameter count Trice is 64.
+#define Trice_11 Trice64_11 //!< Default parameter bit width for 11 parameter count Trice is 64.
+#define Trice_12 Trice64_12 //!< Default parameter bit width for 12 parameter count Trice is 64.
+
+// #define TRice_0  TRice64_0  //!< Default parameter bit width for 0  parameter count TRice is 64.
+#define TRice_1 TRice64_1   //!< Default parameter bit width for 1  parameter count TRice is 64.
+#define TRice_2 TRice64_2   //!< Default parameter bit width for 2  parameter count TRice is 64.
+#define TRice_3 TRice64_3   //!< Default parameter bit width for 3  parameter count TRice is 64.
+#define TRice_4 TRice64_4   //!< Default parameter bit width for 4  parameter count TRice is 64.
+#define TRice_5 TRice64_5   //!< Default parameter bit width for 5  parameter count TRice is 64.
+#define TRice_6 TRice64_6   //!< Default parameter bit width for 6  parameter count TRice is 64.
+#define TRice_7 TRice64_7   //!< Default parameter bit width for 7  parameter count TRice is 64.
+#define TRice_8 TRice64_8   //!< Default parameter bit width for 8  parameter count TRice is 64.
+#define TRice_9 TRice64_9   //!< Default parameter bit width for 9  parameter count TRice is 64.
+#define TRice_10 TRice64_10 //!< Default parameter bit width for 10 parameter count TRice is 64.
+#define TRice_11 TRice64_11 //!< Default parameter bit width for 11 parameter count TRice is 64.
+#define TRice_12 TRice64_12 //!< Default parameter bit width for 12 parameter count TRice is 64.
+
+#endif // #if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 64
+
+#define TRICE64(tid, fmt, ...) TRICE_CONCAT2(TRICE64_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+
+//! TRICE64_B expects inside pFmt only one format specifier, which is used n times by using pFmt n times.
+//!  It is usable for showing n 64-bit values.
+#define TRICE64_B(id, pFmt, buf, n)    \
+	do {                               \
+		TRICE_N(id, pFmt, buf, 8 * n); \
+	} while (0)
+
+//! TRICE64_F expects inside pFmt just a string which is assumed to be a remote function name.
+//!  The trice tool displays the pFmt string followed by n times (64-bit value i).
+//!  The idea behind is to generate an id - function pointer referece list from the generated til.json file to
+//!  compile it into a remote device and execute the inside pFmt named function remotely.
+//!  Look for "TRICE64_F example" inside triceCheck.c.
+#define TRICE64_F TRICE64_B
+
+#define TRICE_PUT64_1(v0) TRICE_PUT64(v0);
+
+#define TRICE_PUT64_2(v0, v1) \
+	TRICE_PUT64(v0);          \
+	TRICE_PUT64(v1);
+
+#define TRICE_PUT64_3(v0, v1, v2) \
+	TRICE_PUT64(v0);              \
+	TRICE_PUT64(v1);              \
+	TRICE_PUT64(v2);
+
+#define TRICE_PUT64_4(v0, v1, v2, v3) \
+	TRICE_PUT64(v0);                  \
+	TRICE_PUT64(v1);                  \
+	TRICE_PUT64(v2);                  \
+	TRICE_PUT64(v3);
+
+#define TRICE_PUT64_5(v0, v1, v2, v3, v4) \
+	TRICE_PUT64(v0);                      \
+	TRICE_PUT64(v1);                      \
+	TRICE_PUT64(v2);                      \
+	TRICE_PUT64(v3);                      \
+	TRICE_PUT64(v4);
+
+#define TRICE_PUT64_6(v0, v1, v2, v3, v4, v5) \
+	TRICE_PUT64(v0);                          \
+	TRICE_PUT64(v1);                          \
+	TRICE_PUT64(v2);                          \
+	TRICE_PUT64(v3);                          \
+	TRICE_PUT64(v4);                          \
+	TRICE_PUT64(v5);
+
+#define TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_PUT64(v0);                              \
+	TRICE_PUT64(v1);                              \
+	TRICE_PUT64(v2);                              \
+	TRICE_PUT64(v3);                              \
+	TRICE_PUT64(v4);                              \
+	TRICE_PUT64(v5);                              \
+	TRICE_PUT64(v6);
+
+#define TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_PUT64(v0);                                  \
+	TRICE_PUT64(v1);                                  \
+	TRICE_PUT64(v2);                                  \
+	TRICE_PUT64(v3);                                  \
+	TRICE_PUT64(v4);                                  \
+	TRICE_PUT64(v5);                                  \
+	TRICE_PUT64(v6);                                  \
+	TRICE_PUT64(v7);
+
+#define TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_PUT64(v0);                                      \
+	TRICE_PUT64(v1);                                      \
+	TRICE_PUT64(v2);                                      \
+	TRICE_PUT64(v3);                                      \
+	TRICE_PUT64(v4);                                      \
+	TRICE_PUT64(v5);                                      \
+	TRICE_PUT64(v6);                                      \
+	TRICE_PUT64(v7);                                      \
+	TRICE_PUT64(v8);
+
+#define TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_PUT64(v0);                                           \
+	TRICE_PUT64(v1);                                           \
+	TRICE_PUT64(v2);                                           \
+	TRICE_PUT64(v3);                                           \
+	TRICE_PUT64(v4);                                           \
+	TRICE_PUT64(v5);                                           \
+	TRICE_PUT64(v6);                                           \
+	TRICE_PUT64(v7);                                           \
+	TRICE_PUT64(v8);                                           \
+	TRICE_PUT64(v9);
+
+#define TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_PUT64(v0);                                                \
+	TRICE_PUT64(v1);                                                \
+	TRICE_PUT64(v2);                                                \
+	TRICE_PUT64(v3);                                                \
+	TRICE_PUT64(v4);                                                \
+	TRICE_PUT64(v5);                                                \
+	TRICE_PUT64(v6);                                                \
+	TRICE_PUT64(v7);                                                \
+	TRICE_PUT64(v8);                                                \
+	TRICE_PUT64(v9);                                                \
+	TRICE_PUT64(v10);
+
+#define TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_PUT64(v0);                                                     \
+	TRICE_PUT64(v1);                                                     \
+	TRICE_PUT64(v2);                                                     \
+	TRICE_PUT64(v3);                                                     \
+	TRICE_PUT64(v4);                                                     \
+	TRICE_PUT64(v5);                                                     \
+	TRICE_PUT64(v6);                                                     \
+	TRICE_PUT64(v7);                                                     \
+	TRICE_PUT64(v8);                                                     \
+	TRICE_PUT64(v9);                                                     \
+	TRICE_PUT64(v10);                                                    \
+	TRICE_PUT64(v11);
+
+// The following `TRICE` macro definitions uses the C preprocess to concatenate the code behind the sub-macros.
+// The sequence `tid` in this context is executable code `id(n)`, `Id(n)` or `ID(n)` defined in trice.h.
+// This works only with tid=`id(n)`, `Id(n)`, `ID(n)`.
+
+//! TRICE64_0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define TRICE64_0(tid, pFmt) \
+	TRICE_ENTER tid;         \
+	TRICE_CNTC(0);           \
+	TRICE_LEAVE
+
+//! TRICE64_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 64 bit value
+#define TRICE64_1(tid, pFmt, v0) \
+	TRICE_ENTER tid;             \
+	TRICE_CNTC(8);               \
+	TRICE_PUT64_1(v0)            \
+	TRICE_LEAVE
+
+//! TRICE64_2 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v1 are 64 bit values
+#define TRICE64_2(id, pFmt, v0, v1) \
+	TRICE_ENTER id;                 \
+	TRICE_CNTC(16);                 \
+	TRICE_PUT64_2(v0, v1);          \
+	TRICE_LEAVE
+
+//! TRICE64_3 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v2 are 64 bit values
+#define TRICE64_3(id, pFmt, v0, v1, v2) \
+	TRICE_ENTER id;                     \
+	TRICE_CNTC(24);                     \
+	TRICE_PUT64_3(v0, v1, v2);          \
+	TRICE_LEAVE
+
+//! TRICE64_4 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v3 are 64 bit values
+#define TRICE64_4(id, pFmt, v0, v1, v2, v3) \
+	TRICE_ENTER id;                         \
+	TRICE_CNTC(32);                         \
+	TRICE_PUT64_4(v0, v1, v2, v3);          \
+	TRICE_LEAVE
+
+//! TRICE64_5 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v4 are 64 bit values
+#define TRICE64_5(id, pFmt, v0, v1, v2, v3, v4) \
+	TRICE_ENTER id;                             \
+	TRICE_CNTC(40);                             \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);          \
+	TRICE_LEAVE
+
+//! TRICE64_6 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v5 are 64 bit values
+#define TRICE64_6(id, pFmt, v0, v1, v2, v3, v4, v5) \
+	TRICE_ENTER id;                                 \
+	TRICE_CNTC(48);                                 \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+//! TRICE64_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v6 are 64 bit values
+#define TRICE64_7(id, pFmt, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER id;                                     \
+	TRICE_CNTC(56);                                     \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);          \
+	TRICE_LEAVE
+
+//! TRICE64_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 64 bit values
+#define TRICE64_8(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER id;                                         \
+	TRICE_CNTC(64);                                         \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+//! TRICE64_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 64 bit values
+#define TRICE64_9(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER id;                                             \
+	TRICE_CNTC(72);                                             \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);          \
+	TRICE_LEAVE
+
+//! TRICE64_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 64 bit values
+#define TRICE64_10(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER id;                                                  \
+	TRICE_CNTC(80);                                                  \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);          \
+	TRICE_LEAVE
+
+//! TRICE64_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 64 bit values
+#define TRICE64_11(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER id;                                                       \
+	TRICE_CNTC(88);                                                       \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);          \
+	TRICE_LEAVE
+
+//! TRICE64_12 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v11 are 64 bit values
+#define TRICE64_12(id, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER id;                                                            \
+	TRICE_CNTC(96);                                                            \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)           \
+	TRICE_LEAVE

Middlewares/trice/trice64McuOrder.h

@@ -0,0 +1,286 @@
+/*! \file trice64McuOrder.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice64m_0(tid)                                              \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((0 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_LEAVE
+
+#define trice64m_1(tid, v0)                                          \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((8 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_1(v0)                                                \
+	TRICE_LEAVE
+
+#define trice64m_2(tid, v0, v1)                                       \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((16 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_2(v0, v1);                                            \
+	TRICE_LEAVE
+
+#define trice64m_3(tid, v0, v1, v2)                                   \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((24 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_3(v0, v1, v2);                                        \
+	TRICE_LEAVE
+
+#define trice64m_4(tid, v0, v1, v2, v3)                               \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((32 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_4(v0, v1, v2, v3);                                    \
+	TRICE_LEAVE
+
+#define trice64m_5(tid, v0, v1, v2, v3, v4)                           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((40 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);                                \
+	TRICE_LEAVE
+
+#define trice64m_6(tid, v0, v1, v2, v3, v4, v5)                       \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((48 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);                            \
+	TRICE_LEAVE
+
+#define trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6)                   \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((56 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);                        \
+	TRICE_LEAVE
+
+#define trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)               \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((64 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);                    \
+	TRICE_LEAVE
+
+#define trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)           \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((72 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);                \
+	TRICE_LEAVE
+
+#define trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)      \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((80 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);           \
+	TRICE_LEAVE
+
+#define trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((88 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT((96 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid)));      \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice64m_0(tid)                          \
+	TRICE_ENTER                                  \
+	uint16_t ts = TriceStamp16;                  \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid)); \
+	TRICE_PUT((TRICE_CYCLE << 16) | ts);         \
+	TRICE_LEAVE
+
+#define Trice64m_1(tid, v0)                        \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_1(v0)                              \
+	TRICE_LEAVE
+
+#define Trice64m_2(tid, v0, v1)                     \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_2(v0, v1);                          \
+	TRICE_LEAVE
+
+#define Trice64m_3(tid, v0, v1, v2)                 \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_3(v0, v1, v2);                      \
+	TRICE_LEAVE
+
+#define Trice64m_4(tid, v0, v1, v2, v3)             \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(32 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_4(v0, v1, v2, v3);                  \
+	TRICE_LEAVE
+
+#define Trice64m_5(tid, v0, v1, v2, v3, v4)         \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(40 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);              \
+	TRICE_LEAVE
+
+#define Trice64m_6(tid, v0, v1, v2, v3, v4, v5)     \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(48 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+#define Trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER                                     \
+	uint16_t ts = TriceStamp16;                     \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));    \
+	TRICE_PUT(56 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);      \
+	TRICE_LEAVE
+
+#define Trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER                                         \
+	uint16_t ts = TriceStamp16;                         \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));        \
+	TRICE_PUT(64 << 24 | (TRICE_CYCLE << 16) | ts);     \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);      \
+	TRICE_LEAVE
+
+#define Trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));            \
+	TRICE_PUT(72 << 24 | (TRICE_CYCLE << 16) | ts);         \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define Trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                 \
+	TRICE_PUT(80 << 24 | (TRICE_CYCLE << 16) | ts);              \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                      \
+	TRICE_PUT(88 << 24 | (TRICE_CYCLE << 16) | ts);                   \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                           \
+	TRICE_PUT(96 << 24 | (TRICE_CYCLE << 16) | ts);                        \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice64m_0(tid)                                    \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_LEAVE
+
+#define TRice64m_1(tid, v0)                                \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_1(v0)                                      \
+	TRICE_LEAVE
+
+#define TRice64m_2(tid, v0, v1)                             \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(16 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_2(v0, v1);                                  \
+	TRICE_LEAVE
+
+#define TRice64m_3(tid, v0, v1, v2)                         \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(24 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_3(v0, v1, v2);                              \
+	TRICE_LEAVE
+
+#define TRice64m_4(tid, v0, v1, v2, v3)                     \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(32 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_4(v0, v1, v2, v3);                          \
+	TRICE_LEAVE
+
+#define TRice64m_5(tid, v0, v1, v2, v3, v4)                 \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(40 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);                      \
+	TRICE_LEAVE
+
+#define TRice64m_6(tid, v0, v1, v2, v3, v4, v5)             \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(48 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);                  \
+	TRICE_LEAVE
+
+#define TRice64m_7(tid, v0, v1, v2, v3, v4, v5, v6)         \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(56 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);              \
+	TRICE_LEAVE
+
+#define TRice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)     \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(64 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+#define TRice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	uint32_t ts = TriceStamp32;                             \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                 \
+	TRICE_PUT(72 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define TRice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                      \
+	TRICE_PUT(80 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));      \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                           \
+	TRICE_PUT(88 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));           \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                                \
+	TRICE_PUT(96 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));                \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice64McuReverse.h

@@ -0,0 +1,286 @@
+/*! \file trice64McuReverse.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice64m_0(tid)                      \
+	TRICE_ENTER                              \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | idLH); \
+	TRICE_LEAVE
+
+#define trice64m_1(tid, v0)                              \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (8 << 16) | idLH); \
+	TRICE_PUT64_1(v0)                                    \
+	TRICE_LEAVE
+
+#define trice64m_2(tid, v0, v1)                           \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (16 << 16) | idLH); \
+	TRICE_PUT64_2(v0, v1);                                \
+	TRICE_LEAVE
+
+#define trice64m_3(tid, v0, v1, v2)                       \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (24 << 16) | idLH); \
+	TRICE_PUT64_3(v0, v1, v2);                            \
+	TRICE_LEAVE
+
+#define trice64m_4(tid, v0, v1, v2, v3)                   \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (32 << 16) | idLH); \
+	TRICE_PUT64_4(v0, v1, v2, v3);                        \
+	TRICE_LEAVE
+
+#define trice64m_5(tid, v0, v1, v2, v3, v4)               \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (40 << 16) | idLH); \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);                    \
+	TRICE_LEAVE
+
+#define trice64m_6(tid, v0, v1, v2, v3, v4, v5)           \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (48 << 16) | idLH); \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);                \
+	TRICE_LEAVE
+
+#define trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6)       \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (56 << 16) | idLH); \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);            \
+	TRICE_LEAVE
+
+#define trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)   \
+	TRICE_ENTER                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (64 << 16) | idLH); \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);        \
+	TRICE_LEAVE
+
+#define trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                             \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (72 << 16) | idLH);   \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (80 << 16) | idLH);        \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (88 << 16) | idLH);             \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (96 << 16) | idLH);                  \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice64m_0(tid)                         \
+	TRICE_ENTER                                 \
+	uint16_t ts = TriceStamp16;                 \
+	TRICE_PUT(((IdLH) << 16) | IdLH)            \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsL | tsH); \
+	TRICE_LEAVE
+
+#define Trice64m_1(tid, v0)                                 \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsL | tsH); \
+	TRICE_PUT64_1(v0)                                       \
+	TRICE_LEAVE
+
+#define Trice64m_2(tid, v0, v1)                              \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsL | tsH); \
+	TRICE_PUT64_2(v0, v1);                                   \
+	TRICE_LEAVE
+
+#define Trice64m_3(tid, v0, v1, v2)                          \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsL | tsH); \
+	TRICE_PUT64_3(v0, v1, v2);                               \
+	TRICE_LEAVE
+
+#define Trice64m_4(tid, v0, v1, v2, v3)                      \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (32 << 16) | tsL | tsH); \
+	TRICE_PUT64_4(v0, v1, v2, v3);                           \
+	TRICE_LEAVE
+
+#define Trice64m_5(tid, v0, v1, v2, v3, v4)                  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (40 << 16) | tsL | tsH); \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);                       \
+	TRICE_LEAVE
+
+#define Trice64m_6(tid, v0, v1, v2, v3, v4, v5)              \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (48 << 16) | tsL | tsH); \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);                   \
+	TRICE_LEAVE
+
+#define Trice64m_7(tid, v0, v1, v2, v3, v4, v5, v6)          \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (56 << 16) | tsL | tsH); \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);               \
+	TRICE_LEAVE
+
+#define Trice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)      \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (64 << 16) | tsL | tsH); \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+#define Trice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)  \
+	TRICE_ENTER                                              \
+	uint16_t ts = TriceStamp16;                              \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (72 << 16) | tsL | tsH); \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);       \
+	TRICE_LEAVE
+
+#define Trice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint16_t ts = TriceStamp16;                                  \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (80 << 16) | tsL | tsH);     \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint16_t ts = TriceStamp16;                                       \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                  \
+	TRICE_PUT((TRICE_CYCLE << 24) | (88 << 16) | tsL | tsH);          \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint16_t ts = TriceStamp16;                                            \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                       \
+	TRICE_PUT((TRICE_CYCLE << 24) | (96 << 16) | tsL | tsH);               \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice64m_0(tid)                                      \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH);                           \
+	TRICE_PUT((TRICE_CYCLE << 24) | (0 << 16) | tsLL | tsLH) \
+	TRICE_LEAVE
+
+#define TRice64m_1(tid, v0)                                  \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_1(v0)                                        \
+	TRICE_LEAVE
+
+#define TRice64m_2(tid, v0, v1)                               \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (16 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_2(v0, v1);                                    \
+	TRICE_LEAVE
+
+#define TRice64m_3(tid, v0, v1, v2)                           \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (24 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_3(v0, v1, v2);                                \
+	TRICE_LEAVE
+
+#define TRice64m_4(tid, v0, v1, v2, v3)                       \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (32 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_4(v0, v1, v2, v3);                            \
+	TRICE_LEAVE
+
+#define TRice64m_5(tid, v0, v1, v2, v3, v4)                   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (40 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_5(v0, v1, v2, v3, v4);                        \
+	TRICE_LEAVE
+
+#define TRice64m_6(tid, v0, v1, v2, v3, v4, v5)               \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (48 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_6(v0, v1, v2, v3, v4, v5);                    \
+	TRICE_LEAVE
+
+#define TRice64m_7(tid, v0, v1, v2, v3, v4, v5, v6)           \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (56 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_7(v0, v1, v2, v3, v4, v5, v6);                \
+	TRICE_LEAVE
+
+#define TRice64m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)       \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (64 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_8(v0, v1, v2, v3, v4, v5, v6, v7);            \
+	TRICE_LEAVE
+
+#define TRice64m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)   \
+	TRICE_ENTER                                               \
+	uint32_t ts = TriceStamp32;                               \
+	TRICE_PUT(tsHL | tsHH | IDLH)                             \
+	TRICE_PUT((TRICE_CYCLE << 24) | (72 << 16) | tsLL | tsLH) \
+	TRICE_PUT64_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);        \
+	TRICE_LEAVE
+
+#define TRice64m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                  \
+	uint32_t ts = TriceStamp32;                                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                \
+	TRICE_PUT((TRICE_CYCLE << 24) | (80 << 16) | tsLL | tsLH)    \
+	TRICE_PUT64_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice64m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                       \
+	uint32_t ts = TriceStamp32;                                       \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                     \
+	TRICE_PUT((TRICE_CYCLE << 24) | (88 << 16) | tsLL | tsLH)         \
+	TRICE_PUT64_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice64m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                            \
+	uint32_t ts = TriceStamp32;                                            \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                          \
+	TRICE_PUT((TRICE_CYCLE << 24) | (96 << 16) | tsLL | tsLH)              \
+	TRICE_PUT64_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice8.c

@@ -0,0 +1,560 @@
+//! \file trice8.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//! ///////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+// lint -e529  Warning 529: Symbol '_SEGGER_RTT__LockState' not subsequently referenced
+// lint -e701  Info 701: Shift left of signed quantity (int)
+
+#if TRICE_8_BIT_SUPPORT == 1 && TRICE_OFF == 0
+
+// without stamp 8-bit values functions
+#ifndef ENABLE_trice8fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 0 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_0 0 //!< Disables no-stamp 8-bit 0 values functions.
+#else
+#define ENABLE_trice8fn_0 1 //!< Enables  no-stamp 8-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 1 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_1 0 //!< Disables no-stamp 8-bit 1 values functions.
+#else
+#define ENABLE_trice8fn_1 1 //!< Enables  no-stamp 8-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 2 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_2 0 //!< Disables no-stamp 8-bit 2 values functions.
+#else
+#define ENABLE_trice8fn_2 1 //!< Enables  no-stamp 8-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 3 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_3 0 //!< Disables no-stamp 8-bit 3 values functions.
+#else
+#define ENABLE_trice8fn_3 1 //!< Enables  no-stamp 8-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 4 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_4 0 //!< Disables no-stamp 8-bit 4 values functions.
+#else
+#define ENABLE_trice8fn_4 1 //!< Enables  no-stamp 8-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 5 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_5 0 //!< Disables no-stamp 8-bit 5 values functions.
+#else
+#define ENABLE_trice8fn_5 1 //!< Enables  no-stamp 8-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 6 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_6 0 //!< Disables no-stamp 8-bit 6 values functions.
+#else
+#define ENABLE_trice8fn_6 1 //!< Enables  no-stamp 8-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 7 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_7 0 //!< Disables no-stamp 8-bit 7 values functions.
+#else
+#define ENABLE_trice8fn_7 1 //!< Enables  no-stamp 8-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 8 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_8 0 //!< Disables no-stamp 8-bit 8 values functions.
+#else
+#define ENABLE_trice8fn_8 1 //!< Enables  no-stamp 8-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 9 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_9 0 //!< Disables no-stamp 8-bit 9 values functions.
+#else
+#define ENABLE_trice8fn_9 1 //!< Enables  no-stamp 8-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 10 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_10 0 //!< Disables no-stamp 8-bit 10 values functions.
+#else
+#define ENABLE_trice8fn_10 1 //!< Enables  no-stamp 8-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 11 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_11 0 //!< Disables no-stamp 8-bit 11 values functions.
+#else
+#define ENABLE_trice8fn_11 1 //!< Enables  no-stamp 8-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_trice8fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((0 + 4 + 12 * 1) + 3) & ~3)
+#define ENABLE_trice8fn_12 0 //!< Disables no-stamp 8-bit 12 values functions.
+#else
+#define ENABLE_trice8fn_12 1 //!< Enables  no-stamp 8-bit 12 values functions.
+#endif
+#endif
+
+// with 16-bit-stamp 8-bit values functions (16-bit timestamps need 4 bytes for allocation reasons)
+#ifndef ENABLE_Trice8fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_0 0 //!< Disables 16-bit-stamp 8-bit 0 values functions.
+#else
+#define ENABLE_Trice8fn_0 1 //!< Enables  16-bit-stamp 8-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_1 0 //!< Disables 16-bit-stamp 8-bit 1 values functions.
+#else
+#define ENABLE_Trice8fn_1 1 //!< Enables  16-bit-stamp 8-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_2 0 //!< Disables 16-bit-stamp 8-bit 2 values functions.
+#else
+#define ENABLE_Trice8fn_2 1 //!< Enables  16-bit-stamp 8-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_3 0 //!< Disables 16-bit-stamp 8-bit 3 values functions.
+#else
+#define ENABLE_Trice8fn_3 1 //!< Enables  16-bit-stamp 8-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_4 0 //!< Disables 16-bit-stamp 8-bit 4 values functions.
+#else
+#define ENABLE_Trice8fn_4 1 //!< Enables  16-bit-stamp 8-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_5 0 //!< Disables 16-bit-stamp 8-bit 5 values functions.
+#else
+#define ENABLE_Trice8fn_5 1 //!< Enables  16-bit-stamp 8-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_6 0 //!< Disables 16-bit-stamp 8-bit 6 values functions.
+#else
+#define ENABLE_Trice8fn_6 1 //!< Enables  16-bit-stamp 8-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_7 0 //!< Disables 16-bit-stamp 8-bit 7 values functions.
+#else
+#define ENABLE_Trice8fn_7 1 //!< Enables  16-bit-stamp 8-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_8 0 //!< Disables 16-bit-stamp 8-bit 8 values functions.
+#else
+#define ENABLE_Trice8fn_8 1 //!< Enables  16-bit-stamp 8-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_9 0 //!< Disables 16-bit-stamp 8-bit 9 values functions.
+#else
+#define ENABLE_Trice8fn_9 1 //!< Enables  16-bit-stamp 8-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_10 0 //!< Disables 16-bit-stamp 8-bit 10 values functions.
+#else
+#define ENABLE_Trice8fn_10 1 //!< Enables  16-bit-stamp 8-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_11 0 //!< Disables 16-bit-stamp 8-bit 11 values functions.
+#else
+#define ENABLE_Trice8fn_11 1 //!< Enables  16-bit-stamp 8-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_Trice8fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 1) + 3) & ~3)
+#define ENABLE_Trice8fn_12 0 //!< Disables 16-bit-stamp 8-bit 12 values functions.
+#else
+#define ENABLE_Trice8fn_12 1 //!< Enables  16-bit-stamp 8-bit 12 values functions.
+#endif
+#endif
+
+// with 32-bit-stamp 8-bit values functions
+#ifndef ENABLE_TRice8fn_0
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 0 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_0 0 //!< Disables 32-bit-stamp 8-bit 0 values functions.
+#else
+#define ENABLE_TRice8fn_0 1 //!< Enables  32-bit-stamp 8-bit 0 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_1
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 1 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_1 0 //!< Disables 32-bit-stamp 8-bit 1 values functions.
+#else
+#define ENABLE_TRice8fn_1 1 //!< Enables  32-bit-stamp 8-bit 1 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_2
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 2 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_2 0 //!< Disables 32-bit-stamp 8-bit 2 values functions.
+#else
+#define ENABLE_TRice8fn_2 1 //!< Enables  32-bit-stamp 8-bit 2 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_3
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 3 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_3 0 //!< Disables 32-bit-stamp 8-bit 3 values functions.
+#else
+#define ENABLE_TRice8fn_3 1 //!< Enables  32-bit-stamp 8-bit 3 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_4
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 4 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_4 0 //!< Disables 32-bit-stamp 8-bit 4 values functions.
+#else
+#define ENABLE_TRice8fn_4 1 //!< Enables  32-bit-stamp 8-bit 4 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_5
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 5 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_5 0 //!< Disables 32-bit-stamp 8-bit 5 values functions.
+#else
+#define ENABLE_TRice8fn_5 1 //!< Enables  32-bit-stamp 8-bit 5 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_6
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 6 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_6 0 //!< Disables 32-bit-stamp 8-bit 6 values functions.
+#else
+#define ENABLE_TRice8fn_6 1 //!< Enables  32-bit-stamp 8-bit 6 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_7
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 7 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_7 0 //!< Disables 32-bit-stamp 8-bit 7 values functions.
+#else
+#define ENABLE_TRice8fn_7 1 //!< Enables  32-bit-stamp 8-bit 7 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_8
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 8 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_8 0 //!< Disables 32-bit-stamp 8-bit 8 values functions.
+#else
+#define ENABLE_TRice8fn_8 1 //!< Enables  32-bit-stamp 8-bit 8 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_9
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 9 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_9 0 //!< Disables 32-bit-stamp 8-bit 9 values functions.
+#else
+#define ENABLE_TRice8fn_9 1 //!< Enables  32-bit-stamp 8-bit 9 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_10
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 10 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_10 0 //!< Disables 32-bit-stamp 8-bit 10 values functions.
+#else
+#define ENABLE_TRice8fn_10 1 //!< Enables  32-bit-stamp 8-bit 10 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_11
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 11 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_11 0 //!< Disables 32-bit-stamp 8-bit 11 values functions.
+#else
+#define ENABLE_TRice8fn_11 1 //!< Enables  32-bit-stamp 8-bit 11 values functions.
+#endif
+#endif
+
+#ifndef ENABLE_TRice8fn_12
+#if TRICE_SINGLE_MAX_SIZE < (((4 + 4 + 12 * 1) + 3) & ~3)
+#define ENABLE_TRice8fn_12 0 //!< Disables 32-bit-stamp 8-bit 12 values functions.
+#else
+#define ENABLE_TRice8fn_12 1 //!< Enables  32-bit-stamp 8-bit 12 values functions.
+#endif
+#endif
+
+#if ENABLE_trice8fn_0
+void trice8fn_0(uint16_t tid) {
+	trice8m_0(tid);
+}
+#endif
+
+#if ENABLE_trice8fn_1
+void trice8fn_1(uint16_t tid, uint8_t v0) {
+	trice8m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_trice8fn_2
+void trice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1) {
+	trice8m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_trice8fn_3
+void trice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2) {
+	trice8m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_trice8fn_4
+void trice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3) {
+	trice8m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_trice8fn_5
+void trice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4) {
+	trice8m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_trice8fn_6
+void trice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5) {
+	trice8m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_trice8fn_7
+void trice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6) {
+	trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_trice8fn_8
+void trice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7) {
+	trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_trice8fn_9
+void trice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8) {
+	trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_trice8fn_10
+void trice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9) {
+	trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_trice8fn_11
+void trice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10) {
+	trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_trice8fn_12
+void trice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11) {
+	trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_Trice8fn_0
+void Trice8fn_0(uint16_t tid) {
+	Trice8m_0(tid);
+}
+#endif
+
+#if ENABLE_Trice8fn_1
+void Trice8fn_1(uint16_t tid, uint8_t v0) {
+	Trice8m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_Trice8fn_2
+void Trice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1) {
+	Trice8m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_Trice8fn_3
+void Trice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2) {
+	Trice8m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_Trice8fn_4
+void Trice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3) {
+	Trice8m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_Trice8fn_5
+void Trice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4) {
+	Trice8m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_Trice8fn_6
+void Trice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5) {
+	Trice8m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_Trice8fn_7
+void Trice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6) {
+	Trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_Trice8fn_8
+void Trice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7) {
+	Trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_Trice8fn_9
+void Trice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8) {
+	Trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_Trice8fn_10
+void Trice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9) {
+	Trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_Trice8fn_11
+void Trice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10) {
+	Trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_Trice8fn_12
+void Trice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11) {
+	Trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#if ENABLE_TRice8fn_0
+void TRice8fn_0(uint16_t tid) {
+	TRice8m_0(tid);
+}
+#endif
+
+#if ENABLE_TRice8fn_1
+void TRice8fn_1(uint16_t tid, uint8_t v0) {
+	TRice8m_1(tid, v0);
+}
+#endif
+
+#if ENABLE_TRice8fn_2
+void TRice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1) {
+	TRice8m_2(tid, v0, v1);
+}
+#endif
+
+#if ENABLE_TRice8fn_3
+void TRice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2) {
+	TRice8m_3(tid, v0, v1, v2);
+}
+#endif
+
+#if ENABLE_TRice8fn_4
+void TRice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3) {
+	TRice8m_4(tid, v0, v1, v2, v3);
+}
+#endif
+
+#if ENABLE_TRice8fn_5
+void TRice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4) {
+	TRice8m_5(tid, v0, v1, v2, v3, v4);
+}
+#endif
+
+#if ENABLE_TRice8fn_6
+void TRice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5) {
+	TRice8m_6(tid, v0, v1, v2, v3, v4, v5);
+}
+#endif
+
+#if ENABLE_TRice8fn_7
+void TRice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6) {
+	TRice8m_7(tid, v0, v1, v2, v3, v4, v5, v6);
+}
+#endif
+
+#if ENABLE_TRice8fn_8
+void TRice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7) {
+	TRice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7);
+}
+#endif
+
+#if ENABLE_TRice8fn_9
+void TRice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8) {
+	TRice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+}
+#endif
+
+#if ENABLE_TRice8fn_10
+void TRice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9) {
+	TRice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+}
+#endif
+
+#if ENABLE_TRice8fn_11
+void TRice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10) {
+	TRice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+#endif
+
+#if ENABLE_TRice8fn_12
+void TRice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11) {
+	TRice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+#endif
+
+#endif // #if TRICE_8_BIT_SUPPORT == 1 && TRICE_OFF == 0

Middlewares/trice/trice8.h

@@ -0,0 +1,246 @@
+/*! \file Trice8.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 8
+
+// #define TRICE_0  TRICE8_0  //!< Default parameter bit width for 0  parameter count TRICE is 8.
+#define TRICE_1 TRICE8_1   //!< Default parameter bit width for 1  parameter count TRICE is 8.
+#define TRICE_2 TRICE8_2   //!< Default parameter bit width for 2  parameter count TRICE is 8.
+#define TRICE_3 TRICE8_3   //!< Default parameter bit width for 3  parameter count TRICE is 8.
+#define TRICE_4 TRICE8_4   //!< Default parameter bit width for 4  parameter count TRICE is 8.
+#define TRICE_5 TRICE8_5   //!< Default parameter bit width for 5  parameter count TRICE is 8.
+#define TRICE_6 TRICE8_6   //!< Default parameter bit width for 6  parameter count TRICE is 8.
+#define TRICE_7 TRICE8_7   //!< Default parameter bit width for 7  parameter count TRICE is 8.
+#define TRICE_8 TRICE8_8   //!< Default parameter bit width for 8  parameter count TRICE is 8.
+#define TRICE_9 TRICE8_9   //!< Default parameter bit width for 9  parameter count TRICE is 8.
+#define TRICE_10 TRICE8_10 //!< Default parameter bit width for 10 parameter count TRICE is 8.
+#define TRICE_11 TRICE8_11 //!< Default parameter bit width for 11 parameter count TRICE is 8.
+#define TRICE_12 TRICE8_12 //!< Default parameter bit width for 12 parameter count TRICE is 8.
+
+// #define trice_0  trice8_0  //!< Default parameter bit width for 0  parameter count trice is 8.
+#define trice_1 trice8_1   //!< Default parameter bit width for 1  parameter count trice is 8.
+#define trice_2 trice8_2   //!< Default parameter bit width for 2  parameter count trice is 8.
+#define trice_3 trice8_3   //!< Default parameter bit width for 3  parameter count trice is 8.
+#define trice_4 trice8_4   //!< Default parameter bit width for 4  parameter count trice is 8.
+#define trice_5 trice8_5   //!< Default parameter bit width for 5  parameter count trice is 8.
+#define trice_6 trice8_6   //!< Default parameter bit width for 6  parameter count trice is 8.
+#define trice_7 trice8_7   //!< Default parameter bit width for 7  parameter count trice is 8.
+#define trice_8 trice8_8   //!< Default parameter bit width for 8  parameter count trice is 8.
+#define trice_9 trice8_9   //!< Default parameter bit width for 9  parameter count trice is 8.
+#define trice_10 trice8_10 //!< Default parameter bit width for 10 parameter count trice is 8.
+#define trice_11 trice8_11 //!< Default parameter bit width for 11 parameter count trice is 8.
+#define trice_12 trice8_12 //!< Default parameter bit width for 12 parameter count trice is 8.
+
+// #define Trice_0  Trice8_0  //!< Default parameter bit width for 1  parameter count Trice is 8.
+#define Trice_1 Trice8_1   //!< Default parameter bit width for 1  parameter count Trice is 8.
+#define Trice_2 Trice8_2   //!< Default parameter bit width for 2  parameter count Trice is 8.
+#define Trice_3 Trice8_3   //!< Default parameter bit width for 3  parameter count Trice is 8.
+#define Trice_4 Trice8_4   //!< Default parameter bit width for 4  parameter count Trice is 8.
+#define Trice_5 Trice8_5   //!< Default parameter bit width for 5  parameter count Trice is 8.
+#define Trice_6 Trice8_6   //!< Default parameter bit width for 6  parameter count Trice is 8.
+#define Trice_7 Trice8_7   //!< Default parameter bit width for 7  parameter count Trice is 8.
+#define Trice_8 Trice8_8   //!< Default parameter bit width for 8  parameter count Trice is 8.
+#define Trice_9 Trice8_9   //!< Default parameter bit width for 9  parameter count Trice is 8.
+#define Trice_10 Trice8_10 //!< Default parameter bit width for 10 parameter count Trice is 8.
+#define Trice_11 Trice8_11 //!< Default parameter bit width for 11 parameter count Trice is 8.
+#define Trice_12 Trice8_12 //!< Default parameter bit width for 12 parameter count Trice is 8.
+
+// #define TRice_0  TRice8_0  //!< Default parameter bit width for 1  parameter count TRice is 8.
+#define TRice_1 TRice8_1   //!< Default parameter bit width for 1  parameter count TRice is 8.
+#define TRice_2 TRice8_2   //!< Default parameter bit width for 2  parameter count TRice is 8.
+#define TRice_3 TRice8_3   //!< Default parameter bit width for 3  parameter count TRice is 8.
+#define TRice_4 TRice8_4   //!< Default parameter bit width for 4  parameter count TRice is 8.
+#define TRice_5 TRice8_5   //!< Default parameter bit width for 5  parameter count TRice is 8.
+#define TRice_6 TRice8_6   //!< Default parameter bit width for 6  parameter count TRice is 8.
+#define TRice_7 TRice8_7   //!< Default parameter bit width for 7  parameter count TRice is 8.
+#define TRice_8 TRice8_8   //!< Default parameter bit width for 8  parameter count TRice is 8.
+#define TRice_9 TRice8_9   //!< Default parameter bit width for 9  parameter count TRice is 8.
+#define TRice_10 TRice8_10 //!< Default parameter bit width for 10 parameter count TRice is 8.
+#define TRice_11 TRice8_11 //!< Default parameter bit width for 11 parameter count TRice is 8.
+#define TRice_12 TRice8_12 //!< Default parameter bit width for 12 parameter count TRice is 8.
+
+#endif // #if TRICE_DEFAULT_PARAMETER_BIT_WIDTH == 8
+
+//! TRICE8 inlining code for up to 12 8-bit parameters.
+#define TRICE8(tid, fmt, ...) TRICE_CONCAT2(TRICE8_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+
+//! TRICE8_B expects inside pFmt only one format specifier, which is used n times by using pFmt n times.
+//!  It is usable for showing n 8-bit values.
+#define TRICE8_B TRICE_N
+
+//! TRICE8_F expects inside pFmt just a string which is assumed to be a remote function name.
+//! \li The trice tool displays the pFmt string followed by n times (value i).
+//! \li The idea behind is to generate an id - function pointer referece list from the generated til.json file to compile it into a remote device and execute the inside pFmt named function remotely.
+//! \li Look for "TRICE8_F example" inside triceCheck.c.
+//!  Look for "TRICE8_F example" inside triceCheck.c.
+#define TRICE8_F TRICE8_B
+
+#define TRICE_BYTE0(v) ((uint8_t)(v))                       //!< TRICE_BYTE0(v) is the 8-bit value v moved to the LL position in a 32-bit value 0xHH_HL_LH_LL.
+#define TRICE_BYTE1(v) (0x0000FF00 & ((uint32_t)(v) << 8))  //!< TRICE_BYTE1(v) is the 8-bit value v moved to the LH position in a 32-bit value 0xHH_HL_LH_LL.
+#define TRICE_BYTE2(v) (0x00FF0000 & ((uint32_t)(v) << 16)) //!< TRICE_BYTE2(v) is the 8-bit value v moved to the HL position in a 32-bit value 0xHH_HL_LH_LL.
+#define TRICE_BYTE3(v) ((uint32_t)(v) << 24)                //!< TRICE_BYTE3(v) is the 8-bit value v moved to the HH position in a 32-bit value 0xHH_HL_LH_LL.
+
+//! TRICE_PUT8_1 transfers a single 8-bit parameter value to the Trice buffer.
+#define TRICE_PUT8_1(v0) TRICE_PUT(TRICE_BYTE0(v0));
+
+#define TRICE_PUT8_2(v0, v1) TRICE_PUT(TRICE_BYTE1(v1) | TRICE_BYTE0(v0));
+
+#define TRICE_PUT8_3(v0, v1, v2) TRICE_PUT(TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0));
+
+#define TRICE_PUT8_4(v0, v1, v2, v3) TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0));
+
+#define TRICE_PUT8_5(v0, v1, v2, v3, v4)                                              \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE0(v4));
+
+#define TRICE_PUT8_6(v0, v1, v2, v3, v4, v5)                                          \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE1(v5) | TRICE_BYTE0(v4));
+
+#define TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6)                                      \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4));
+
+#define TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7)                                  \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE3(v7) | TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4));
+
+#define TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8)                              \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE3(v7) | TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4)); \
+	TRICE_PUT(TRICE_BYTE0(v8));
+
+#define TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)                         \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE3(v7) | TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4)); \
+	TRICE_PUT(TRICE_BYTE1(v9) | TRICE_BYTE0(v8));
+
+#define TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)                    \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE3(v7) | TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4)); \
+	TRICE_PUT(TRICE_BYTE2(v10) | TRICE_BYTE1(v9) | TRICE_BYTE0(v8));
+
+#define TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)               \
+	TRICE_PUT(TRICE_BYTE3(v3) | TRICE_BYTE2(v2) | TRICE_BYTE1(v1) | TRICE_BYTE0(v0)); \
+	TRICE_PUT(TRICE_BYTE3(v7) | TRICE_BYTE2(v6) | TRICE_BYTE1(v5) | TRICE_BYTE0(v4)); \
+	TRICE_PUT(TRICE_BYTE3(v11) | TRICE_BYTE2(v10) | TRICE_BYTE1(v9) | TRICE_BYTE0(v8));
+
+// The following `TRICE` macro definitions are using the C preprocess to concatenate the code behind the sub-macros.
+// The sequence `tid` in this context is executable code `id(n)`, `Id(n)` or `ID(n)` defined in trice.h.
+// This works only with tid=`id(n)`, `Id(n)`, `ID(n)`.
+
+//! TRICE8_0 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+#define TRICE8_0(tid, pFmt) \
+	TRICE_ENTER tid;        \
+	TRICE_CNTC(0);          \
+	TRICE_LEAVE
+
+//! TRICE8_1 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 a 8 bit bit value
+#define TRICE8_1(tid, pFmt, v0) \
+	TRICE_ENTER tid;            \
+	TRICE_CNTC(1);              \
+	TRICE_PUT8_1(v0)            \
+	TRICE_LEAVE
+
+//! TRICE8_2 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v1 are 8 bit bit values
+#define TRICE8_2(tid, pFmt, v0, v1) \
+	TRICE_ENTER tid;                \
+	TRICE_CNTC(2);                  \
+	TRICE_PUT8_2(v0, v1);           \
+	TRICE_LEAVE
+
+//! TRICE8_3 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v2 are 8 bit bit values
+#define TRICE8_3(tid, pFmt, v0, v1, v2) \
+	TRICE_ENTER tid;                    \
+	TRICE_CNTC(3);                      \
+	TRICE_PUT8_3(v0, v1, v2);           \
+	TRICE_LEAVE
+
+//! TRICE8_4 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v3 are 8 bit bit values
+#define TRICE8_4(tid, pFmt, v0, v1, v2, v3) \
+	TRICE_ENTER tid;                        \
+	TRICE_CNTC(4);                          \
+	TRICE_PUT8_4(v0, v1, v2, v3);           \
+	TRICE_LEAVE
+
+//! TRICE8_5 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v4 are 8 bit bit values
+#define TRICE8_5(tid, pFmt, v0, v1, v2, v3, v4) \
+	TRICE_ENTER tid;                            \
+	TRICE_CNTC(5);                              \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);           \
+	TRICE_LEAVE
+
+//! TRICE8_6 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v5 are 8 bit bit values
+#define TRICE8_6(tid, pFmt, v0, v1, v2, v3, v4, v5) \
+	TRICE_ENTER tid;                                \
+	TRICE_CNTC(6);                                  \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);           \
+	TRICE_LEAVE
+
+//! TRICE8_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v6 are 8 bit bit values
+#define TRICE8_7(tid, pFmt, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER tid;                                    \
+	TRICE_CNTC(7);                                      \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);           \
+	TRICE_LEAVE
+
+//! TRICE8_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 8 bit bit values
+#define TRICE8_8(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER tid;                                        \
+	TRICE_CNTC(8);                                          \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+//! TRICE8_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 8 bit bit values
+#define TRICE8_9(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER tid;                                            \
+	TRICE_CNTC(9);                                              \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);           \
+	TRICE_LEAVE
+
+//! TRICE8_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 8 bit bit values
+#define TRICE8_10(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER tid;                                                 \
+	TRICE_CNTC(10);                                                  \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);           \
+	TRICE_LEAVE
+
+//! TRICE8_8 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v7 are 8 bit bit values
+#define TRICE8_11(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER tid;                                                      \
+	TRICE_CNTC(11);                                                       \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);           \
+	TRICE_LEAVE
+
+//! TRICE8_12 writes trice data as fast as possible in a buffer.
+//! \param tid is a 16 bit Trice id in upper 2 bytes of a 32 bit value
+//! \param v0 - v11 are 8 bit bit values
+#define TRICE8_12(tid, pFmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER tid;                                                           \
+	TRICE_CNTC(12);                                                            \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)            \
+	TRICE_LEAVE

Middlewares/trice/trice8McuOrder.h

@@ -0,0 +1,286 @@
+/*! \file trice8McuOrder.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice8m_0(tid)                                               \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((0 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_LEAVE
+
+#define trice8m_1(tid, v0)                                           \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((1 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_1(v0)                                                 \
+	TRICE_LEAVE
+
+#define trice8m_2(tid, v0, v1)                                       \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((2 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_2(v0, v1);                                            \
+	TRICE_LEAVE
+
+#define trice8m_3(tid, v0, v1, v2)                                   \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((3 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_3(v0, v1, v2);                                        \
+	TRICE_LEAVE
+
+#define trice8m_4(tid, v0, v1, v2, v3)                               \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((4 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_4(v0, v1, v2, v3);                                    \
+	TRICE_LEAVE
+
+#define trice8m_5(tid, v0, v1, v2, v3, v4)                           \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((5 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);                                \
+	TRICE_LEAVE
+
+#define trice8m_6(tid, v0, v1, v2, v3, v4, v5)                       \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((6 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);                            \
+	TRICE_LEAVE
+
+#define trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6)                   \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((7 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);                        \
+	TRICE_LEAVE
+
+#define trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)               \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((8 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);                    \
+	TRICE_LEAVE
+
+#define trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)           \
+	TRICE_ENTER                                                      \
+	TRICE_PUT((9 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);                \
+	TRICE_LEAVE
+
+#define trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)       \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((10 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);            \
+	TRICE_LEAVE
+
+#define trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)  \
+	TRICE_ENTER                                                       \
+	TRICE_PUT((11 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid))); \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);       \
+	TRICE_LEAVE
+
+#define trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	TRICE_PUT((12 << 24) | ((TRICE_CYCLE) << 16) | (0x4000 | (tid)));     \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice8m_0(tid)                             \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_LEAVE
+
+#define Trice8m_1(tid, v0)                         \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(1 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_1(v0)                               \
+	TRICE_LEAVE
+
+#define Trice8m_2(tid, v0, v1)                     \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(2 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_2(v0, v1);                          \
+	TRICE_LEAVE
+
+#define Trice8m_3(tid, v0, v1, v2)                 \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(3 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_3(v0, v1, v2);                      \
+	TRICE_LEAVE
+
+#define Trice8m_4(tid, v0, v1, v2, v3)             \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_4(v0, v1, v2, v3);                  \
+	TRICE_LEAVE
+
+#define Trice8m_5(tid, v0, v1, v2, v3, v4)         \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(5 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);              \
+	TRICE_LEAVE
+
+#define Trice8m_6(tid, v0, v1, v2, v3, v4, v5)     \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(6 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);          \
+	TRICE_LEAVE
+
+#define Trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6) \
+	TRICE_ENTER                                    \
+	uint16_t ts = TriceStamp16;                    \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));   \
+	TRICE_PUT(7 << 24 | (TRICE_CYCLE << 16) | ts); \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);      \
+	TRICE_LEAVE
+
+#define Trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7) \
+	TRICE_ENTER                                        \
+	uint16_t ts = TriceStamp16;                        \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));       \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | ts);     \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);      \
+	TRICE_LEAVE
+
+#define Trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                            \
+	uint16_t ts = TriceStamp16;                            \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));           \
+	TRICE_PUT(9 << 24 | (TRICE_CYCLE << 16) | ts);         \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define Trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                 \
+	uint16_t ts = TriceStamp16;                                 \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                \
+	TRICE_PUT(10 << 24 | (TRICE_CYCLE << 16) | ts);             \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                      \
+	uint16_t ts = TriceStamp16;                                      \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                     \
+	TRICE_PUT(11 << 24 | (TRICE_CYCLE << 16) | ts);                  \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	uint16_t ts = TriceStamp16;                                           \
+	TRICE_PUT(0x80008000 | (tid << 16) | (tid));                          \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | ts);                       \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice8m_0(tid)                                     \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(0 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_LEAVE
+
+#define TRice8m_1(tid, v0)                                 \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(1 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_1(v0)                                       \
+	TRICE_LEAVE
+
+#define TRice8m_2(tid, v0, v1)                             \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(2 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_2(v0, v1);                                  \
+	TRICE_LEAVE
+
+#define TRice8m_3(tid, v0, v1, v2)                         \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(3 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_3(v0, v1, v2);                              \
+	TRICE_LEAVE
+
+#define TRice8m_4(tid, v0, v1, v2, v3)                     \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(4 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_4(v0, v1, v2, v3);                          \
+	TRICE_LEAVE
+
+#define TRice8m_5(tid, v0, v1, v2, v3, v4)                 \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(5 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);                      \
+	TRICE_LEAVE
+
+#define TRice8m_6(tid, v0, v1, v2, v3, v4, v5)             \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(6 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);                  \
+	TRICE_LEAVE
+
+#define TRice8m_7(tid, v0, v1, v2, v3, v4, v5, v6)         \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(7 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);              \
+	TRICE_LEAVE
+
+#define TRice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)     \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(8 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);          \
+	TRICE_LEAVE
+
+#define TRice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                            \
+	uint32_t ts = TriceStamp32;                            \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                \
+	TRICE_PUT(9 << 24 | (TRICE_CYCLE << 16) | (ts >> 16)); \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define TRice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                 \
+	uint32_t ts = TriceStamp32;                                 \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                     \
+	TRICE_PUT(10 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));     \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                      \
+	uint32_t ts = TriceStamp32;                                      \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                          \
+	TRICE_PUT(11 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));          \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	uint32_t ts = TriceStamp32;                                           \
+	TRICE_PUT((ts << 16) | 0xc000 | (tid));                               \
+	TRICE_PUT(12 << 24 | (TRICE_CYCLE << 16) | (ts >> 16));               \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/trice8McuReverse.h

@@ -0,0 +1,286 @@
+/*! \file trice8McuReverse.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#define trice8m_0(tid)                       \
+	TRICE_ENTER                              \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | idLH); \
+	TRICE_LEAVE
+
+#define trice8m_1(tid, v0)                               \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (1 << 16) | idLH); \
+	TRICE_PUT8_1(v0)                                     \
+	TRICE_LEAVE
+
+#define trice8m_2(tid, v0, v1)                           \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (2 << 16) | idLH); \
+	TRICE_PUT8_2(v0, v1);                                \
+	TRICE_LEAVE
+
+#define trice8m_3(tid, v0, v1, v2)                       \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (3 << 16) | idLH); \
+	TRICE_PUT8_3(v0, v1, v2);                            \
+	TRICE_LEAVE
+
+#define trice8m_4(tid, v0, v1, v2, v3)                   \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (4 << 16) | idLH); \
+	TRICE_PUT8_4(v0, v1, v2, v3);                        \
+	TRICE_LEAVE
+
+#define trice8m_5(tid, v0, v1, v2, v3, v4)               \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (5 << 16) | idLH); \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);                    \
+	TRICE_LEAVE
+
+#define trice8m_6(tid, v0, v1, v2, v3, v4, v5)           \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (6 << 16) | idLH); \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);                \
+	TRICE_LEAVE
+
+#define trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6)       \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (7 << 16) | idLH); \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);            \
+	TRICE_LEAVE
+
+#define trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)   \
+	TRICE_ENTER                                          \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (8 << 16) | idLH); \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);        \
+	TRICE_LEAVE
+
+#define trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8) \
+	TRICE_ENTER                                            \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (9 << 16) | idLH);   \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);      \
+	TRICE_LEAVE
+
+#define trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                 \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (10 << 16) | idLH);       \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                      \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (11 << 16) | idLH);            \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	TRICE_PUT(((TRICE_CYCLE) << 24) | (12 << 16) | idLH);                 \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define Trice8m_0(tid)                          \
+	TRICE_ENTER                                 \
+	uint16_t ts = TriceStamp16;                 \
+	TRICE_PUT(((IdLH) << 16) | IdLH)            \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsL | tsH); \
+	TRICE_LEAVE
+
+#define Trice8m_1(tid, v0)                                  \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (1 << 16) | tsL | tsH); \
+	TRICE_PUT8_1(v0)                                        \
+	TRICE_LEAVE
+
+#define Trice8m_2(tid, v0, v1)                              \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (2 << 16) | tsL | tsH); \
+	TRICE_PUT8_2(v0, v1);                                   \
+	TRICE_LEAVE
+
+#define Trice8m_3(tid, v0, v1, v2)                          \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (3 << 16) | tsL | tsH); \
+	TRICE_PUT8_3(v0, v1, v2);                               \
+	TRICE_LEAVE
+
+#define Trice8m_4(tid, v0, v1, v2, v3)                      \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsL | tsH); \
+	TRICE_PUT8_4(v0, v1, v2, v3);                           \
+	TRICE_LEAVE
+
+#define Trice8m_5(tid, v0, v1, v2, v3, v4)                  \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (5 << 16) | tsL | tsH); \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);                       \
+	TRICE_LEAVE
+
+#define Trice8m_6(tid, v0, v1, v2, v3, v4, v5)              \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (6 << 16) | tsL | tsH); \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);                   \
+	TRICE_LEAVE
+
+#define Trice8m_7(tid, v0, v1, v2, v3, v4, v5, v6)          \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (7 << 16) | tsL | tsH); \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);               \
+	TRICE_LEAVE
+
+#define Trice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)      \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsL | tsH); \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);           \
+	TRICE_LEAVE
+
+#define Trice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)  \
+	TRICE_ENTER                                             \
+	uint16_t ts = TriceStamp16;                             \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                        \
+	TRICE_PUT((TRICE_CYCLE << 24) | (9 << 16) | tsL | tsH); \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);       \
+	TRICE_LEAVE
+
+#define Trice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                 \
+	uint16_t ts = TriceStamp16;                                 \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (10 << 16) | tsL | tsH);    \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define Trice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                      \
+	uint16_t ts = TriceStamp16;                                      \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                 \
+	TRICE_PUT((TRICE_CYCLE << 24) | (11 << 16) | tsL | tsH);         \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define Trice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	uint16_t ts = TriceStamp16;                                           \
+	TRICE_PUT(((IdLH) << 16) | IdLH)                                      \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsL | tsH);              \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE
+
+#define TRice8m_0(tid)                           \
+	TRICE_ENTER                                  \
+	uint32_t ts = TriceStamp32;                  \
+	TRICE_PUT(tsHL | tsHH | IDLH)                \
+	TRICE_PUT((TRICE_CYCLE << 24) | tsLL | tsLH) \
+	TRICE_LEAVE
+
+#define TRice8m_1(tid, v0)                                   \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (1 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_1(v0)                                         \
+	TRICE_LEAVE
+
+#define TRice8m_2(tid, v0, v1)                               \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (2 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_2(v0, v1);                                    \
+	TRICE_LEAVE
+
+#define TRice8m_3(tid, v0, v1, v2)                           \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (3 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_3(v0, v1, v2);                                \
+	TRICE_LEAVE
+
+#define TRice8m_4(tid, v0, v1, v2, v3)                       \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (4 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_4(v0, v1, v2, v3);                            \
+	TRICE_LEAVE
+
+#define TRice8m_5(tid, v0, v1, v2, v3, v4)                   \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (5 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_5(v0, v1, v2, v3, v4);                        \
+	TRICE_LEAVE
+
+#define TRice8m_6(tid, v0, v1, v2, v3, v4, v5)               \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (6 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_6(v0, v1, v2, v3, v4, v5);                    \
+	TRICE_LEAVE
+
+#define TRice8m_7(tid, v0, v1, v2, v3, v4, v5, v6)           \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (7 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_7(v0, v1, v2, v3, v4, v5, v6);                \
+	TRICE_LEAVE
+
+#define TRice8m_8(tid, v0, v1, v2, v3, v4, v5, v6, v7)       \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (8 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_8(v0, v1, v2, v3, v4, v5, v6, v7);            \
+	TRICE_LEAVE
+
+#define TRice8m_9(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8)   \
+	TRICE_ENTER                                              \
+	uint32_t ts = TriceStamp32;                              \
+	TRICE_PUT(tsHL | tsHH | IDLH)                            \
+	TRICE_PUT((TRICE_CYCLE << 24) | (9 << 16) | tsLL | tsLH) \
+	TRICE_PUT8_9(v0, v1, v2, v3, v4, v5, v6, v7, v8);        \
+	TRICE_LEAVE
+
+#define TRice8m_10(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) \
+	TRICE_ENTER                                                 \
+	uint32_t ts = TriceStamp32;                                 \
+	TRICE_PUT(tsHL | tsHH | IDLH)                               \
+	TRICE_PUT((TRICE_CYCLE << 24) | (10 << 16) | tsLL | tsLH)   \
+	TRICE_PUT8_10(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);      \
+	TRICE_LEAVE
+
+#define TRice8m_11(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
+	TRICE_ENTER                                                      \
+	uint32_t ts = TriceStamp32;                                      \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                    \
+	TRICE_PUT((TRICE_CYCLE << 24) | (11 << 16) | tsLL | tsLH)        \
+	TRICE_PUT8_11(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);      \
+	TRICE_LEAVE
+
+#define TRice8m_12(tid, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) \
+	TRICE_ENTER                                                           \
+	uint32_t ts = TriceStamp32;                                           \
+	TRICE_PUT(tsHL | tsHH | IDLH)                                         \
+	TRICE_PUT((TRICE_CYCLE << 24) | (12 << 16) | tsLL | tsLH)             \
+	TRICE_PUT8_12(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)       \
+	TRICE_LEAVE

Middlewares/trice/triceAuxiliary.c

@@ -0,0 +1,90 @@
+//! \file triceAuxiliary.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//!     //////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+#if !TRICE_OFF
+
+    #if TRICE_DIRECT_AUXILIARY8 == 1
+
+//! UserNonBlockingDirectWrite8AuxiliaryFn can get a user function address for writing to an auxiliary interface.
+Write8AuxiliaryFn_t UserNonBlockingDirectWrite8AuxiliaryFn = (void *)0;
+
+//! TriceNonBlockingDirectWrite8Auxiliary writes to a user defined interface.
+void TriceNonBlockingDirectWrite8Auxiliary(const uint8_t *enc, size_t encLen)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(enc, encLen);
+#else
+    if (UserNonBlockingDirectWrite8AuxiliaryFn != (void *)0)
+    {
+        UserNonBlockingDirectWrite8AuxiliaryFn(enc, encLen);
+    }
+#endif
+}
+
+    #endif // #if TRICE_DIRECT_AUXILIARY8 == 1
+
+    #if TRICE_DEFERRED_AUXILIARY8 == 1
+
+//! UserNonBlockingDeferredWrite8AuxiliaryFn can get a user function address for writing to an auxiliary interface.
+Write8AuxiliaryFn_t UserNonBlockingDeferredWrite8AuxiliaryFn = (void *)0;
+
+//! TriceNonBlockingDeferredWrite8Auxiliary writes to a user defined interface.
+void TriceNonBlockingDeferredWrite8Auxiliary(const uint8_t *enc, size_t encLen)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(enc, encLen);
+#else
+    if (UserNonBlockingDeferredWrite8AuxiliaryFn != (void *)0)
+    {
+        UserNonBlockingDeferredWrite8AuxiliaryFn(enc, encLen);
+    }
+#endif
+}
+
+    #endif // #if TRICE_DEFERRED_AUXILIARY8 == 1
+
+    #if TRICE_DIRECT_AUXILIARY32 == 1
+
+//! UserNonBlockingDirectWrite32AuxiliaryFn can get a user function address for writing to an auxiliary interface.
+Write32AuxiliaryFn_t UserNonBlockingDirectWrite32AuxiliaryFn = (void *)0;
+
+//! TriceNonBlockingDirectWrite32Auxiliary writes to a user defined interface.
+void TriceNonBlockingDirectWrite32Auxiliary(const uint32_t *enc, unsigned count)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(enc, count << 2);
+#else
+    if (UserNonBlockingDirectWrite32AuxiliaryFn != (void *)0)
+    {
+        UserNonBlockingDirectWrite32AuxiliaryFn(enc, count);
+    }
+#endif
+}
+
+    #endif // #if TRICE_DIRECT_AUXILIARY32 == 1
+
+    #if TRICE_DEFERRED_AUXILIARY32 == 1
+
+//! UserNonBlockingDeferredWrite32AuxiliaryFn can get a user function address for writing to an auxiliary interface.
+Write32AuxiliaryFn_t UserNonBlockingDeferredWrite32AuxiliaryFn = (void *)0;
+
+//! TriceNonBlockingDeferredWrite32Auxiliary writes to a user defined interface.
+void TriceNonBlockingDeferredWrite32Auxiliary(const uint32_t *enc, unsigned count)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(enc, count << 2);
+#else
+    if (UserNonBlockingDeferredWrite32AuxiliaryFn != (void *)0)
+    {
+        UserNonBlockingDeferredWrite32AuxiliaryFn(enc, count);
+    }
+#endif
+}
+
+    #endif // #if TRICE_DEFERRED_AUXILIARY32 == 1
+
+#endif // #if !TRICE_OFF

Middlewares/trice/triceDefaultConfig.h

@@ -0,0 +1,484 @@
+/*!
+ *  \file triceDefaultConfig.h
+   \author Thomas.Hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+#ifndef TRICE_DEFAULT_CONFIG_H_
+#define TRICE_DEFAULT_CONFIG_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef TRICE_CLEAN
+// TRICE_CLEAN, when found in triceConfig.h is set to 0 with command "trice insert".
+// and set to 1 with command "trice clean" to get rid of
+// potential editor warnings in the trice clean state.
+#define TRICE_CLEAN 0
+#endif
+
+#ifndef TRICE_OFF
+// TRICE_OFF, when defined to 1 earlier than including trice.h disables trice code for the file.
+// When defined in the project settings, it influences the whole trice code generation.
+#define TRICE_OFF 0
+#endif
+
+#ifndef TRICE_UARTA_MIN_ID
+#define TRICE_UARTA_MIN_ID 0 //!< TRICE_UARTA_MIN_ID, if > 0, is the smalles ID routed to UARTA.
+#endif
+
+#ifndef TRICE_UARTA_MAX_ID
+#define TRICE_UARTA_MAX_ID 0 //!< TRICE_UARTA_MAX_ID, if > 0, is the largest ID routed to UARTA.
+#endif
+
+#ifndef TRICE_UARTB_MIN_ID
+#define TRICE_UARTB_MIN_ID 0 //!< TRICE_UARTB_MIN_ID, if > 0, is the smalles ID routed to UARTB.
+#endif
+
+#ifndef TRICE_UARTB_MAX_ID
+#define TRICE_UARTB_MAX_ID 0 //!< TRICE_UARTB_MAX_ID, if > 0, is the largest ID routed to UARTA.
+#endif
+
+#ifndef TRICE_DEFERRED_UARTA
+#define TRICE_DEFERRED_UARTA 0 //!< TRICE_DEFERRED_UARTA enables a user defined deferred trice write over TRICE_UARTA.
+#endif
+
+#ifndef TRICE_DEFERRED_UARTB
+#define TRICE_DEFERRED_UARTB 0 //!< TRICE_DEFERRED_UARTB enables a user defined deferred trice write over TRICE_UARTB.
+#endif
+
+#ifndef TRICE_DIRECT_AUXILIARY8
+#define TRICE_DIRECT_AUXILIARY8 0 //!< TRICE_DIRECT_AUXILIARY8 enables a user defined direct trice write.
+#endif
+
+#ifndef TRICE_DEFERRED_AUXILIARY8
+#define TRICE_DEFERRED_AUXILIARY8 0 //!< TRICE_DEFERRED_AUXILIARY8 enables a user defined deferred trice write.
+#endif
+
+#ifndef TRICE_DIRECT_AUXILIARY32
+#define TRICE_DIRECT_AUXILIARY32 0 //!< TRICE_DIRECT_AUXILIARY32 enables a user defineddirect trice write.
+#endif
+
+#ifndef TRICE_DEFERRED_AUXILIARY32
+#define TRICE_DEFERRED_AUXILIARY32 0 //!< TRICE_DEFERRED_AUXILIARY32 enables a user defined deferred trice write.
+#endif
+
+#ifndef TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING
+//! TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING allows to send an ID range of trices directly to an output.
+//! The called output function usually is executed inside an interrupt and should therefore be non-blocking and fast.
+#define TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING 0
+#endif
+
+#ifndef TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING
+//! TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING allows to send an ID range of trices directly to an output.
+//! The called output function should be non-blocking.
+#define TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING 0
+#endif
+
+#ifndef TRICE_B
+//! TRICE_B is a shortcut for TRICE8_B, TRICE16_B, TRICE32_B or TRICE64_B usable in your project.
+#define TRICE_B TRICE8_B
+#endif
+
+#ifndef TRICE_F
+//! TRICE_F is a shortcut for TRICE8_F, TRICE16_F, TRICE32_F or TRICE64_F usable in your project.
+#define TRICE_F TRICE8_F
+#endif
+
+#ifndef TRICE_COMMAND_SIZE_MAX
+//! TRICE_COMMAND_SIZE_MAX is the length limit for command strings to target.
+#define TRICE_COMMAND_SIZE_MAX 8
+#endif
+
+#ifndef TRICE_DEFAULT_PARAMETER_BIT_WIDTH
+//! TRICE_DEFAULT_PARAMETER_BIT_WIDTH is the default parameter bit width for Trice macros not specifying the parameter bit width: 8, 16, 32 or 64.
+//! If for example the majority of your values is 16 bit, it makes sense to set this value to 16 to use Trice for them and to use Trice32 explicitely for 32-bit values.
+//! The trice tool CLI switch "-defaultTRICEBitwidth" needs to be set to the same bit width, default is 32.
+#define TRICE_DEFAULT_PARAMETER_BIT_WIDTH 32
+#endif
+
+#ifndef TRICE_CONFIG_WARNINGS
+#define TRICE_CONFIG_WARNINGS 1 //!< TRICE_CONFIG_WARNINGS == 0 can suppress some unwanted configuration warnings. Set to 0 only if you know what you are doing.
+#endif
+
+#ifndef TriceStamp16
+//! TriceStamp16 returns a 16-bit value to stamp `Id` TRICE and `Trice` macros. Usually it is a timestamp, but could also be a destination address or a counter for example.
+//! The user has to provide this value. Defining a macro here, instead of providing a function has significant speed impact.
+#define TriceStamp16 0xbe16
+#endif
+
+#ifndef TriceStamp32
+//! TriceStamp32 returns a 32-bit value to stamp `ID` TRICE and `TRice` macros. Usually it is a timestamp, but could also be a destination address or a counter for example.
+//! The user has to provide this value. Defining a macro here, instead of providing a function has significant speed impact.
+#define TriceStamp32 0xfeed3322
+#endif
+
+#ifndef TRICE_PROTECT
+//! The TRICE_PROTECT switch is only relevant for the deferred trice modes TRICE_DOUBLE_BUFFER and TRICE_RING_BUFFER.
+//! The trice library works well, when less data are produced in the average than transmittable and when in the double buffer case the TriceTransfer
+//! function is called, before too much data in a half buffer according to a good configuration. If that is guarantied you do not need to enable TRICE_PROTECT.
+//! If because of an potential error this is not guarantied, you should enable TRICE_PROTECT. This slows down the Trice macros a bit, but makes buffer overflows impossible.
+//! A ring buffer cannot overflow in a first assumption, because old, not yet transmitted, trices are overwritten by newer ones.
+//! But that can happen only to parts of trices. The ring buffer read out function relies on consistent data. If it gets data garbage, wrong values
+//! for the trice lengths are possible and buffer overruns not avoidable. When enabling TRICE_PROTECT, new trices are only written into the deferred buffer,
+//! if there is enough space. That guaranties data consistency. Because a suppressed trice cannot cause a cycle error, there is TriceOverflowCount as diagnostic value.
+//! Long story short: If you sure, not to produce too much data, than set TRICE_PROTECT to 0 and get a bit more speed.
+#define TRICE_PROTECT 1
+#endif
+
+#if !defined(TRICE_BUFFER) && !TRICE_OFF
+//!  TRICE_BUFFER selects, where the Trice macros accumulate the trice data during a single Trice execution. Selectable options:
+//! - TRICE_STACK_BUFFER: No additional buffer is needed, what makes sense for single task systems with direct output only.
+//! - TRICE_STATIC_BUFFER: A single trice is stored in a separate static buffer, what makes sense for multi-tasking systems with direct output only.
+//! - TRICE_DOUBLE_BUFFER: Trice macros write direct into a double buffer without any additional management action.
+//!   This is the fastest execution option for Trice macros but needs more RAM. Used for deferred output and optional additional direct output.
+//! - TRICE_RING_BUFFER: Trice macros write direct into a ring buffer without any additional management action.
+//!   This is a fast but not the fastest execution option for Trice macros and needs less RAM. Used for deferred output and optional additional direct output.
+#error TRICE_BUFFER type not specified in triceConfig.h, please add "#define TRICE_BUFFER TRICE_RING_BUFFER" for example.
+#endif
+
+#ifndef TRICE_DEFERRED_TRANSFER_MODE
+//! TRICE_DEFERRED_TRANSFER_MODE is the selected deferred trice transfer method. Options:
+//! - TRICE_SINGLE_PACK_MODE packs each Trice message separately and adds a 0-delimiter byte. This increases the transmit byte count slightly. In case of a lost package only one Trice can get lost.
+//! - TRICE_MULTI_PACK_MODE packs several trice messages before adding a 0-delimiter byte. This reduces the transmit byte count. In case of a lost package several Trices can get lost.
+//! - When using encryption, the TRICE_MULTI_PACK_MODE can significantly reduce the transmit byte count, because in TRICE_SINGLE_PACK_MODE each Trice message gets extended
+//! with 1 to 7 padding bytes before encryption. TRICE_MULTI_PACK_MODE is not possible for TRICE_STACK_BUFFER and TRICE_STATIC_BUFFER (direct mode).
+#define TRICE_DEFERRED_TRANSFER_MODE TRICE_MULTI_PACK_MODE
+#endif
+
+#ifndef TRICE_RING_BUFFER_OVERFLOW_WATCH
+//! TRICE_RING_BUFFER_OVERFLOW_WATCH is used to investigate, if the ring buffer margins are really not touched.
+//! This value usually can stay 0.
+#define TRICE_RING_BUFFER_OVERFLOW_WATCH 0
+#endif
+
+#ifndef TRICE_DIRECT_OUTPUT
+//! TRICE_DIRECT_OUTPUT == 0: only deferred output, usually UART output only
+//! TRICE_DIRECT_OUTPUT == 1: with direct output, SEGGER_RTT output and/or TRICE_DIRECT_AUXILIARY8 output
+//! Setting TRICE_BUFFER to TRICE_STACK_BUFFER or TRICE_STATIC_BUFFER demands TRICE_DIRECT_OUTPUT == 1, no deferred output at all.
+//! When TRICE_BUFFER == TRICE_RING_BUFFER or TRICE_BUFFER == TRICE_DOUBLE_BUFFER for deferred output, additional direct output can be switched on here.
+//! For example it is possible to have direct 32-bit wise RTT TRICE_FRAMING_NONE output and deferred UART TRICE_FRAMING_TCOBS output.
+#define TRICE_DIRECT_OUTPUT 0
+#endif
+
+#ifndef TRICE_DEFERRED_OUTPUT
+//! TRICE_DEFERRED_OUTPUT == 0: no deferred output
+//! TRICE_DEFERRED_OUTPUT == 1: with deferred output, usually UART output and/or auxiliary output
+//! Setting TRICE_BUFFER to TRICE_RING_BUFFER or TRICE_DOUBLE_BUFFER demands TRICE_DEFERRED_OUTPUT == 1.
+//! TRICE_BUFFER == TRICE_STACK_BUFFER or TRICE_BUFFER == TRICE_STATIC_BUFFER needs TRICE_DEFERRED_OUTPUT == 0.
+//! When TRICE_BUFFER == TRICE_RING_BUFFER or TRICE_BUFFER == TRICE_DOUBLE_BUFFER for deferred output, additional direct output can be on.
+#define TRICE_DEFERRED_OUTPUT 0
+#endif
+
+#ifndef TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING
+//! TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING == 1 makes only sense, when TRICE_DIRECT_OUTPUT is 1.
+//! Enable this only, if you want only a specific ID range for direct Trice output.
+//! If you use different direct output channels, you can change this only for all together.
+#define TRICE_DIRECT_OUTPUT_IS_WITH_ROUTING 0 // (experimental)
+#endif
+
+#ifndef TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING
+//! TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING == 1 makes only sense, when TRICE_DEFERRED_OUTPUT is 1.
+//! Enable this only, if you want only a specific ID range for direct Trice output.
+//! If you use different direct output channels, you can change this only for all together.
+#define TRICE_DEFERRED_OUTPUT_IS_WITH_ROUTING 0 // (experimental)
+#endif
+
+#ifndef TRICE_DATA_OFFSET
+//! TRICE_DATA_OFFSET is the space in front of single trice data for in-buffer (T)COBS encoding.
+//! - When using real big buffers, 16 may be not enough.
+//! - When having only short trices but lots of trice bursts, it may make sense to reduce this value to 4.
+//! - Without encoding/framing this value can be 0.
+//! - When using XTEA, this value should incorporate additional 4 bytes, because of the 64-bit encryption units.
+//! With TRICE_BUFFER == TRICE_RING_BUFFER, this amount of space is allocated in front of the ring buffer.
+//! With TRICE_BUFFER == TRICE_DOUBLE_BUFFER, this amount of space is allocated once in front of each half buffer.
+//! Must be a multiple of 4. 64 is a _very_ safe value. In most cases you can reduce this to 16 or less.
+#define TRICE_DATA_OFFSET 64
+#endif
+
+#ifndef TRICE_SINGLE_MAX_SIZE
+//! TRICE_SINGLE_MAX_SIZE is used to truncate long runtime generated strings, to detect the need of a ring buffer wrap or to protect against overflow.
+//! It must be a multiple of 4 and ist max valid value is 32764.
+//! \li Be careful with this value: When using 12 64-bit values with a 32-bit stamp the trice size is 2(id) + 4(stamp) + 2(count) + 12*8(values) = 104 bytes.
+//! \li In direct mode, and also when you enabled TRICE_DEFERRED_SEGGER_RTT_8BIT_WRITE, this plus TRICE_DATA_OFFSET plus 4 is the max allocation size on the target
+//! stack with TRICE_BUFFER == TRICE_STACK_BUFFER.
+//! \li When short of memory and, for example, max 2 32-bit values with a 32-bit stamp are used, the max trice size is 2 + 4 + 2 + 2*4 = 16 bytes.
+//! \li When not using target timestamps and not more than one 32-bit or two 16-bit or four 8-bit values or using target timestamp without carried values, the TRICE_SINGLE_MAX_SIZE should be 8 bytes only.
+//! \li With a value < 104 automatically all then forbidden trices are disabled to avoid mistakes. This also reduces the needed flash size and compile time depending on the used compiler.
+//! \li Example: TRrice( "%d %d %d", 1, 2, 3)` would cause a compiler error with `#define TRICE_SINGLE_MAX_SIZE 16` then.
+//! \li When NOT using dynamic string or buffer transfer, bigger values than 104 make no sense here and just spoiling RAM.
+//! \li When USING dynamic string (or buffer) transfer, this value limits the max length of a trice. 2^15-4=32764 is the max possible value if you have enough RAM.
+//! According to TRICE_SINGLE_MAX_SIZE the Trice functions are enabled/disabled automatically.
+//! To force that manually, the user can for example `#define ENABLE_trice32fn_12 0` or `#define ENABLE_trice32fn_12 1` for all variations. See trice8.c trice16.c, ... .
+#define TRICE_SINGLE_MAX_SIZE 104
+#endif
+
+#if TRICE_SINGLE_MAX_SIZE & 3
+#error "TRICE_SINGLE_MAX_SIZE is not a multiple of 4"
+#endif
+
+#if TRICE_SINGLE_MAX_SIZE > 32764
+#error "TRICE_SINGLE_MAX_SIZE is too big"
+#endif
+
+#ifndef TRICE_DEFERRED_BUFFER_SIZE
+//! TRICE_DEFERRED_BUFFER_SIZE needs to be capable to hold trice bursts until they are transmitted and must be a multiple of 4.
+//! \li When TRICE_BUFFER == TRICE_STACK_BUFFER this value is not used.
+//! \li When TRICE_BUFFER == TRICE_STATIC_BUFFER this value is not used.
+//! \li When TRICE_BUFFER == TRICE_DOUBLE_BUFFER, this is the sum of both half buffers.
+//! \li When TRICE_BUFFER == TRICE_RING_BUFFER, this is the whole buffer.
+#define TRICE_DEFERRED_BUFFER_SIZE 1024
+#endif
+
+#ifndef TRICE_RING_BUFFER_SIZE
+//! TRICE_RING_BUFFER_SIZE is the ring buffer net size. Together with TRICE_DATA_OFFSET it is the TRICE_DEFERRED_BUFFER_SIZE.
+#define TRICE_RING_BUFFER_SIZE (TRICE_DEFERRED_BUFFER_SIZE - TRICE_DATA_OFFSET)
+#endif
+
+#ifndef TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN
+//! Long story short: Whith big endian target MCUs simply apply the `-triceEndianness bigEndian` CLI switch when using the `trice log` command.
+//! Long story long:
+//! TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN should have the same value as TRICE_MCU_IS_BIG_ENDIAN to avoid additional byte swapping code.
+//! It can be defined to 1 on little endian MCUs if the trice data are needed in network order for some reason.
+//! But that adds byte swapping code. This switch is mainly intended to be used for automated tests.
+//! The default transfer order is little endian as most targets are little endian machines.
+//! On big endian MCUs this value should be set to 1 to avoid additional byte swapping code, which increases the trice storage time and the needed code amount.
+//! For TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 1, you need to apply the `-triceEndianness bigEndian` CLI switch when using the `trice log` command then.
+//! Please consider also the TRICE_MCU_IS_BIG_ENDIAN compiler switch in this context.
+#define TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN TRICE_MCU_IS_BIG_ENDIAN
+#endif
+
+#ifndef TRICE_DIRECT_OUT_FRAMING
+//! TRICE_DIRECT_OUT_FRAMING defines the framing method of the binary trice data stream for direct output. Options:
+//! - TRICE_FRAMING_TCOBS: Recommended for internal transfer and trice tool visualization.
+//! - TRICE_FRAMING_COBS: The trice tool needs switch `-pf COBS`. Useful with XTEA or to decode the binary trice data with a user tool.
+//! - TRICE_FRAMING_NONE: The trice tool needs switch `-pf none`. TRICE_FRAMING_NONE is recommended for fast RTT (32-bit access).
+#define TRICE_DIRECT_OUT_FRAMING TRICE_FRAMING_NONE
+#endif
+
+#ifndef TRICE_DEFERRED_OUT_FRAMING
+//! TRICE_DEFERRED_OUT_FRAMING defines the framing method of the binary trice data stream for deferred output. Options:
+//! - TRICE_FRAMING_TCOBS: Recommended for UART transfer and trice tool visualization.
+//! - TRICE_FRAMING_COBS: The trice tool needs switch `-pf COBS`. Useful with XTEA or to decode the binary trice date with Python or an other language.
+//! - TRICE_FRAMING_NONE: The trice tool needs switch `-pf none`. This mode may be helpful if you write your own trice viewer without a decoder.
+#define TRICE_DEFERRED_OUT_FRAMING TRICE_FRAMING_TCOBS
+#endif
+
+#ifndef XTEA_ENCRYPT_KEY
+//! XTEA_ENCRYPT_KEY allows XTEA TriceEncryption with the key.
+//! To get your private XTEA_KEY, call just once "trice log -port ... -password YourSecret -showKey".
+//! The byte sequence you see then, copy and use it in your trice.Config.h file.
+//! YOu can user `-password MySecret` as Trice tool CLI switch with the default key.
+#define XTEA_ENCRYPT_KEY XTEA_KEY(ea, bb, ec, 6f, 31, 80, 4e, b9, 68, e2, fa, ea, ae, f1, 50, 54);
+#endif
+
+#ifndef XTEA_DECRYPT
+//! XTEA_DECRYPT, when defined, enables device local decryption. Usable for checks or if you use a trice reception capable node to read XTEA encrypted messages.
+//! One possible application is, receiving trices, decoding them, finding an ID match in a (from triceF generated) function pointer list and executing the dedicated function.
+//! This allows kind of RPC (without immediate return) also with encryption.
+#define XTEA_DECRYPT 0
+#endif
+
+#ifndef TRICE_DIRECT_XTEA_ENCRYPT
+//! TRICE_DIRECT_XTEA_ENCRYPT enables encryption for direct output. Encrypting direct output costs significant computing time in the time critical path!
+#define TRICE_DIRECT_XTEA_ENCRYPT 0
+#endif
+
+#ifndef TRICE_DEFERRED_XTEA_ENCRYPT
+//! TRICE_DEFERRED_XTEA_ENCRYPT enables encryption for deferred output.
+#define TRICE_DEFERRED_XTEA_ENCRYPT 0
+#endif
+
+#ifndef TRICE_DIAGNOSTICS
+//! With TRICE_DIAGNOSTICS == 0, additional trice diagnostics code is removed.
+//! During development TRICE_DIAGNOSTICS == 1 helps to optimize the trice buffer sizes.
+#define TRICE_DIAGNOSTICS 1
+#endif
+
+#ifndef TRICE_DIRECT_SEGGER_RTT_8BIT_WRITE
+//! TRICE_DIRECT_SEGGER_RTT_8BIT_WRITE==1 uses standard RTT transfer by using function SEGGER_RTT_WriteNoLock and needs ((TRICE_DIRECT_OUTPUT == 1).
+//! - This setting results in unframed RTT trice packages and requires the `-packageFraming none` switch for the appropriate trice tool instance.
+//! - Not that fast as with TRICE_SEGGER_RTT_32BIT_WRITE == 1 but still fast and uses pure SEGGER functionality only.
+#define TRICE_DIRECT_SEGGER_RTT_8BIT_WRITE 0
+#endif
+
+#ifndef TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE
+//! TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE == 1 speeds up RTT transfer by using function SEGGER_Write_RTT0_NoCheck32.
+//! - This setting results in unframed RTT trice packages and requires the `-packageFraming none` switch for the appropriate trice tool instance.
+//!   This squeezes the whole Trice macro into about 100 processor clocks leaving the data already inside the SEGGER _acUpBuffer.
+//! - If you do not wish RTT, or wish RTT with framing, simply set this value to 0.
+//! - The trice tool CLI switch -d16 is needed too, because for alignment reasons the 16bit ID field is doubled for 16bit timestamp trice messages.
+#define TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE 0
+#endif
+
+#ifndef TRICE_DEFERRED_SEGGER_RTT_8BIT_WRITE
+//! TRICE_DEFERRED_SEGGER_RTT_8BIT_WRITE == 1 enables channel number 0 for SeggerRTT usage. Only channel 0 works right now for some reason.
+//! Than the RTT trice packages can be framed according to the set TRICE_DIRECT_OUT_FRAMING.
+//! Not useable together with TRICE_DIRECT_SEGGER_RTT_32BIT_WRITE or TRICE_DIRECT_SEGGER_RTT_8BIT_WRITE
+//! Switch this on, if you wish deferred Segger RTT output. Usually RTT is used for direct mode only.
+#define TRICE_DEFERRED_SEGGER_RTT_8BIT_WRITE 0
+#endif
+
+#ifndef TRICE_DIRECT_AUXILIARY8
+//! TRICE_DIRECT_AUXILIARY8 enables a user defined direct trice 8bit char write.
+#define TRICE_DIRECT_AUXILIARY8 0
+#endif
+
+#ifndef TRICE_DIRECT_AUXILIARY32
+//! TRICE_DIRECT_AUXILIARY32 enables a user defined direct trice 32bit word write.
+#define TRICE_DIRECT_AUXILIARY32 0
+#endif
+
+#ifndef TRICE_DEFERRED_AUXILIARY8
+//! TRICE_DEFERRED_AUXILIARY8 enables a user defined deferred trice 8bit char write.
+#define TRICE_DEFERRED_AUXILIARY8 0
+#endif
+
+#ifndef TRICE_DEFERRED_AUXILIARY32
+//! TRICE_DEFERRED_AUXILIARY32 enables a user defined deferred trice 32bit word write.
+#define TRICE_DEFERRED_AUXILIARY32 0
+#endif
+
+#ifndef TRICE_CGO
+//! CGO interface for testing the target code with Go only, do not enable normally. Usage examples can be found in the trice/_test folder.
+#define TRICE_CGO 0
+#endif
+
+#ifndef TRICE_CYCLE_COUNTER
+//! TRICE_CYCLE_COUNTER adds a cycle counter to each trice message.
+//! If 0, do not add cycle counter. The Trice macros are a bit faster. Lost TRICEs are not detectable by the trice tool. The cycle counter byte ist statically 0xC0.
+//! If 1, add an 8-bit cycle counter. The Trice macros are a bit slower. Lost TRICEs are detectable by the trice tool. The cycle counter byte changes (recommended).
+#define TRICE_CYCLE_COUNTER 1
+#endif
+
+// Compiler Adaption:
+
+#ifndef USE_SEGGER_RTT_LOCK_UNLOCK_MACROS
+//! USE_SEGGER_RTT_LOCK_UNLOCK_MACROS == 1 includes SEGGER_RTT header files even SEGGER_RTT is not used. THis allows SEGGER code for critical sections.
+#define USE_SEGGER_RTT_LOCK_UNLOCK_MACROS 0
+#endif
+
+#ifndef TRICE_ENTER_CRITICAL_SECTION
+//! TRICE_ENTER_CRITICAL_SECTION saves interrupt state and disables Interrupts.
+//! If trices are used only outside critical sections or interrupts, you can leave this macro empty for more speed. Use only '{' in that case.
+//! Examples:
+//! \li #define TRICE_ENTER_CRITICAL_SECTION { SEGGER_RTT_LOCK() { - does the job for many compilers.
+//! \li #define TRICE_ENTER_CRITICAL_SECTION {
+//! \li #define TRICE_ENTER_CRITICAL_SECTION { uint32_t old_mask = cm_mask_interrupts(1); { // copied from test/OpenCM3_STM32F411_Nucleo/triceConfig.h
+//! \li #define TRICE_ENTER_CRITICAL_SECTION { uint32_t primaskstate = __get_PRIMASK(); __disable_irq(); {
+#define TRICE_ENTER_CRITICAL_SECTION {
+#endif
+
+#ifndef TRICE_LEAVE_CRITICAL_SECTION
+//! TRICE_LEAVE_CRITICAL_SECTION restores interrupt state.
+//! If trices are used only outside critical sections or interrupts, you can leave this macro empty for more speed. Use only '}' in that case.
+//! Examples:
+//! \li #define TRICE_LEAVE_CRITICAL_SECTION } SEGGER_RTT_UNLOCK() } - does the job for many compilers.
+//! \li #define TRICE_LEAVE_CRITICAL_SECTION }
+//! \li #define TRICE_LEAVE_CRITICAL_SECTION } cm_mask_interrupts(old_mask); } // copied from test/OpenCM3_STM32F411_Nucleo/triceConfig.h
+//! \li #define TRICE_LEAVE_CRITICAL_SECTION } __set_PRIMASK(primaskstate); }
+#define TRICE_LEAVE_CRITICAL_SECTION }
+#endif
+
+#ifndef TRICE_INLINE
+//! TRICE_INLINE is used for inlining trice code to be usable with any compiler. Define this value according to your compiler syntax.
+#define TRICE_INLINE static inline
+#endif
+
+// code space optimization
+
+#ifndef TRICE_8_BIT_SUPPORT
+//! TRICE_8_BIT_SUPPORT enables/disables all 8-bit Trice macros.
+#define TRICE_8_BIT_SUPPORT 1
+#endif
+
+#ifndef TRICE_16_BIT_SUPPORT
+//! TRICE_16_BIT_SUPPORT enables/disables all 16-bit Trice macros.
+#define TRICE_16_BIT_SUPPORT 1
+#endif
+
+#ifndef TRICE_32_BIT_SUPPORT
+//! TRICE_32_BIT_SUPPORT enables/disables all 32-bit Trice macros.
+#define TRICE_32_BIT_SUPPORT 1
+#endif
+
+#ifndef TRICE_64_BIT_SUPPORT
+//! TRICE_32_BIT_SUPPORT enables/disables all 64-bit Trice macros.
+#define TRICE_64_BIT_SUPPORT 1
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Trice time measurement
+// The SYSTICKVAL is not needed by the Trice code. It is only used inside triceCheck.c as example value.
+// If your MCU is a not ARM Cortex-M one, simply define this value according your MCU, if you wish to use SYSTICKVAL.
+
+#ifndef SYSTICKVAL
+
+#if defined(__arm__)       /* Defined by GNU C and RealView */               \
+    || defined(__thumb__)  /* Defined by GNU C and RealView in Thumb mode */ \
+    || defined(_ARM)       /* Defined by ImageCraft C */                     \
+    || defined(_M_ARM)     /* Defined by Visual Studio */                    \
+    || defined(_M_ARMT)    /* Defined by Visual Studio in Thumb mode */      \
+    || defined(__arm)      /* Defined by Diab */                             \
+    || defined(__ICCARM__) /* IAR */                                         \
+    || defined(__CC_ARM)   /* ARM's (RealView) compiler */                   \
+    || defined(__ARM__)    /* TASKING VX ARM toolset C compiler */           \
+    || defined(__CARM__)   /* TASKING VX ARM toolset C compiler */           \
+    || defined(__CPARM__)  /* TASKING VX ARM toolset C++ compiler */
+
+//! ARM Cortex-M MCUs have this register.
+//! \li See https://developer.arm.com/documentation/dui0552/a/cortex-m3-peripherals/system-timer--systick
+//! This is only 16- or 24-bit wide and usually resetted each ms. Consider using DWT_CYCCNT if your MCU supports this.
+//! When using a 24-bit SYSTICKVAL as 16-bit target timestamp, be aware, that, for example, with a 100 MHz system clock, the
+//! SYSTICKVAL runs from 99 999 999 to 0 and you see just the lower 16 bit as time stamp, what may be confusing. With a
+//! 64 MHz clock, everything is fine, because 63999 is still a 16-bit value. When using DWT_CYCCNT on MCU clocks > 65 MHz,
+//! displaying only the lower 2 bytes is ok, because this 32-bit counter runs circular without being resetted.
+#define SYSTICKVAL (*(volatile uint32_t*)0xE000E018UL)
+
+#else
+
+#define SYSTICKVAL 0
+
+#endif
+
+#endif // #ifndef SYSTICKVAL
+
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// These settings are overwriting the Trice relevant defaults in SEGGER_RTT_Conf.h.
+// To change, you should define them in your project specific triceConfig.h.
+// No separate copy of SEGGER_RTT_Conf.h is needed this way.
+// The BUFFER_SIZE_UP value is de-facto a TRICE_DIRECT_BUFFER_SIZE, if no direct auxilary output is used.
+
+#ifndef   SEGGER_RTT_MAX_NUM_UP_BUFFERS
+#define SEGGER_RTT_MAX_NUM_UP_BUFFERS   (1)     // Max. number of up-buffers (T->H) available on this target
+#endif
+
+#ifndef   SEGGER_RTT_MAX_NUM_DOWN_BUFFERS
+#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (0)     // Max. number of down-buffers (H->T) available on this target
+#endif
+
+#ifndef   BUFFER_SIZE_UP
+#define BUFFER_SIZE_UP                  (1024)  // "TRICE_DIRECT_BUFFER_SIZE"
+#endif
+
+#ifndef   BUFFER_SIZE_DOWN
+#define BUFFER_SIZE_DOWN                (0)     // Size of the buffer for terminal input to target from host
+#endif
+
+#ifndef   SEGGER_RTT_PRINTF_BUFFER_SIZE
+#define SEGGER_RTT_PRINTF_BUFFER_SIZE   (0u)    // Size of buffer for RTT printf to bulk-send chars via RTT
+#endif
+
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TRICE_DEFAULT_CONFIG_H_ */

Middlewares/trice/triceDoubleBuffer.c

@@ -0,0 +1,350 @@
+//! \file triceDoubleBuffer.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//!     //////////////////////////////////////////////////////////////////////////
+#include "cobs.h"
+#include "tcobs.h"
+#include "trice.h"
+
+#if TRICE_BUFFER == TRICE_DOUBLE_BUFFER && TRICE_OFF == 0
+
+static void TriceOut(uint32_t *tb, size_t tLen);
+
+//! triceBuffer is a double buffer for better write speed.
+//! halfBufferStart     writePosition
+//! ^-TRICE_DATA_OFFSET-^-restOf_TRICE_DEFERRED_BUFFER_SIZE-^-2ndBuf...
+//! ^-TRICE_DATA_OFFSET-^-restOf_TRICE_DEFERRED_BUFFER_SIZE-Limit
+static uint32_t triceBuffer[2][TRICE_DEFERRED_BUFFER_SIZE >> 3] = {0};
+
+    #define TRICE_WRITE_START_HALF_BUFFER_0 (&triceBuffer[0][TRICE_DATA_OFFSET >> 2])
+    #define TRICE_WRITE_LIMIT_HALF_BUFFER_0 (&triceBuffer[0][TRICE_DEFERRED_BUFFER_SIZE >> 3])
+    #define TRICE_WRITE_START_HALF_BUFFER_1 (&triceBuffer[1][TRICE_DATA_OFFSET >> 2])
+    #define TRICE_WRITE_LIMIT_HALF_BUFFER_1 (&triceBuffer[1][TRICE_DEFERRED_BUFFER_SIZE >> 3])
+
+static uint32_t *const triceWriteStartHalfBuffer0 = TRICE_WRITE_START_HALF_BUFFER_0;
+static uint32_t *const triceWriteStartHalfBuffer1 = TRICE_WRITE_START_HALF_BUFFER_1;
+    #if TRICE_PROTECT == 1
+static uint32_t *const triceWriteLimitHalfBuffer0 = TRICE_WRITE_LIMIT_HALF_BUFFER_0;
+static uint32_t *const triceWriteLimitHalfBuffer1 = TRICE_WRITE_LIMIT_HALF_BUFFER_1;
+    #endif
+
+//! triceActiveHalfBuffer is the index of the active write buffer. !triceActiveHalfBuffer is the active read buffer index.
+static int triceActiveHalfBuffer = 0;
+
+//! TriceBufferWritePosition is the active write position and is used by TRICE_PUT macros.
+uint32_t *TriceBufferWritePosition = TRICE_WRITE_START_HALF_BUFFER_0; // triceWriteStartHalfBuffer0;
+
+//! TriceBufferWritePositionStart is the begin of the active write buffer.
+uint32_t *TriceBufferWritePositionStart = TRICE_WRITE_START_HALF_BUFFER_0; // triceWriteStartHalfBuffer0;
+
+    #if TRICE_PROTECT == 1
+//! TriceBufferWritePositionLimit is the first not usable address of the current written half buffer.
+static uint32_t *TriceBufferWritePositionLimit = TRICE_WRITE_LIMIT_HALF_BUFFER_0; // triceWriteLimitHalfBuffer0;
+
+//! TriceEnoughSpace checks, if at least TRICE_SINGLE_MAX_SIZE bytes available for the next trice.
+//! \retval 0, when not enough space
+//! \retval 1, when enough space
+int TriceEnoughSpace(void)
+{
+    // space32 is the writable 32-bit value count in the current write buffer.
+    int space32 = TriceBufferWritePositionLimit - TriceBufferWritePosition;
+    // there need to be at least TRICE_SINGLE_MAX_SIZE bytes space in the current write buffer.
+    if (space32 >= (TRICE_SINGLE_MAX_SIZE >> 2))
+    {
+        return 1;
+    }
+    else
+    {
+#if TRICE_DIAGNOSTICS == 1
+        TriceDeferredOverflowCount++;
+#endif
+        return 0;
+    }
+}
+
+    #endif // #if TRICE_PROTECT == 1
+
+//! triceBufferSwap swaps the trice double buffer and returns the read buffer address.
+static uint32_t *triceBufferSwap(void)
+{
+    if (triceActiveHalfBuffer == 0)
+    {
+        triceActiveHalfBuffer = 1;
+        TriceBufferWritePositionStart = triceWriteStartHalfBuffer1;
+        TriceBufferWritePosition = TriceBufferWritePositionStart;
+#if TRICE_PROTECT == 1
+        TriceBufferWritePositionLimit = triceWriteLimitHalfBuffer1;
+#endif
+        return triceWriteStartHalfBuffer0;
+    }
+    else
+    {
+        triceActiveHalfBuffer = 0;
+        TriceBufferWritePositionStart = triceWriteStartHalfBuffer0;
+        TriceBufferWritePosition = TriceBufferWritePositionStart;
+#if TRICE_PROTECT == 1
+        TriceBufferWritePositionLimit = triceWriteLimitHalfBuffer0;
+#endif
+        return triceWriteStartHalfBuffer1;
+    }
+}
+
+    #if TRICE_DIAGNOSTICS == 1
+//! TriceHalfBufferDepthMax is a diagnostics value usable to optimize buffer size.
+unsigned TriceHalfBufferDepthMax = 0;
+    #endif
+
+//! TriceTransfer, if possible, swaps the double buffer and initiates a write.
+//! It is the responsibility of the app to call this function once every 10-100 milliseconds.
+void TriceTransfer(void)
+{
+    if (0 == TriceOutDepth())   // transmission done for slowest output channel, so a swap is possible.
+    {
+        uint32_t *readBuf;
+        size_t tLen32;
+        TRICE_ENTER_CRITICAL_SECTION
+            tLen32 = TriceBufferWritePosition - TriceBufferWritePositionStart;
+        if (tLen32)   // Some Trice data are available.
+        {
+            readBuf = triceBufferSwap();
+            readBuf -= (TRICE_DATA_OFFSET >> 2);
+        }
+        TRICE_LEAVE_CRITICAL_SECTION
+        if (tLen32)
+        {
+            TriceOut(readBuf, tLen32 << 2);
+        }
+    }
+}
+
+//! TriceNext expects at *buf 32-bit aligned trice messages and returns the next one in pStart and pLen.
+//! \todo: use this function only when MULTI
+//! \param buf points to 32-bit aligned trice messages and is filled with the advanced buf.
+//! \param pSize contains the total size of all following trices including padding bytes to 32-bit alignments and gets the by next trice reduced value.
+//! \param pStart points to the net start of the next trice.
+//! \param pLen contains the net length of the first trice.
+//! \retval is the trice ID on success or negative on error.
+//! The trices inside the double buffer start 32-bit aligned with maybe 1-3 padding bytes in-between.
+//! \li |    ... |    trice   | trice | ... |  trice |
+//! \li before:  ^- buf
+//! \li before:  <-------------- pSize -------------->
+//! \li after:                 ^- buf
+//! \li after:                 <-------- pSize ------>
+//! \li after:     ^- pStart    (is input buf or input buf + 2)
+//! \li after:     <- pLen ->   (maybe 1-3 bytes shorter)
+static int TriceNext(uint8_t **buf, size_t *pSize, const uint8_t **pStart, size_t *pLen)
+{
+    uint16_t *pTID = (uint16_t *)*buf; // lint !e826, get TID address
+    unsigned TID = TRICE_TTOHS(*pTID); // type and id
+    int triceID = 0x3FFF & TID;
+    int triceType = TID >> 14;
+    unsigned offset;
+    size_t size = *pSize;
+    size_t triceSize;
+    size_t len;
+    switch (triceType)
+    {
+    case TRICE_TYPE_S0: // S0 = no stamp
+        *pStart = *buf;
+        offset = 0;
+        len = 4 + triceDataLen(*pStart + 2); // tyId
+        break;
+    case TRICE_TYPE_S2: // S2 = 16-bit stamp
+        *pStart = *buf; // see Id(n) macro definition
+        *pStart += 2;   // see Id(n) macro definition
+        offset = 2;
+        len = 6 + triceDataLen(*pStart + 4); // tyId ts16
+        break;
+    case TRICE_TYPE_S4: // S4 = 32-bit stamp
+        *pStart = *buf;
+        offset = 0;
+        len = 8 + triceDataLen(*pStart + 6); // tyId ts32
+        break;
+    default: // impossible
+             // fallthrugh
+    case TRICE_TYPE_X0:
+        TriceErrorCount++;
+        *pStart = 0;
+        *pLen = 0;
+        return -__LINE__; // extended trices not supported (yet)
+    }
+    triceSize = (len + offset + 3) & ~3;
+    // S16 case example:            triceSize  len   t-0-3   t-o
+    // 80id 80id 1616 00cc                8     6      3      6
+    // 80id 80id 1616 01cc dd            12     7      7     10
+    // 80id 80id 1616 02cc dd dd         12     8      7     10
+    // 80id 80id 1616 03cc dd dd dd      12     9      7     10
+    // 80id 80id 1616 04cc dd dd dd dd   12    10      7     10
+    if (!(triceSize - (offset + 3) <= len && len <= triceSize - offset))   // corrupt data
+    {
+        TriceErrorCount++;
+        return -__LINE__;
+    }
+    size -= triceSize;
+    *buf += triceSize;
+    *pSize = size;
+    *pLen = len;
+    return triceID;
+}
+
+uint8_t *firstNotModifiedAddress;
+int distance;
+int triceDataOffsetDepth;
+
+//! TriceOut encodes trices and writes them in one step to the output.
+//! This function is called only, when the slowest deferred output device has finished its last buffer.
+//! At the half buffer start tb are TRICE_DATA_OFFSET bytes space followed by a number of trice messages which all contain
+//! 0-3 padding bytes and therefore have a length of a multiple of 4. There is no additional space between these trice messages.
+//! When XTEA enabled, only (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE) is allowed, because the 4 bytes behind a trice messages
+//! are changed, when the trice length is not a multiple of 8, but only of 4. (XTEA can encrypt only multiple of 8 length packages.)
+//! \param tb is start of uint32_t* trice buffer. The space TRICE_DATA_OFFSET at the tb start is for in-buffer encoding of the trice data.
+//! \param tLen is total length of several trice data. It is always a multiple of 4 because of 32-bit alignment and padding bytes.
+static void TriceOut(uint32_t *tb, size_t tLen)
+{
+    uint8_t *enc = (uint8_t *)tb;           // This is the later encoded data starting address.
+    uint8_t *dat = enc + TRICE_DATA_OFFSET; // This is the start of      32-bit aligned trices.
+    uint8_t *nxt = dat;                     // This is the start of next 32-bit aligned trices.
+    size_t encLen = 0;
+#if (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE) && ((TRICE_PROTECT == 1) || (TRICE_DIAGNOSTICS == 1))
+    uint8_t *dst = enc; // This value dst must not get > nxt to avoid overwrites.
+#endif
+    int triceID = 0; // This assignment is only needed to silence compiler complains about being uninitialized.
+#if TRICE_DIAGNOSTICS == 1
+    unsigned depth = tLen + TRICE_DATA_OFFSET;
+    TriceHalfBufferDepthMax = depth < TriceHalfBufferDepthMax ? TriceHalfBufferDepthMax : depth;
+#endif
+    // do it
+    while (tLen)
+    {
+#if TRICE_DIAGNOSTICS == 1
+        firstNotModifiedAddress = enc + encLen;
+        distance = nxt - firstNotModifiedAddress;
+        triceDataOffsetDepth = TRICE_DATA_OFFSET - distance; // distance can get > TRICE_DATA_OFFSET, but that is no problem.
+        TriceDataOffsetDepthMax = triceDataOffsetDepth < TriceDataOffsetDepthMax ? TriceDataOffsetDepthMax : triceDataOffsetDepth;
+#endif // #if TRICE_DIAGNOSTICS == 1
+        const uint8_t *triceNettoStart;
+        size_t triceNettoLen; // This is the trice netto length (without padding bytes).
+#if (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING != TRICE_FRAMING_NONE) && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE)
+        uint8_t *crypt = nxt - 4; // only 8-byte groups are encryptable
+#endif
+        triceID = TriceNext(&nxt, &tLen, &triceNettoStart, &triceNettoLen);
+        if (triceID <= 0)   // on data error
+        {
+            TriceErrorCount++;
+            break; // ignore following data
+        }
+#if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+        uint8_t *dst = enc + encLen;
+#if (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS)
+        memmove(crypt, triceNettoStart, triceNettoLen);
+        size_t len8 = (triceNettoLen + 7) & ~7;                   // Only multiple of 8 encryptable, so we adjust len.
+        memset((crypt)+triceNettoLen, 0, len8 - triceNettoLen);   // Clear padding space.
+        XTEAEncrypt((uint32_t *)crypt, len8 >> 2);
+        encLen += (size_t)TCOBSEncode(dst, crypt, len8); // encLen is re-used here
+        dst[encLen++] = 0;                               // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)
+        memmove(crypt, triceNettoStart, triceNettoLen);
+        size_t len8 = (triceNettoLen + 7) & ~7;                   // Only multiple of 8 encryptable, so we adjust len.
+        memset((crypt)+triceNettoLen, 0, len8 - triceNettoLen);   // Clear padding space.
+        XTEAEncrypt((uint32_t *)crypt, len8 >> 2);
+        encLen += (size_t)COBSEncode(dst, crypt, len8); // encLen is re-used here
+        dst[encLen++] = 0;                              // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+#if TRICE_CONFIG_WARNINGS == 1
+#error configuration: The Trice tool does not support encryted data without COBS or TCOBS framing.
+#endif
+        // memmove(dst, triceNettoStart, triceNettoLen );
+        // size_t len8 = (triceNettoLen + 7) & ~7; // Only multiple of 8 encryptable, so we adjust len.
+        // memset((enc)+triceNettoLen, 0, len8 - triceNettoLen); // Clear padding space.
+        // XTEAEncrypt( (uint32_t *)enc, len8>>2 );
+        // encLen += len8; // encLen is re-used here
+        // nextPosForEncoding = dst+encLen;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS)
+        size_t len = (size_t)TCOBSEncode(dst, triceNettoStart, triceNettoLen);
+        dst[len++] = 0; // Add zero as package delimiter.
+        encLen += len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)
+        size_t len = (size_t)COBSEncode(dst, triceNettoStart, triceNettoLen);
+        dst[len++] = 0; // Add zero as package delimiter.
+        encLen += len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+        memmove(dst, triceNettoStart, triceNettoLen);
+        encLen += triceNettoLen;
+#else
+#error configuration: unexpected
+#endif
+#elif TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+        // pack data
+        uint8_t *packed = dat + encLen;                  // After the loop, the packed data start at dat.
+        memmove(packed, triceNettoStart, triceNettoLen); // This action removes all padding bytes of the trices, compacting their sequence this way
+        encLen += triceNettoLen;
+#endif // #elif  TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+#if (TRICE_PROTECT == 1) || (TRICE_DIAGNOSTICS == 1)
+        dst = enc + encLen;                           // When several Trices in the double buffer, with each encoding the new dst could drift a bit closer towards triceNettoStart.
+        int triceDataOffsetSpaceRemained = nxt - dst; // THe begin of unprocessed data MINUS next dst must not be negative.
+#endif
+#if (TRICE_PROTECT == 1)
+        if (triceDataOffsetSpaceRemained < 0)
+        {
+            TriceErrorCount++;
+            return; // discard broken data to avoid buffer overflow
+        }
+#endif
+#if TRICE_DIAGNOSTICS == 1
+        int triceDataOffsetDepth = TRICE_DATA_OFFSET - triceDataOffsetSpaceRemained;
+        TriceDataOffsetDepthMax = triceDataOffsetDepth < TriceDataOffsetDepthMax ? TriceDataOffsetDepthMax : triceDataOffsetDepth;
+#endif
+    }
+#if TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+    // At this point the compacted trice messages start TRICE_DATA_OFFSET bytes after tb (now dat) and the encLen is their total netto length.
+    // Behind this up to 7 bytes can be used as scratch pad when XTEA is active. That is ok, because the half buffer should not get totally filled.
+    // encLen = TriceEncode( TRICE_DEFERRED_XTEA_ENCRYPT, TRICE_DEFERRED_OUT_FRAMING, enc, dat, encLen );
+#if (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS) // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    // special case: The data are at dat and can be big, are compacted and behind them is space. So we can encrypt them in space
+    size_t len8 = (encLen + 7) & ~7;                    // Only multiple of 8 encryptable, so we adjust len.
+    memset(((uint8_t *)dat) + encLen, 0, len8 - encLen); // clear padding space: ATTENTION! OK only for this compiler switch setting.
+    XTEAEncrypt((uint32_t *)dat, len8 >> 2);
+    size_t eLen = (size_t)TCOBSEncode(enc, dat, len8);                                          // encLen is re-used here
+    enc[eLen++] = 0;                                                                            // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)  // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    // special case: The data are at dat and can be big, are compacted and behind them is space. So we can encrypt them in space
+    size_t len8 = (encLen + 7) & ~7;                    // Only multiple of 8 encryptable, so we adjust len.
+    memset(((uint8_t *)dat) + encLen, 0, len8 - encLen); // clear padding space: ATTENTION! OK only for this compiler switch setting.
+    XTEAEncrypt((uint32_t *)dat, len8 >> 2);
+    size_t eLen = (size_t)COBSEncode(enc, dat, len8); // encLen is re-used here
+    enc[eLen++] = 0;                                  // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)  // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    size_t eLen = TriceEncode(TRICE_DEFERRED_XTEA_ENCRYPT, TRICE_DEFERRED_OUT_FRAMING, enc, dat, encLen);
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS) // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    size_t eLen = TCOBSEncode(enc, dat, encLen);
+    enc[eLen++] = 0; // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)  // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    size_t eLen = (size_t)COBSEncode(enc, dat, encLen);
+    enc[eLen++] = 0; // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)  // && (TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE)
+    enc = dat;
+    size_t eLen = encLen;
+#else
+#error configuration:
+#endif
+#if TRICE_DIAGNOSTICS
+    // before: space = enc[TRICE_DATA_OFFSET], data = dat[encLen]
+    // after:  date  = enc[eLen], (dat [encLen])
+    // Mostly eLen < encLen, but it could be eLen = encLen + 1 + (encLen>>5) in TCOBS worst case.
+    // dat - enc = TRICE_DATA_OFFSET
+    // if eLen > encLen, then TriceDataOffsetDepth = eLen - encLen
+    int triceDataOffsetDepth = eLen - encLen; // usually negative
+    TriceDataOffsetDepthMax = triceDataOffsetDepth < TriceDataOffsetDepthMax ? TriceDataOffsetDepthMax : triceDataOffsetDepth;
+#endif
+    encLen = eLen;
+#endif
+
+    // Reaching here means all trice data in the current half buffer are encoded
+    // into a single continuous buffer having 0-delimiters between them or not but at the ent is a 0-delimiter.
+    //
+    // output
+    TRICE_ENTER_CRITICAL_SECTION
+        TriceNonBlockingDeferredWrite8(triceID, enc, encLen); // lint !e771 Info 771: Symbol 'triceID' conceivably not initialized. Comment: tLen is always > 0.
+    TRICE_LEAVE_CRITICAL_SECTION
+}
+
+#endif // #if TRICE_BUFFER == TRICE_DOUBLE_BUFFER && TRICE_OFF == 0

Middlewares/trice/triceMcuOrder.h

@@ -0,0 +1,45 @@
+/*! \file triceMcuOrder.h
+\author Thomas.Hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#if !defined(TRICE_HTOTS) && !defined(TRICE_HTOTL) && !defined(TRICE_TTOHS)
+
+#define TRICE_HTOTS(x) ((uint16_t)(x)) //! TRICE_HTOTS reorders short values from host order into trice transfer order.
+#define TRICE_HTOTL(x) ((uint32_t)(x)) //! TRICE_HTOTL reorders long values from host order x into trice transfer order.
+#define TRICE_TTOHS(x) ((uint16_t)(x)) //! TRICE_TTOHS reorders short values from trice transfer order into host order.
+
+#endif //! defined(TRICE_HTOTS) && !defined(TRICE_HTOTL) && !defined(TRICE_TTOHS)
+
+#if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0
+
+//! TRICE_PUT16_1616 writes a 16-bit value followed by a 32-bit value in 2 16-bit steps to avoid memory alignment hard fault.
+#define TRICE_PUT16_1616(x, ts) /* little endian */        \
+	do {                                                   \
+		uint16_t* p = (uint16_t*)TriceBufferWritePosition; \
+		*p++ = x;                                          \
+		*p++ = ts;         /* lo */                        \
+		*p++ = (ts) >> 16; /* hi */                        \
+		TriceBufferWritePosition = (uint32_t*)p;           \
+	} while (0)
+
+#define TRICE_PUT64(x)        \
+	TRICE_PUT((uint32_t)(x)); \
+	TRICE_PUT((uint32_t)((uint64_t)(x) >> 32)); // little endian
+
+#else                           // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0
+
+//! TRICE_PUT16_1616 writes a 16-bit value followed by a 32-bit value in 2 16-bit steps to avoid memory alignment hard fault.
+#define TRICE_PUT16_1616(x, ts) /* big endian */           \
+	do {                                                   \
+		uint16_t* p = (uint16_t*)TriceBufferWritePosition; \
+		*p++ = x;                                          \
+		*p++ = (ts) >> 16; /* hi */                        \
+		*p++ = ts;         /* lo */                        \
+		TriceBufferWritePosition = (uint32_t*)p;           \
+	} while (0)
+
+#define TRICE_PUT64(x)              \
+	TRICE_PUT((uint64_t)(x) >> 32); \
+	TRICE_PUT((uint32_t)(x)); // big endian
+
+#endif // #else // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0

Middlewares/trice/triceMcuReverse.h

@@ -0,0 +1,88 @@
+/*! \file triceMcuReverse.h
+\author Thomas.Hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+//! Note:  https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
+#if defined __has_include //! __has_include is a macro defined in several compilers including GCC and integrated into the C23 standard (Note N2799)
+#if __has_include(<byteswap.h>)
+#include <byteswap.h> // https://codereview.stackexchange.com/questions/151049/endianness-conversion-in-c
+#define TRICE_LIBC_BYTESWAP 1
+#endif
+#endif
+
+// Swap a 16-bit integer (https://www.oryx-embedded.com/doc/cpu__endian_8h_source.html)
+TRICE_INLINE uint16_t TriceReverse16(uint16_t value) {
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || (defined(__clang__) && __has_builtin(__builtin_bswap16))
+	return __builtin_bswap16(value);
+#elif (defined(TRICE_LIBC_BYTESWAP) && TRICE_LIBC_BYTESWAP == 1)
+	return __bswap_16(value);
+#else
+	return (((value & 0x00FF) << 8) |
+	        ((value & 0xFF00) >> 8));
+#endif
+}
+// Swap a 32-bit integer (https://www.oryx-embedded.com/doc/cpu__endian_8h_source.html)
+TRICE_INLINE uint32_t TriceReverse32(uint32_t value) {
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) || (defined(__clang__) && __has_builtin(__builtin_bswap32))
+	return __builtin_bswap32(value);
+#elif (defined(TRICE_LIBC_BYTESWAP) && TRICE_LIBC_BYTESWAP == 1)
+	return __bswap_32(value);
+#else
+	return (((value & 0x000000FF) << 24) |
+	        ((value & 0x0000FF00) << 8) |
+	        ((value & 0x00FF0000) >> 8) |
+	        ((value & 0xFF000000) >> 24));
+#endif
+}
+
+#if !defined(TRICE_HTOTS) && !defined(TRICE_HTOTL) && !defined(TRICE_TTOHS)
+#define TRICE_HTOTS(x) TriceReverse16(x) //!< TRICE_HTOTS reorders short values from host order into trice transfer order.
+#define TRICE_HTOTL(x) TriceReverse32(x) //!< TRICE_HTOTL reorders long values from host order x into trice transfer order.
+#define TRICE_TTOHS(x) TriceReverse16(x) //!< TRICE_TTOHS reorders short values from trice transfer order into host order.
+#endif
+
+#if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0
+
+//! TRICE_PUT16_1616 writes a 16-bit value followed by a 32-bit value in 2 16-bit steps to avoid memory alignment hard fault.
+#define TRICE_PUT16_1616(x, ts) /* little endian */        \
+	do {                                                   \
+		uint16_t* p = (uint16_t*)TriceBufferWritePosition; \
+		*p++ = TRICE_HTOTS(x);                             \
+		*p++ = TRICE_HTOTS(ts);         /* lo */           \
+		*p++ = TRICE_HTOTS((ts) >> 16); /* hi */           \
+		TriceBufferWritePosition = (uint32_t*)p;           \
+	} while (0)
+
+#define TRICE_PUT64(x)                     \
+	TRICE_PUT(TRICE_HTOTL((uint32_t)(x))); \
+	TRICE_PUT(TRICE_HTOTL((uint32_t)((uint64_t)(x) >> 32))); // little endian
+
+#else                           // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0
+
+//! TRICE_PUT16_1616 writes a 16-bit value followed by a 32-bit value in 2 16-bit steps to avoid memory alignment hard fault.
+#define TRICE_PUT16_1616(x, ts) /* big endian */           \
+	do {                                                   \
+		uint16_t* p = (uint16_t*)TriceBufferWritePosition; \
+		*p++ = TRICE_HTOTS(x);                             \
+		*p++ = TRICE_HTOTS((ts) >> 16); /* hi */           \
+		*p++ = TRICE_HTOTS(ts);         /* lo */           \
+		TriceBufferWritePosition = (uint32_t*)p;           \
+	} while (0)
+
+#define TRICE_PUT64(x)                           \
+	TRICE_PUT(TRICE_HTOTL((uint64_t)(x) >> 32)); \
+	TRICE_PUT(TRICE_HTOTL((uint32_t)(x))); // big endian
+
+#endif // #else // #if TRICE_TRANSFER_ORDER_IS_BIG_ENDIAN == 0
+
+#define idLH TRICE_HTOTS(0x4000 | (tid)) //!< idLH is the no-stamp tid, byte swapped to be used in TRICE_PUT, when TRICE_REVERSE == 1.
+#define IdLH TRICE_HTOTS(0x8000 | (tid)) //!< IdLH is the 16-bit-stamp tid, byte swapped to be used in TRICE_PUT, when TRICE_REVERSE == 1.
+#define IDLH TRICE_HTOTS(0xc000 | (tid)) //!< IDLH is the 32-bit-stamp tid, byte swapped to be used in TRICE_PUT, when TRICE_REVERSE == 1.
+
+#define tsL ((0x00ff & ts) << 8)
+#define tsH ((0xff00 & ts) >> 8)
+
+#define tsHH ((0xFF000000 & ts) >> 8)
+#define tsHL ((0x00FF0000 & ts) << 8)
+#define tsLH ((0x0000FF00 & ts) >> 8)
+#define tsLL ((0x000000FF & ts) << 8)

Middlewares/trice/triceOff.h

@@ -0,0 +1,444 @@
+/*!
+ *  \file triceOff.h
+   \author thomas.hoehenleitner [at] seerose.net
+ *     *****************************************************************************
+ */
+
+// global function prototypes: (not all always used)
+
+#define TriceInitRingBufferMargins()
+#define WatchRingBufferMargins()
+#define TriceDiagnostics(index) TRICE_UNUSED(index)
+#define TriceNonBlockingWriteUartA(buf, nByte) TRICE_UNUSED(buf) TRICE_UNUSED(nByte)
+#define TriceNonBlockingWriteUartB(buf, nByte) TRICE_UNUSED(buf) TRICE_UNUSED(nByte)
+#define TriceNonBlockingDirectWrite(triceStart, wordCount) TRICE_UNUSED(triceStart) TRICE_UNUSED(wordCount)
+#define TriceNonBlockingDirectWrite8Auxiliary(enc, encLen) TRICE_UNUSED(enc) TRICE_UNUSED(encLen)
+#define TriceNonBlockingDeferredWrite8Auxiliary(enc, encLen) TRICE_UNUSED(enc) TRICE_UNUSED(encLen)
+#define TriceNonBlockingDirectWrite32Auxiliary(enc, count) TRICE_UNUSED(enc) TRICE_UNUSED(encLen)
+#define TriceNonBlockingDeferredWrite32Auxiliary(enc, count) TRICE_UNUSED(enc) TRICE_UNUSED(encLen)
+#define TriceInit()
+#define TriceLogDiagnosticData()
+#define TriceLogSeggerDiagnostics()
+#define TriceNonBlockingDeferredWrite8(ticeID, enc, encLen) TRICE_UNUSED(ticeID) TRICE_UNUSED(enc) TRICE_UNUSED(encLen)
+#define TriceTransfer()
+#define triceDataLen(p)
+#define TriceEnoughSpace()
+#define TriceOutDepth()
+#define TriceDepth()
+#define TriceDepthMax()
+#define TriceEncode(encrypt, framing, dst, buf, len) TRICE_UNUSED(encrypt) TRICE_UNUSED(framing) TRICE_UNUSED(dst) TRICE_UNUSED(len)
+#define TriceWriteDeviceCgo(buf, len) TRICE_UNUSED(buf) TRICE_UNUSED(len) //!< TriceWriteDeviceCgo is only needed for testing C-sources from Go.
+
+#define TriceBlockingWriteUartA(buf, len) TRICE_UNUSED(buf) TRICE_UNUSED(len)
+#define triceServeTransmitUartA()
+#define triceTriggerTransmitUartA()
+#define TriceOutDepthUartA()
+
+#define TriceBlockingWriteUartB(buf, len) TRICE_UNUSED(buf) TRICE_UNUSED(len)
+#define triceServeTransmitUartB()
+#define triceTriggerTransmitUartB()
+#define TriceOutDepthUartB()
+
+#define XTEAEncrypt(p, n) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define XTEADecrypt(p, n) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define XTEAInitTable()
+
+#define TRICE_XTEA_H_ // do not include xtea.h
+#define COBS_H_       // do not include cobs.h
+#define TCOBS_H_      // do not include tcobs.h
+#define SEGGER_RTT_H  // do not include SEGGER_RTT.h
+
+// Trice functions and macros
+
+#define id(n) (n)
+#define Id(n) (n)
+#define ID(n) (n)
+#define iD(n) (n)
+
+#define TRICE_ENTER
+#define TRICE_LEAVE
+#define TRICE_PUT(n) TRICE_UNUSED(n)
+#define TRICE_PUT16(n) TRICE_UNUSED(n)
+#define TRICE_PUT16_1616(x, n)
+#define PUT_BUFFER(p, n) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE0(pFmt, ...)
+#define trice0(pFmt, ...)
+#define Trice0(pFmt, ...)
+#define TRice0(pFmt, ...)
+
+// clang-format off
+//  TRICE_INLINE void trice0( const char * pFmt ){TRICE_UNUSED(pFmt)}
+//  TRICE_INLINE void Trice0( const char * pFmt ){TRICE_UNUSED(pFmt)}
+//  TRICE_INLINE void TRice0( const char * pFmt ){TRICE_UNUSED(pFmt)}
+
+TRICE_INLINE void triceAssertTrue(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+TRICE_INLINE void TriceAssertTrue(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+TRICE_INLINE void TRiceAssertTrue(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+
+TRICE_INLINE void triceAssertFalse(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+TRICE_INLINE void TriceAssertFalse(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+TRICE_INLINE void TRiceAssertFalse(int idN, char *msg, int flag)
+{
+    TRICE_UNUSED(idN) TRICE_UNUSED(msg) TRICE_UNUSED(flag)
+}
+
+// All following macros are defined without ID and as variadic, to avoid editor warnings for TRICE_CLEAN == 1 or TRICE_OFF == 1
+
+#define TRICE_S(p, s, ...) TRICE_UNUSED(p) TRICE_UNUSED(s)
+#define triceS( p, s, ...) TRICE_UNUSED(p) TRICE_UNUSED(s)
+#define TriceS( p, s, ...) TRICE_UNUSED(p) TRICE_UNUSED(s)
+#define TRiceS( p, s, ...) TRICE_UNUSED(p) TRICE_UNUSED(s)
+
+#define TRICE_N(p, s, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(s) TRICE_UNUSED(n)
+#define triceN( p, s, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(s) TRICE_UNUSED(n)
+#define TriceN( p, s, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(s) TRICE_UNUSED(n)
+#define TRiceN( p, s, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(s) TRICE_UNUSED(n)
+
+// #define TRICE_B(iD, ...)
+#define triceB(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TriceB(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRiceB(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+// #define TRICE_F(iD, ...)
+#define triceF(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TriceF(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRiceF(p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE(  fmt, ...)
+#define trice(  fmt, ...)
+#define Trice(  fmt, ...)
+#define TRice(  fmt, ...)
+#define TRICE8( fmt, ...)
+#define trice8( fmt, ...)
+#define Trice8( fmt, ...)
+#define TRice8( fmt, ...)
+#define TRICE16(fmt, ...)
+#define trice16(fmt, ...)
+#define Trice16(fmt, ...)
+#define TRice16(fmt, ...)
+#define TRICE32(fmt, ...)
+#define trice32(fmt, ...)
+#define Trice32(fmt, ...)
+#define TRice32(fmt, ...)
+#define TRICE64(fmt, ...)
+#define trice64(fmt, ...)
+#define Trice64(fmt, ...)
+#define TRice64(fmt, ...)
+
+#define TRICE_0( fmt, ...)
+#define TRICE_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRICE_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRICE_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRICE_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRICE_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRICE_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRICE_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRICE_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRICE_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRICE_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRICE_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRICE_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define trice_0( fmt, ...)
+#define trice_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define trice_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define trice_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define trice_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define trice_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define trice_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define trice_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define trice_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define trice_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define trice_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define trice_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define trice_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define Trice_0( fmt, ...)
+#define Trice_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define Trice_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define Trice_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define Trice_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define Trice_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define Trice_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define Trice_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define Trice_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define Trice_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define Trice_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define Trice_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define Trice_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define TRice_0( fmt, ...)
+#define TRice_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRice_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRice_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRice_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRice_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRice_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRice_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRice_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRice_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRice_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRice_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRice_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+
+#define TRICE8_B(id, fmt, p, n ) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice8B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice8B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice8B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRICE8_F(id, fmt, p, n ) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice8F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice8F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice8F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE8_0( fmt, ...)
+#define TRICE8_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRICE8_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRICE8_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRICE8_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRICE8_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRICE8_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRICE8_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRICE8_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRICE8_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRICE8_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRICE8_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRICE8_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define trice8_0( fmt, ...)
+#define trice8_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define trice8_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define trice8_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define trice8_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define trice8_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define trice8_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define trice8_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define trice8_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define trice8_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define trice8_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define trice8_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define trice8_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define Trice8_0( fmt, ...)
+#define Trice8_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define Trice8_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define Trice8_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define Trice8_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define Trice8_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define Trice8_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define Trice8_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define Trice8_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define Trice8_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define Trice8_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define Trice8_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define Trice8_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define TRice8_0( fmt, ...)
+#define TRice8_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRice8_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRice8_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRice8_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRice8_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRice8_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRice8_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRice8_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRice8_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRice8_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRice8_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRice8_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+
+#define TRICE16_B(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice16B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice16B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice16B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRICE16_F(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice16F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice16F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice16F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE16_0( fmt, ...)
+#define TRICE16_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRICE16_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRICE16_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRICE16_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRICE16_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRICE16_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRICE16_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRICE16_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRICE16_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRICE16_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRICE16_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRICE16_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define trice16_0( fmt, ...)
+#define trice16_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define trice16_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define trice16_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define trice16_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define trice16_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define trice16_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define trice16_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define trice16_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define trice16_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define trice16_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define trice16_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define trice16_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define Trice16_0( fmt, ...)
+#define Trice16_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define Trice16_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define Trice16_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define Trice16_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define Trice16_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define Trice16_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define Trice16_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define Trice16_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define Trice16_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define Trice16_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define Trice16_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define Trice16_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define TRice16_0( fmt, ...)
+#define TRice16_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRice16_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRice16_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRice16_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRice16_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRice16_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRice16_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRice16_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRice16_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRice16_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRice16_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRice16_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+
+#define TRICE32_B(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice32B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice32B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice32B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRICE32_F(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice32F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice32F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice32F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE32_0( fmt, ...)
+#define TRICE32_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRICE32_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRICE32_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRICE32_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRICE32_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRICE32_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRICE32_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRICE32_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRICE32_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRICE32_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRICE32_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRICE32_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define trice32_0( fmt, ...)
+#define trice32_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define trice32_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define trice32_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define trice32_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define trice32_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define trice32_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define trice32_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define trice32_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define trice32_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define trice32_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define trice32_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define trice32_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define Trice32_0( fmt, ...)
+#define Trice32_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define Trice32_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define Trice32_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define Trice32_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define Trice32_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define Trice32_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define Trice32_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define Trice32_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define Trice32_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define Trice32_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define Trice32_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define Trice32_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define TRice32_0( fmt, ...)
+#define TRice32_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRice32_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRice32_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRice32_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRice32_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRice32_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRice32_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRice32_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRice32_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRice32_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRice32_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRice32_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+
+#define TRICE64_B(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice64B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice64B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice64B( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRICE64_F(fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define trice64F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define Trice64F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+#define TRice64F( fmt, p, n, ...) TRICE_UNUSED(p) TRICE_UNUSED(n)
+
+#define TRICE64_0( fmt, ...)
+#define TRICE64_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRICE64_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRICE64_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRICE64_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRICE64_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRICE64_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRICE64_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRICE64_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRICE64_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRICE64_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRICE64_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRICE64_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define trice64_0( fmt, ...)
+#define trice64_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define trice64_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define trice64_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define trice64_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define trice64_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define trice64_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define trice64_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define trice64_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define trice64_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define trice64_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define trice64_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define trice64_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define Trice64_0( fmt, ...)
+#define Trice64_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define Trice64_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define Trice64_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define Trice64_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define Trice64_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define Trice64_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define Trice64_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define Trice64_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define Trice64_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define Trice64_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define Trice64_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define Trice64_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+#define TRice64_0( fmt, ...)
+#define TRice64_1( fmt, v0, ...) TRICE_UNUSED(v0)
+#define TRice64_2( fmt, v0, v1, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1)
+#define TRice64_3( fmt, v0, v1, v2, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2)
+#define TRice64_4( fmt, v0, v1, v2, v3, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3)
+#define TRice64_5( fmt, v0, v1, v2, v3, v4, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4)
+#define TRice64_6( fmt, v0, v1, v2, v3, v4, v5, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5)
+#define TRice64_7( fmt, v0, v1, v2, v3, v4, v5, v6, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6)
+#define TRice64_8( fmt, v0, v1, v2, v3, v4, v5, v6, v7, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7)
+#define TRice64_9( fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8)
+#define TRice64_10(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9)
+#define TRice64_11(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10)
+#define TRice64_12(fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, ...) TRICE_UNUSED(v0) TRICE_UNUSED(v1) TRICE_UNUSED(v2) TRICE_UNUSED(v3) TRICE_UNUSED(v4) TRICE_UNUSED(v5) TRICE_UNUSED(v6) TRICE_UNUSED(v7) TRICE_UNUSED(v8) TRICE_UNUSED(v9) TRICE_UNUSED(v10) TRICE_UNUSED(v11)
+// clang-format on

Middlewares/trice/triceOn.h

@@ -0,0 +1,434 @@
+/*! \file triceOn.h
+\author thomas.hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// The variadic macros need to be defined before `#include "triceOff.h"`.
+// When TRICE OFF == 1, the  variadic macros cannot simply be defined as empty macros, because then unused parameter warnings pop up.
+//
+
+//! TRICE_NTH_ARGUMENT just evaluates to the 15th argument. It is extendable until a 32764 bytes payload.
+//! Variadic macros (https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms)
+//! See for more explanation https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments
+#define TRICE_NTH_ARGUMENT(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, ...) a14
+
+//! TRICE_COUNT_ARGUMENTS builds upon TRICE_NTH_ARGUMENT. The more arguments that are passed to TRICE_COUNT_ARGUMENTS,
+//! the more the »counting arguments« (12, 11, 10, 9, 8, 7…) are pushed to the right.
+//! Thus the macro evaluates to the number of arguments that are passed to the macro.
+//! If you set the C language to strict C (C90, C99, C11 or C17) the `##` operator doesn't remove the comma before it when `__VA_ARGS__` expands to nothing.
+//! In this case, the TRICE macro doesn't work with no parameters. You must then explicitly use TRICE0 instead of TRICE for a no parameter value TRICE.
+//! For more details see closed Issue #279. Special thanks to [@escherstair](https://github.com/escherstair).
+//! If for example using CLANG 6.18 set C-language to gnu11, gnu99 or std to avoid the comma issue when no parameters are in a TRICE  macro.
+//! In case you have to set the C-Language to c11 or c99 you can use the TRICE0 macro directly instead of TRICE when no value parameters.
+#define TRICE_COUNT_ARGUMENTS(...) TRICE_NTH_ARGUMENT(dummy, ##__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+
+//! TRICE_CONCAT concatenates the 2 arguments a and b (helper macro).
+#define TRICE_CONCAT(a, b) a##b
+
+//! TRICE_CONCAT2 concatenates the 2 arguments a and b (helper macro).
+#define TRICE_CONCAT2(a, b) TRICE_CONCAT(a, b)
+
+// clang-format off
+#define TRICE(  tid, fmt, ...) TRICE_CONCAT2(TRICE_,   TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define trice(  tid, fmt, ...) TRICE_CONCAT2(trice_,   TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define Trice(  tid, fmt, ...) TRICE_CONCAT2(Trice_,   TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRice(  tid, fmt, ...) TRICE_CONCAT2(TRice_,   TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRICE8( tid, fmt, ...) TRICE_CONCAT2(TRICE8_,  TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define trice8( tid, fmt, ...) TRICE_CONCAT2(trice8_,  TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define Trice8( tid, fmt, ...) TRICE_CONCAT2(Trice8_,  TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRice8( tid, fmt, ...) TRICE_CONCAT2(TRice8_,  TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRICE16(tid, fmt, ...) TRICE_CONCAT2(TRICE16_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define trice16(tid, fmt, ...) TRICE_CONCAT2(trice16_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define Trice16(tid, fmt, ...) TRICE_CONCAT2(Trice16_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRice16(tid, fmt, ...) TRICE_CONCAT2(TRice16_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRICE32(tid, fmt, ...) TRICE_CONCAT2(TRICE32_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define trice32(tid, fmt, ...) TRICE_CONCAT2(trice32_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define Trice32(tid, fmt, ...) TRICE_CONCAT2(Trice32_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRice32(tid, fmt, ...) TRICE_CONCAT2(TRice32_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRICE64(tid, fmt, ...) TRICE_CONCAT2(TRICE64_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define trice64(tid, fmt, ...) TRICE_CONCAT2(trice64_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define Trice64(tid, fmt, ...) TRICE_CONCAT2(Trice64_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+#define TRice64(tid, fmt, ...) TRICE_CONCAT2(TRice64_, TRICE_COUNT_ARGUMENTS(__VA_ARGS__))(tid, fmt, ##__VA_ARGS__)
+// clang-format on
+
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// global function prototypes: (not all always used)
+
+void TriceInitRingBufferMargins(void);
+void WatchRingBufferMargins(void);
+void TriceCheck(int index); //!< tests and examples
+void TriceDiagnostics(int index);
+void TriceNonBlockingWriteUartA(const void* buf, size_t nByte);
+void TriceNonBlockingWriteUartB(const void* buf, size_t nByte);
+void TriceNonBlockingDirectWrite(uint32_t* triceStart, unsigned wordCount);
+void TriceNonBlockingDirectWrite8Auxiliary(const uint8_t* enc, size_t encLen);
+void TriceNonBlockingDeferredWrite8Auxiliary(const uint8_t* enc, size_t encLen);
+void TriceNonBlockingDirectWrite32Auxiliary(const uint32_t* enc, unsigned count);
+void TriceNonBlockingDeferredWrite32Auxiliary(const uint32_t* enc, unsigned count);
+void TriceInit(void);
+void TriceLogDiagnosticData(void);
+void TriceLogSeggerDiagnostics(void);
+void TriceNonBlockingDeferredWrite8(int ticeID, const uint8_t* enc, size_t encLen);
+void TriceTransfer(void);
+size_t triceDataLen(const uint8_t* p);
+int TriceEnoughSpace(void);
+unsigned TriceOutDepth(void);
+size_t TriceDepth(void);
+size_t TriceDepthMax(void);
+size_t TriceEncode(unsigned encrypt, unsigned framing, uint8_t* dst, const uint8_t* buf, size_t len);
+void TriceWriteDeviceCgo(const void* buf, unsigned len); //!< TriceWriteDeviceCgo is only needed for testing C-sources from Go.
+unsigned TriceOutDepthCGO(void);                         //!< TriceOutDepthCGO is only needed for testing C-sources from Go.
+
+void TriceBlockingWriteUartA(const uint8_t* buf, unsigned len);
+void triceServeTransmitUartA(void);
+void triceTriggerTransmitUartA(void);
+unsigned TriceOutDepthUartA(void);
+
+void TriceBlockingWriteUartB(const uint8_t* buf, unsigned len);
+void triceServeTransmitUartB(void);
+void triceTriggerTransmitUartB(void);
+unsigned TriceOutDepthUartB(void);
+
+void XTEAEncrypt(uint32_t* p, unsigned count);
+void XTEADecrypt(uint32_t* p, unsigned count);
+void XTEAInitTable(void);
+
+// Trice functions and macros
+
+void trice8fn_0(uint16_t tid);
+void trice8fn_1(uint16_t tid, uint8_t v0);
+void trice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1);
+void trice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2);
+void trice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3);
+void trice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4);
+void trice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5);
+void trice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6);
+void trice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7);
+void trice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8);
+void trice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9);
+void trice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10);
+void trice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11);
+
+void Trice8fn_0(uint16_t tid);
+void Trice8fn_1(uint16_t tid, uint8_t v0);
+void Trice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1);
+void Trice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2);
+void Trice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3);
+void Trice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4);
+void Trice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5);
+void Trice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6);
+void Trice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7);
+void Trice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8);
+void Trice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9);
+void Trice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10);
+void Trice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11);
+
+void TRice8fn_0(uint16_t tid);
+void TRice8fn_1(uint16_t tid, uint8_t v0);
+void TRice8fn_2(uint16_t tid, uint8_t v0, uint8_t v1);
+void TRice8fn_3(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2);
+void TRice8fn_4(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3);
+void TRice8fn_5(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4);
+void TRice8fn_6(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5);
+void TRice8fn_7(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6);
+void TRice8fn_8(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7);
+void TRice8fn_9(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8);
+void TRice8fn_10(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9);
+void TRice8fn_11(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10);
+void TRice8fn_12(uint16_t tid, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10, uint8_t v11);
+
+void trice16fn_0(uint16_t tid);
+void trice16fn_1(uint16_t tid, uint16_t v0);
+void trice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1);
+void trice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2);
+void trice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3);
+void trice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4);
+void trice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5);
+void trice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6);
+void trice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7);
+void trice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8);
+void trice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9);
+void trice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10);
+void trice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11);
+
+void Trice16fn_0(uint16_t tid);
+void Trice16fn_1(uint16_t tid, uint16_t v0);
+void Trice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1);
+void Trice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2);
+void Trice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3);
+void Trice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4);
+void Trice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5);
+void Trice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6);
+void Trice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7);
+void Trice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8);
+void Trice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9);
+void Trice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10);
+void Trice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11);
+
+void TRice16fn_0(uint16_t tid);
+void TRice16fn_1(uint16_t tid, uint16_t v0);
+void TRice16fn_2(uint16_t tid, uint16_t v0, uint16_t v1);
+void TRice16fn_3(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2);
+void TRice16fn_4(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3);
+void TRice16fn_5(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4);
+void TRice16fn_6(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5);
+void TRice16fn_7(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6);
+void TRice16fn_8(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7);
+void TRice16fn_9(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8);
+void TRice16fn_10(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9);
+void TRice16fn_11(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10);
+void TRice16fn_12(uint16_t tid, uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4, uint16_t v5, uint16_t v6, uint16_t v7, uint16_t v8, uint16_t v9, uint16_t v10, uint16_t v11);
+
+void trice32fn_0(uint16_t tid);
+void trice32fn_1(uint16_t tid, uint32_t v0);
+void trice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1);
+void trice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2);
+void trice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3);
+void trice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4);
+void trice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5);
+void trice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6);
+void trice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7);
+void trice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8);
+void trice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9);
+void trice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10);
+void trice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11);
+
+void Trice32fn_0(uint16_t tid);
+void Trice32fn_1(uint16_t tid, uint32_t v0);
+void Trice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1);
+void Trice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2);
+void Trice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3);
+void Trice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4);
+void Trice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5);
+void Trice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6);
+void Trice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7);
+void Trice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8);
+void Trice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9);
+void Trice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10);
+void Trice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11);
+
+void TRice32fn_0(uint16_t tid);
+void TRice32fn_1(uint16_t tid, uint32_t v0);
+void TRice32fn_2(uint16_t tid, uint32_t v0, uint32_t v1);
+void TRice32fn_3(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2);
+void TRice32fn_4(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3);
+void TRice32fn_5(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4);
+void TRice32fn_6(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5);
+void TRice32fn_7(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6);
+void TRice32fn_8(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7);
+void TRice32fn_9(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8);
+void TRice32fn_10(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9);
+void TRice32fn_11(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10);
+void TRice32fn_12(uint16_t tid, uint32_t v0, uint32_t v1, uint32_t v2, uint32_t v3, uint32_t v4, uint32_t v5, uint32_t v6, uint32_t v7, uint32_t v8, uint32_t v9, uint32_t v10, uint32_t v11);
+
+void trice64fn_0(uint16_t tid);
+void trice64fn_1(uint16_t tid, uint64_t v0);
+void trice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1);
+void trice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2);
+void trice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3);
+void trice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4);
+void trice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5);
+void trice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6);
+void trice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7);
+void trice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8);
+void trice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9);
+void trice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10);
+void trice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11);
+
+void Trice64fn_0(uint16_t tid);
+void Trice64fn_1(uint16_t tid, uint64_t v0);
+void Trice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1);
+void Trice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2);
+void Trice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3);
+void Trice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4);
+void Trice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5);
+void Trice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6);
+void Trice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7);
+void Trice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8);
+void Trice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9);
+void Trice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10);
+void Trice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11);
+
+void TRice64fn_0(uint16_t tid);
+void TRice64fn_1(uint16_t tid, uint64_t v0);
+void TRice64fn_2(uint16_t tid, uint64_t v0, uint64_t v1);
+void TRice64fn_3(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2);
+void TRice64fn_4(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3);
+void TRice64fn_5(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4);
+void TRice64fn_6(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5);
+void TRice64fn_7(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6);
+void TRice64fn_8(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7);
+void TRice64fn_9(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8);
+void TRice64fn_10(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9);
+void TRice64fn_11(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10);
+void TRice64fn_12(uint16_t tid, uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4, uint64_t v5, uint64_t v6, uint64_t v7, uint64_t v8, uint64_t v9, uint64_t v10, uint64_t v11);
+
+#define trice8_0(tid, fmt) trice8fn_0(tid)                                                                                                                                                                                                                                           //!< trice8_0 is a macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_1(tid, fmt, v0) trice8fn_1(tid, (uint8_t)(v0))                                                                                                                                                                                                                        //!< trice8_1 is a macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_2(tid, fmt, v0, v1) trice8fn_2(tid, (uint8_t)(v0), (uint8_t)(v1))                                                                                                                                                                                                     //!< trice8_2 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_3(tid, fmt, v0, v1, v2) trice8fn_3(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2))                                                                                                                                                                                  //!< trice8_3 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_4(tid, fmt, v0, v1, v2, v3) trice8fn_4(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3))                                                                                                                                                               //!< trice8_4 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_5(tid, fmt, v0, v1, v2, v3, v4) trice8fn_5(tid, (uint8_t)v0, (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4))                                                                                                                                              //!< trice8_5 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_6(tid, fmt, v0, v1, v2, v3, v4, v5) trice8fn_6(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5))                                                                                                                         //!< trice8_6 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) trice8fn_7(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6))                                                                                                      //!< trice8_7 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) trice8fn_8(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7))                                                                                   //!< trice8_8 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) trice8fn_9(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8))                                                                //!< trice8_9 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) trice8fn_10(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9))                                           //!< trice8_10 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) trice8fn_11(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10))                      //!< trice8_1M ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define trice8_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) trice8fn_12(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10), (uint8_t)(v11)) //!< trice8_12 ia macro calling a function to reduce code size, this way avoiding code inlining.
+
+#define Trice8_0(tid, fmt) Trice8fn_0(tid)                                                                                                                                                                                                                                           //!< Trice8_1 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_1(tid, fmt, v0) Trice8fn_1(tid, (uint8_t)(v0))                                                                                                                                                                                                                        //!< Trice8_1 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_2(tid, fmt, v0, v1) Trice8fn_2(tid, (uint8_t)(v0), (uint8_t)(v1))                                                                                                                                                                                                     //!< Trice8_2 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_3(tid, fmt, v0, v1, v2) Trice8fn_3(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2))                                                                                                                                                                                  //!< Trice8_3 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_4(tid, fmt, v0, v1, v2, v3) Trice8fn_4(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3))                                                                                                                                                               //!< Trice8_4 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_5(tid, fmt, v0, v1, v2, v3, v4) Trice8fn_5(tid, (uint8_t)v0, (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4))                                                                                                                                              //!< Trice8_5 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_6(tid, fmt, v0, v1, v2, v3, v4, v5) Trice8fn_6(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5))                                                                                                                         //!< Trice8_6 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) Trice8fn_7(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6))                                                                                                      //!< Trice8_7 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) Trice8fn_8(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7))                                                                                   //!< Trice8_8 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) Trice8fn_9(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8))                                                                //!< Trice8_9 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) Trice8fn_10(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9))                                           //!< Trice8_10 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) Trice8fn_11(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10))                      //!< Trice8_11 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define Trice8_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) Trice8fn_12(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10), (uint8_t)(v11)) //!< Trice8_12 ia macro calling a function to reduce code size, this way avoiding code inlining.
+
+#define TRice8_0(tid, fmt) TRice8fn_0(tid)                                                                                                                                                                                                                                           //!< TRice8_0 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_1(tid, fmt, v0) TRice8fn_1(tid, (uint8_t)(v0))                                                                                                                                                                                                                        //!< TRice8_1 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_2(tid, fmt, v0, v1) TRice8fn_2(tid, (uint8_t)(v0), (uint8_t)(v1))                                                                                                                                                                                                     //!< TRice8_2 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_3(tid, fmt, v0, v1, v2) TRice8fn_3(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2))                                                                                                                                                                                  //!< TRice8_3 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_4(tid, fmt, v0, v1, v2, v3) TRice8fn_4(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3))                                                                                                                                                               //!< TRice8_4 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_5(tid, fmt, v0, v1, v2, v3, v4) TRice8fn_5(tid, (uint8_t)v0, (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4))                                                                                                                                              //!< TRice8_5 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_6(tid, fmt, v0, v1, v2, v3, v4, v5) TRice8fn_6(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5))                                                                                                                         //!< TRice8_6 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) TRice8fn_7(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6))                                                                                                      //!< TRice8_7 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) TRice8fn_8(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7))                                                                                   //!< TRice8_8 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) TRice8fn_9(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8))                                                                //!< TRice8_9 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) TRice8fn_10(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9))                                           //!< TRice8_10 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) TRice8fn_11(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10))                      //!< TRice8_11 ia macro calling a function to reduce code size, this way avoiding code inlining.
+#define TRice8_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) TRice8fn_12(tid, (uint8_t)(v0), (uint8_t)(v1), (uint8_t)(v2), (uint8_t)(v3), (uint8_t)(v4), (uint8_t)(v5), (uint8_t)(v6), (uint8_t)(v7), (uint8_t)(v8), (uint8_t)(v9), (uint8_t)(v10), (uint8_t)(v11)) //!< TRice8_12 ia macro calling a function to reduce code size, this way avoiding code inlining.
+
+#define trice16_0(tid, fmt) trice16fn_0(tid)                                                                                                                                                                                                                                                       //!< trice16_0 is a macro calling a function to reduce code size.
+#define trice16_1(tid, fmt, v0) trice16fn_1(tid, (uint16_t)(v0))                                                                                                                                                                                                                                   //!< trice16_1 is a macro calling a function to reduce code size.
+#define trice16_2(tid, fmt, v0, v1) trice16fn_2(tid, (uint16_t)(v0), (uint16_t)(v1))                                                                                                                                                                                                               //!< trice16_2 is a macro calling a function to reduce code size.
+#define trice16_3(tid, fmt, v0, v1, v2) trice16fn_3(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2))                                                                                                                                                                                           //!< trice16_3 is a macro calling a function to reduce code size.
+#define trice16_4(tid, fmt, v0, v1, v2, v3) trice16fn_4(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3))                                                                                                                                                                       //!< trice16_4 is a macro calling a function to reduce code size.
+#define trice16_5(tid, fmt, v0, v1, v2, v3, v4) trice16fn_5(tid, (uint16_t)v0, (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4))                                                                                                                                                     //!< trice16_5 is a macro calling a function to reduce code size.
+#define trice16_6(tid, fmt, v0, v1, v2, v3, v4, v5) trice16fn_6(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5))                                                                                                                               //!< trice16_6 is a macro calling a function to reduce code size.
+#define trice16_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) trice16fn_7(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6))                                                                                                           //!< trice16_7 is a macro calling a function to reduce code size.
+#define trice16_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) trice16fn_8(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7))                                                                                       //!< trice16_8 is a macro calling a function to reduce code size.
+#define trice16_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) trice16fn_9(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8))                                                                   //!< trice16_9 is a macro calling a function to reduce code size.
+#define trice16_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) trice16fn_10(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9))                                             //!< trice16_10 is a macro calling a function to reduce code size.
+#define trice16_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) trice16fn_11(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10))                       //!< trice16_11 is a macro calling a function to reduce code size.
+#define trice16_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) trice16fn_12(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10), (uint16_t)(v11)) //!< trice16_12 is a macro calling a function to reduce code size.
+
+#define Trice16_0(tid, fmt) Trice16fn_0(tid)                                                                                                                                                                                                                                                       //!< Trice16_0 is a macro calling a function to reduce code size.
+#define Trice16_1(tid, fmt, v0) Trice16fn_1(tid, (uint16_t)(v0))                                                                                                                                                                                                                                   //!< Trice16_1 is a macro calling a function to reduce code size.
+#define Trice16_2(tid, fmt, v0, v1) Trice16fn_2(tid, (uint16_t)(v0), (uint16_t)(v1))                                                                                                                                                                                                               //!< Trice16_2 is a macro calling a function to reduce code size.
+#define Trice16_3(tid, fmt, v0, v1, v2) Trice16fn_3(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2))                                                                                                                                                                                           //!< Trice16_3 is a macro calling a function to reduce code size.
+#define Trice16_4(tid, fmt, v0, v1, v2, v3) Trice16fn_4(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3))                                                                                                                                                                       //!< Trice16_4 is a macro calling a function to reduce code size.
+#define Trice16_5(tid, fmt, v0, v1, v2, v3, v4) Trice16fn_5(tid, (uint16_t)v0, (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4))                                                                                                                                                     //!< Trice16_5 is a macro calling a function to reduce code size.
+#define Trice16_6(tid, fmt, v0, v1, v2, v3, v4, v5) Trice16fn_6(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5))                                                                                                                               //!< Trice16_6 is a macro calling a function to reduce code size.
+#define Trice16_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) Trice16fn_7(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6))                                                                                                           //!< Trice16_7 is a macro calling a function to reduce code size.
+#define Trice16_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) Trice16fn_8(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7))                                                                                       //!< Trice16_8 is a macro calling a function to reduce code size.
+#define Trice16_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) Trice16fn_9(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8))                                                                   //!< Trice16_9 is a macro calling a function to reduce code size.
+#define Trice16_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) Trice16fn_10(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9))                                             //!< Trice16_10 is a macro calling a function to reduce code size.
+#define Trice16_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) Trice16fn_11(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10))                       //!< Trice16_11 is a macro calling a function to reduce code size.
+#define Trice16_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) Trice16fn_12(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10), (uint16_t)(v11)) //!< Trice16_12 is a macro calling a function to reduce code size.
+
+#define TRice16_0(tid, fmt) TRice16fn_0(tid)                                                                                                                                                                                                                                                       //!< TRice16_0 is a macro calling a function to reduce code size.
+#define TRice16_1(tid, fmt, v0) TRice16fn_1(tid, (uint16_t)(v0))                                                                                                                                                                                                                                   //!< TRice16_1 is a macro calling a function to reduce code size.
+#define TRice16_2(tid, fmt, v0, v1) TRice16fn_2(tid, (uint16_t)(v0), (uint16_t)(v1))                                                                                                                                                                                                               //!< TRice16_2 is a macro calling a function to reduce code size.
+#define TRice16_3(tid, fmt, v0, v1, v2) TRice16fn_3(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2))                                                                                                                                                                                           //!< TRice16_3 is a macro calling a function to reduce code size.
+#define TRice16_4(tid, fmt, v0, v1, v2, v3) TRice16fn_4(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3))                                                                                                                                                                       //!< TRice16_4 is a macro calling a function to reduce code size.
+#define TRice16_5(tid, fmt, v0, v1, v2, v3, v4) TRice16fn_5(tid, (uint16_t)v0, (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4))                                                                                                                                                     //!< TRice16_5 is a macro calling a function to reduce code size.
+#define TRice16_6(tid, fmt, v0, v1, v2, v3, v4, v5) TRice16fn_6(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5))                                                                                                                               //!< TRice16_6 is a macro calling a function to reduce code size.
+#define TRice16_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) TRice16fn_7(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6))                                                                                                           //!< TRice16_7 is a macro calling a function to reduce code size.
+#define TRice16_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) TRice16fn_8(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7))                                                                                       //!< TRice16_16_M is a macro calling a function to reduce code size.
+#define TRice16_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) TRice16fn_9(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8))                                                                   //!< TRice16_9 is a macro calling a function to reduce code size.
+#define TRice16_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) TRice16fn_10(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9))                                             //!< TRice16_10 is a macro calling a function to reduce code size.
+#define TRice16_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) TRice16fn_11(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10))                       //!< TRice16_11 is a macro calling a function to reduce code size.
+#define TRice16_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) TRice16fn_12(tid, (uint16_t)(v0), (uint16_t)(v1), (uint16_t)(v2), (uint16_t)(v3), (uint16_t)(v4), (uint16_t)(v5), (uint16_t)(v6), (uint16_t)(v7), (uint16_t)(v8), (uint16_t)(v9), (uint16_t)(v10), (uint16_t)(v11)) //!< TRice16_12 is a macro calling a function to reduce code size.
+
+#define trice32_0(tid, fmt) trice32fn_0(tid)                                                                                                                                                                                                                                                       //!< trice32_0 is a macro calling a function to reduce code size.
+#define trice32_1(tid, fmt, v0) trice32fn_1(tid, (uint32_t)(v0))                                                                                                                                                                                                                                   //!< trice32_1 is a macro calling a function to reduce code size.
+#define trice32_2(tid, fmt, v0, v1) trice32fn_2(tid, (uint32_t)(v0), (uint32_t)(v1))                                                                                                                                                                                                               //!< trice32_2 is a macro calling a function to reduce code size.
+#define trice32_3(tid, fmt, v0, v1, v2) trice32fn_3(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2))                                                                                                                                                                                           //!< trice32_3 is a macro calling a function to reduce code size.
+#define trice32_4(tid, fmt, v0, v1, v2, v3) trice32fn_4(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3))                                                                                                                                                                       //!< trice32_4 is a macro calling a function to r  educe code size.
+#define trice32_5(tid, fmt, v0, v1, v2, v3, v4) trice32fn_5(tid, (uint32_t)v0, (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4))                                                                                                                                                     //!< trice32_5 is a macro calling a function to reduce code size.
+#define trice32_6(tid, fmt, v0, v1, v2, v3, v4, v5) trice32fn_6(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5))                                                                                                                               //!< trice32_6 is a macro calling a function to reduce code size.
+#define trice32_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) trice32fn_7(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6))                                                                                                           //!< trice32_7 is a macro calling a function to reduce code size.
+#define trice32_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) trice32fn_8(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7))                                                                                       //!< trice32_8 is a macro calling a function to reduce code size.
+#define trice32_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) trice32fn_9(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8))                                                                   //!< trice32_9 is a macro calling a function to reduce code size.
+#define trice32_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) trice32fn_10(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9))                                             //!< trice32_10 is a macro calling a function to reduce code size.
+#define trice32_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) trice32fn_11(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10))                       //!< trice32_11 is a macro calling a function to reduce code size.
+#define trice32_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) trice32fn_12(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10), (uint32_t)(v11)) //!< trice32_12 is a macro calling a function to reduce code size.
+
+#define Trice32_0(tid, fmt) Trice32fn_0(tid)                                                                                                                                                                                                                                                       //!< Trice32_0 is a macro calling a function to reduce code size.
+#define Trice32_1(tid, fmt, v0) Trice32fn_1(tid, (uint32_t)(v0))                                                                                                                                                                                                                                   //!< Trice32_1 is a macro calling a function to reduce code size.
+#define Trice32_2(tid, fmt, v0, v1) Trice32fn_2(tid, (uint32_t)(v0), (uint32_t)(v1))                                                                                                                                                                                                               //!< Trice32_2 is a macro calling a function to reduce code size.
+#define Trice32_3(tid, fmt, v0, v1, v2) Trice32fn_3(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2))                                                                                                                                                                                           //!< Trice32_3 is a macro calling a function to reduce code size.
+#define Trice32_4(tid, fmt, v0, v1, v2, v3) Trice32fn_4(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3))                                                                                                                                                                       //!< Trice32_4 is a macro calling a function to reduce code size.
+#define Trice32_5(tid, fmt, v0, v1, v2, v3, v4) Trice32fn_5(tid, (uint32_t)v0, (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4))                                                                                                                                                     //!< Trice32_5 is a macro calling a function to reduce code size.
+#define Trice32_6(tid, fmt, v0, v1, v2, v3, v4, v5) Trice32fn_6(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5))                                                                                                                               //!< Trice32_6 is a macro calling a function to reduce code size.
+#define Trice32_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) Trice32fn_7(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6))                                                                                                           //!< Trice32_7 is a macro calling a function to reduce code size.
+#define Trice32_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) Trice32fn_8(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7))                                                                                       //!< Trice32_8 is a macro calling a function to reduce code size.
+#define Trice32_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) Trice32fn_9(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8))                                                                   //!< Trice32_9 is a macro calling a function to reduce code size.
+#define Trice32_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) Trice32fn_10(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9))                                             //!< Trice32_10 is a macro calling a function to reduce code size.
+#define Trice32_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) Trice32fn_11(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10))                       //!< Trice32_11 is a macro calling a function to reduce code size.
+#define Trice32_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) Trice32fn_12(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10), (uint32_t)(v11)) //!< Trice32_12 is a macro calling a function to reduce code size.
+
+#define TRice32_0(tid, fmt) TRice32fn_0(tid)                                                                                                                                                                                                                                                       //!< TRice32_1 is a macro calling a function to reduce code size.
+#define TRice32_1(tid, fmt, v0) TRice32fn_1(tid, (uint32_t)(v0))                                                                                                                                                                                                                                   //!< TRice32_1 is a macro calling a function to reduce code size.
+#define TRice32_2(tid, fmt, v0, v1) TRice32fn_2(tid, (uint32_t)(v0), (uint32_t)(v1))                                                                                                                                                                                                               //!< TRice32_2 is a macro calling a function to reduce code size.
+#define TRice32_3(tid, fmt, v0, v1, v2) TRice32fn_3(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2))                                                                                                                                                                                           //!< TRice32_3 is a macro calling a function to reduce code size.
+#define TRice32_4(tid, fmt, v0, v1, v2, v3) TRice32fn_4(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3))                                                                                                                                                                       //!< TRice32_4 is a macro calling a function to reduce code size.
+#define TRice32_5(tid, fmt, v0, v1, v2, v3, v4) TRice32fn_5(tid, (uint32_t)v0, (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4))                                                                                                                                                     //!< TRice32_5 is a macro calling a function to reduce code size.
+#define TRice32_6(tid, fmt, v0, v1, v2, v3, v4, v5) TRice32fn_6(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5))                                                                                                                               //!< TRice32_6 is a macro calling a function to reduce code size.
+#define TRice32_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) TRice32fn_7(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6))                                                                                                           //!< TRice32_7 is a macro calling a function to reduce code size.
+#define TRice32_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) TRice32fn_8(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7))                                                                                       //!< TRice32_32_M is a macro calling a function to reduce code size.
+#define TRice32_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) TRice32fn_9(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8))                                                                   //!< TRice32_9 is a macro calling a function to reduce code size.
+#define TRice32_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) TRice32fn_10(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9))                                             //!< TRice32_10 is a macro calling a function to reduce code size.
+#define TRice32_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) TRice32fn_11(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10))                       //!< TRice32_11 is a macro calling a function to reduce code size.
+#define TRice32_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) TRice32fn_12(tid, (uint32_t)(v0), (uint32_t)(v1), (uint32_t)(v2), (uint32_t)(v3), (uint32_t)(v4), (uint32_t)(v5), (uint32_t)(v6), (uint32_t)(v7), (uint32_t)(v8), (uint32_t)(v9), (uint32_t)(v10), (uint32_t)(v11)) //!< TRice32_12 is a macro calling a function to reduce code size.
+
+#define trice64_0(tid, fmt) trice64fn_0(tid)                                                                                                                                                                                                                                                       //!< trice64_1 is a macro calling a function to reduce code size.
+#define trice64_1(tid, fmt, v0) trice64fn_1(tid, (uint64_t)(v0))                                                                                                                                                                                                                                   //!< trice64_1 is a macro calling a function to reduce code size.
+#define trice64_2(tid, fmt, v0, v1) trice64fn_2(tid, (uint64_t)(v0), (uint64_t)(v1))                                                                                                                                                                                                               //!< trice64_2 is a macro calling a function to reduce code size.
+#define trice64_3(tid, fmt, v0, v1, v2) trice64fn_3(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2))                                                                                                                                                                                           //!< trice64_3 is a macro calling a function to reduce code size.
+#define trice64_4(tid, fmt, v0, v1, v2, v3) trice64fn_4(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3))                                                                                                                                                                       //!< trice64_4 is a macro calling a function to reduce code size.
+#define trice64_5(tid, fmt, v0, v1, v2, v3, v4) trice64fn_5(tid, (uint64_t)v0, (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4))                                                                                                                                                     //!< trice64_5 is a macro calling a function to reduce code size.
+#define trice64_6(tid, fmt, v0, v1, v2, v3, v4, v5) trice64fn_6(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5))                                                                                                                               //!< trice64_6 is a macro calling a function to reduce code size.
+#define trice64_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) trice64fn_7(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6))                                                                                                           //!< trice64_7 is a macro calling a function to reduce code size.
+#define trice64_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) trice64fn_8(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7))                                                                                       //!< trice64_8 is a macro calling a function to reduce code size.
+#define trice64_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) trice64fn_9(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8))                                                                   //!< trice64_9 is a macro calling a function to reduce code size.
+#define trice64_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) trice64fn_10(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9))                                             //!< trice64_10 is a macro calling a function to reduce code size.
+#define trice64_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) trice64fn_11(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10))                       //!< trice64_11 is a macro calling a function to reduce code size.
+#define trice64_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) trice64fn_12(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10), (uint64_t)(v11)) //!< trice64_12 is a macro calling a function to reduce code size.
+
+#define Trice64_0(tid, fmt) Trice64fn_0(tid)                                                                                                                                                                                                                                                       //!< Trice64_0 is a macro calling a function to reduce code size.
+#define Trice64_1(tid, fmt, v0) Trice64fn_1(tid, (uint64_t)(v0))                                                                                                                                                                                                                                   //!< Trice64_1 is a macro calling a function to reduce code size.
+#define Trice64_2(tid, fmt, v0, v1) Trice64fn_2(tid, (uint64_t)(v0), (uint64_t)(v1))                                                                                                                                                                                                               //!< Trice64_2 is a macro calling a function to reduce code size.
+#define Trice64_3(tid, fmt, v0, v1, v2) Trice64fn_3(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2))                                                                                                                                                                                           //!< Trice64_3 is a macro calling a function to reduce code size.
+#define Trice64_4(tid, fmt, v0, v1, v2, v3) Trice64fn_4(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3))                                                                                                                                                                       //!< Trice64_4 is a macro calling a function to reduce code size.
+#define Trice64_5(tid, fmt, v0, v1, v2, v3, v4) Trice64fn_5(tid, (uint64_t)v0, (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4))                                                                                                                                                     //!< Trice64_5 is a macro calling a function to reduce code size.
+#define Trice64_6(tid, fmt, v0, v1, v2, v3, v4, v5) Trice64fn_6(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5))                                                                                                                               //!< Trice64_6 is a macro calling a function to reduce code size.
+#define Trice64_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) Trice64fn_7(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6))                                                                                                           //!< Trice64_7 is a macro calling a function to reduce code size.
+#define Trice64_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) Trice64fn_8(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7))                                                                                       //!< Trice64_8 is a macro calling a function to reduce code size.
+#define Trice64_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) Trice64fn_9(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8))                                                                   //!< Trice64_9 is a macro calling a function to reduce code size.
+#define Trice64_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) Trice64fn_10(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9))                                             //!< Trice64_10 is a macro calling a function to reduce code size.
+#define Trice64_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) Trice64fn_11(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10))                       //!< Trice64_11 is a macro calling a function to reduce code size.
+#define Trice64_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) Trice64fn_12(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10), (uint64_t)(v11)) //!< Trice64_12 is a macro calling a function to reduce code size.
+
+#define TRice64_0(tid, fmt) TRice64fn_0(tid)                                                                                                                                                                                                                                                       //!< TRice64_0 is a macro calling a function to reduce code size.
+#define TRice64_1(tid, fmt, v0) TRice64fn_1(tid, (uint64_t)(v0))                                                                                                                                                                                                                                   //!< TRice64_1 is a macro calling a function to reduce code size.
+#define TRice64_2(tid, fmt, v0, v1) TRice64fn_2(tid, (uint64_t)(v0), (uint64_t)(v1))                                                                                                                                                                                                               //!< TRice64_2 is a macro calling a function to reduce code size.
+#define TRice64_3(tid, fmt, v0, v1, v2) TRice64fn_3(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2))                                                                                                                                                                                           //!< TRice64_3 is a macro calling a function to reduce code size.
+#define TRice64_4(tid, fmt, v0, v1, v2, v3) TRice64fn_4(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3))                                                                                                                                                                       //!< TRice64_4 is a macro calling a function to reduce code size.
+#define TRice64_5(tid, fmt, v0, v1, v2, v3, v4) TRice64fn_5(tid, (uint64_t)v0, (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4))                                                                                                                                                     //!< TRice64_5 is a macro calling a function to reduce code size.
+#define TRice64_6(tid, fmt, v0, v1, v2, v3, v4, v5) TRice64fn_6(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5))                                                                                                                               //!< TRice64_6 is a macro calling a function to reduce code size.
+#define TRice64_7(tid, fmt, v0, v1, v2, v3, v4, v5, v6) TRice64fn_7(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6))                                                                                                           //!< TRice64_7 is a macro calling a function to reduce code size.
+#define TRice64_8(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7) TRice64fn_8(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7))                                                                                       //!< TRice64_64_M is a macro calling a function to reduce code size.
+#define TRice64_9(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8) TRice64fn_9(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8))                                                                   //!< TRice64_9 is a macro calling a function to reduce code size.
+#define TRice64_10(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) TRice64fn_10(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9))                                             //!< TRice64_10 is a macro calling a function to reduce code size.
+#define TRice64_11(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) TRice64fn_11(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10))                       //!< TRice64_11 is a macro calling a function to reduce code size.
+#define TRice64_12(tid, fmt, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) TRice64fn_12(tid, (uint64_t)(v0), (uint64_t)(v1), (uint64_t)(v2), (uint64_t)(v3), (uint64_t)(v4), (uint64_t)(v5), (uint64_t)(v6), (uint64_t)(v7), (uint64_t)(v8), (uint64_t)(v9), (uint64_t)(v10), (uint64_t)(v11)) //!< TRice64_12 is a macro calling a function to reduce code size.

Middlewares/trice/triceRingBuffer.c

@@ -0,0 +1,503 @@
+//! \file triceRingBuffer.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//!     //////////////////////////////////////////////////////////////////////////
+#include "cobs.h"
+#include "tcobs.h"
+#include "trice.h"
+
+#if TRICE_BUFFER == TRICE_RING_BUFFER && TRICE_OFF == 0
+
+    #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+static void triceSingleDeferredOut(int *wordCount);
+    #else
+static void triceMultiDeferredOut(int *triceCount, int *wordCount);
+    #endif
+
+    #if TRICE_RING_BUFFER_OVERFLOW_WATCH == 1
+
+        #define TRICE_RING_BUFFER_LOWER_MARGIN 8 //!< 32-bit units just for debugging > 0
+        #define TRICE_RING_BUFFER_UPPER_MARGIN 8 //!< 32-bit units just for debugging > 0
+        #define TRICE_RING_BUFFER_MARGIN_FILL_VALUE 0xfee4deb
+
+    #else
+
+        #define TRICE_RING_BUFFER_LOWER_MARGIN 0 //!< 32-bit units just for debugging > 0
+        #define TRICE_RING_BUFFER_UPPER_MARGIN 0 //!< 32-bit units just for debugging > 0
+        #define TRICE_RING_BUFFER_FILL_VALUE 0
+
+    #endif
+
+//! triceRingBuffer is a kind of heap for trice messages. It needs to be initialized with 0.
+//! Initial:
+//! |<-LM->|<----------------  triceRingBuffer  ------------------------------------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<---------------- TRICE_RING_BUFFER_SIZE -------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<--        writable        -->|<-- TRICE_RING_BUFFER_MIN_SPACE32 -->|<-UM->|
+//!                                |                              |                                     ^--------- TriceRingBufferLimit
+//!                                |                              ^----------------------------------------------- TriceRingBufferProtectLimit
+//!                                ^------------------------------------------------------------------------------ TriceBufferWritePosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferReadPosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferStart
+//!
+//! After some writes:
+//! |<-LM->|<----------------  triceRingBuffer  ------------------------------------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<---------------- TRICE_RING_BUFFER_SIZE -------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<-T->|<-T->|<--  writable  -->|<-- TRICE_RING_BUFFER_MIN_SPACE32 -->|<-UM->|
+//!                                |           |                  |                                     ^--------- TriceRingBufferLimit
+//!                                |           |                  ^----------------------------------------------- TriceRingBufferProtectLimit
+//!                                |           ^------------------------------------------------------------------ TriceBufferWritePosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferReadPosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferStart
+//!
+//! After some reads:
+//! |<-LM->|<----------------  triceRingBuffer  ------------------------------------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<---------------- TRICE_RING_BUFFER_SIZE -------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<writable->|<--  writable  -->|<-- TRICE_RING_BUFFER_MIN_SPACE32 -->|<-UM->|
+//!                                |           |                  |                                     ^--------- TriceRingBufferLimit
+//!                                |           |                  ^----------------------------------------------- TriceRingBufferProtectLimit
+//!                                |           ^------------------------------------------------------------------ TriceBufferWritePosition
+//!                                |           ^-------------------------------------------------------------------TriceRingBufferReadPosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferStart
+//!
+//! After some time:
+//! |<-LM->|<----------------  triceRingBuffer  ------------------------------------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<---------------- TRICE_RING_BUFFER_SIZE -------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|                              |<-- TRICE_RING_BUFFER_MIN_SPACE32 -->|<-UM->|
+//!                                |                              |                                     ^--------- TriceRingBufferLimit
+//!                                |                              ^----------------------------------------------- TriceRingBufferProtectLimit
+//!                                |<-- writable -->|<-T->|<-T->|<-T->|<-------- not writable --------->|<-UM->|
+//!                                |                |                 ^------------------------------------------- TriceBufferWritePosition, no more TRICE_RING_BUFFER_MIN_SPACE32!
+//!                                |                ^------------------------------------------------------------- TriceRingBufferReadPosition
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferStart
+//! With next Trice, TriceBufferWritePosition has to wrap firstly:
+//! |<-LM->|<----------------  triceRingBuffer  ------------------------------------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|<---------------- TRICE_RING_BUFFER_SIZE -------------------------->|<-UM->|
+//! |<-LM->|<--TRICE_DATA_OFFSET-->|                              |<-- TRICE_RING_BUFFER_MIN_SPACE32 -->|<-UM->|
+//!                                |                              |                                     ^--------- TriceRingBufferLimit
+//!                                |                              ^----------------------------------------------- TriceRingBufferProtectLimit
+//!                                |<-- writable -->|<-T->|<-T->|<-T->|<-------- not writable --------->|<-UM->|   When depth32(==writable) < TRICE_RING_BUFFER_MIN_SPACE32, no write is possible.
+//!                                |                ^------------------------------------------------------------- TriceRingBufferReadPosition
+//!                                ^------------------------------------------------------------------------------ TriceBufferWritePosition (wrapped)
+//!                                ^------------------------------------------------------------------------------ TriceRingBufferStart
+uint32_t triceRingBuffer[TRICE_RING_BUFFER_LOWER_MARGIN +(TRICE_DATA_OFFSET >> 2)+(TRICE_RING_BUFFER_SIZE >> 2)+ TRICE_RING_BUFFER_UPPER_MARGIN] = {0};
+
+//! TRICE_RING_BUFFER_MIN_SPACE32 is the needed space before a new Trice is allowed to be written.
+//! The TRICE_DATA_OFFSET guaranties, that in front of TriceRingBufferReadPosition is always a scratch pad.
+    #define TRICE_RING_BUFFER_MIN_SPACE32 ((TRICE_SINGLE_MAX_SIZE + TRICE_DATA_OFFSET) >> 2)
+
+//! TRICE_RING_BUFFER_START is a helper definition to avoid warning "expression must have a constant value".
+    #define TRICE_RING_BUFFER_START (triceRingBuffer + TRICE_RING_BUFFER_LOWER_MARGIN + (TRICE_DATA_OFFSET >> 2))
+
+//! TriceRingBufferStart is an immutable pointer to the begin of the triceRingBuffer area.
+uint32_t *const TriceRingBufferStart = TRICE_RING_BUFFER_START;
+
+//! triceBufferWriteLimit is the first address behind triceRingBuffer area and immutable.
+//! With encryption it can happen that 4 bytes following TriceRingBufferLimit are used as scratch pad.
+//! We use the value of TRICE_DEFERRED_XTEA_ENCRYPT (0 or 1) here to respect that
+//! See also comment inside triceSingleDeferredOut.
+uint32_t *const TriceRingBufferLimit = TRICE_RING_BUFFER_START + (TRICE_RING_BUFFER_SIZE >> 2);
+
+//! TricesCountRingBuffer holds the readable trices count inside triceRingBuffer.
+unsigned TricesCountRingBuffer = 0;
+
+//! TriceBufferWritePosition is used by the TRICE_PUT macros.
+uint32_t *TriceBufferWritePosition = TRICE_RING_BUFFER_START;
+
+//! TriceRingBufferProtectLimit is the first address not allowed to be written to in any circumstances.
+//! If TriceBufferWritePosition >= TriceRingBufferProtectLimit, TriceBufferWritePosition needs to wrap.
+uint32_t *const TriceRingBufferProtectLimit = TRICE_RING_BUFFER_START + (TRICE_RING_BUFFER_SIZE >> 2) - TRICE_RING_BUFFER_MIN_SPACE32;
+
+//! TriceRingBufferReadPosition points to a valid trice message when singleTricesRingCount > 0.
+//! This is first the TRICE_DATA_OFFSET byte space followed by the trice data.
+//! Initially this value is set to TriceRingBufferStart minus TRICE_DATA_OFFSET byte space
+//! to get a correct value for the very first call of triceNextRingBufferRead
+//! uint32_t* TriceRingBufferReadPosition = TriceRingBufferStart - (TRICE_DATA_OFFSET>>2); //lint !e428 Warning 428: negative subscript (-4) in operator 'ptr-int'
+uint32_t *TriceRingBufferReadPosition = TRICE_RING_BUFFER_START;
+
+    #if TRICE_DIAGNOSTICS == 1
+
+//! TricesCountRingBufferMax holds the max count of trices occurred inside the ring buffer.
+//! This value is only informal, because the length of the trice messages is not known.
+//! unsigned TricesCountRingBufferMax = 0;
+
+//! TriceRingBufferDepthMax holds the max occurred ring buffer depth.
+int TriceRingBufferDepthMax = 0;
+
+    #endif // #if TRICE_DIAGNOSTICS == 1
+
+    #if TRICE_PROTECT == 1
+
+//! TriceEnoughSpace checks, if enough bytes available for the next trice.
+//! \retval 0, when not enough space
+//! \retval 1, when enough space
+int TriceEnoughSpace(void)
+{
+    // depth32 is the used buffer space in 32-bit words. After reset TriceBufferWritePosition and TriceRingBufferReadPosition are equal and depth32 is 0.
+    // After some trice data writing, TriceBufferWritePosition is > TriceRingBufferReadPosition and depth32 has a positive value.
+    // When trice data read out takes place, the TriceRingBufferReadPosition is incremented. That makes the depth32 value smaller again and gives write space.
+    // Before a new trice write operation, TriceBufferWritePosition is reset to TriceRingBufferStart if less than TRICE_SINGLE_MAX_SIZE bytes left to the TriceRingBufferLimit.
+    // So, even there is a only 4 bytes Trice, it cannot be written, when no full TRICE_SINGLE_MAX_SIZE space is left, because we do not know its size in advance.
+    // The TriceRingBufferReadPosition jumps in the same way as the TriceBufferWritePosition. It wraps according the same rules.
+
+    int depth32 = TriceBufferWritePosition - TriceRingBufferReadPosition;
+    if (depth32 == 0 && TricesCountRingBuffer > 0)
+    {
+        goto noSpace;
+    }
+    if (depth32 < 0)   // After a TriceBufferWritePosition reset the difference is negative and needs correction to get the correct value.
+    {
+        depth32 += (TRICE_RING_BUFFER_SIZE >> 2);
+    }
+    // This fn is called before an intended trice data write ande therefore additional at least TRICE_SINGLE_MAX_SIZE>>2 32-bit words need to fit in the buffer.
+    // There must be left TRICE_DATA_OFFSET space behind the last Trice to be usable as scratch pad in front of TriceRingBufferReadPosition.
+    if (depth32 <= (TRICE_RING_BUFFER_SIZE >> 2) - TRICE_RING_BUFFER_MIN_SPACE32)
+    {
+        return 1;
+    }
+    else
+    {
+    noSpace:
+#if TRICE_DIAGNOSTICS == 1
+        TriceDeferredOverflowCount++;
+#endif
+        return 0;
+    }
+}
+
+    #endif // #if TRICE_PROTECT == 1
+
+// triceIncrementRingBufferReadPosition sets TriceRingBufferReadPosition forward by wordCount.
+//! \param lastWordCount is the u32 count of the last read trice including padding bytes.
+TRICE_INLINE void triceIncrementRingBufferReadPosition(int wordCount)
+{
+    TriceRingBufferReadPosition += wordCount;
+    if (TriceRingBufferReadPosition > TriceRingBufferProtectLimit)
+    {
+        TriceRingBufferReadPosition = TriceRingBufferStart;
+    }
+}
+
+// triceRingBufferDiagnostics computes and tracks TriceRingBufferDepthMax
+TRICE_INLINE void triceRingBufferDiagnostics(void)
+{
+#if TRICE_DIAGNOSTICS == 1
+    int depth = (TriceBufferWritePosition - TriceRingBufferReadPosition) << 2; // lint !e845 Info 845: The left argument to operator '<<' is certain to be 0
+    if (depth < 0)
+    {
+        depth += TRICE_DEFERRED_BUFFER_SIZE;
+    }
+    TriceRingBufferDepthMax = (depth > TriceRingBufferDepthMax) ? depth : TriceRingBufferDepthMax;
+#endif // #if TRICE_DIAGNOSTICS == 1
+}
+
+    #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+
+//! triceTransferSingleFraming transfers a single Trice from the Ring Buffer.
+//! Implicit assumed is, that the pre-condition "TricesCountRingBuffer > 0" is fulfilled.
+void triceTransferSingleFraming(void)
+{
+    triceRingBufferDiagnostics(); // We need to measure before the RingBufferReadPosition increment.
+
+    static int lastWordCount = 0; // lastWordCount is needed to increment TriceRingBufferReadPosition accordingly after transfer is done.
+    triceIncrementRingBufferReadPosition(lastWordCount);
+    lastWordCount = 0;
+
+    if (TricesCountRingBuffer == 0)   // no data
+    {
+        return;
+    }
+    TRICE_ENTER_CRITICAL_SECTION
+        TricesCountRingBuffer--; // We decrement, even the Trice is not out yet.
+    TRICE_LEAVE_CRITICAL_SECTION
+
+        // The trice data are starting at byte offset TRICE_DATA_OFFSET from TriceRingBufferReadPosition.
+        triceSingleDeferredOut(&lastWordCount);
+}
+
+    #endif // #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+
+    #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+
+//! triceTransferMultiFraming transfers several, but not necessarily all, Trices from the Ring Buffer.
+void triceTransferMultiFraming(void)
+{
+    triceRingBufferDiagnostics(); // We need to measure before the RingBufferReadPosition increment.
+
+    // The Ring Buffer can contain a fair amount of trices and we do not want them copy in a separate buffer for less RAM usage.
+    // Therefore we pack all Trices until the Ring Buffer end (where it wraps) together.
+    // We know here, that at least one Trice is inside the Ring Buffer.
+    static int triceCount = 0; // triceCount it the count of Trices from the last call.
+    TRICE_ENTER_CRITICAL_SECTION
+        // It is known here, that the previous transmission is finished and we can advance.
+        TricesCountRingBuffer -= triceCount;
+    TRICE_LEAVE_CRITICAL_SECTION
+        triceCount = 0;
+
+    static int multiWordCount = 0;                        // wordCount is the Ring Buffer space which is now free after the last transfer is finished.
+    triceIncrementRingBufferReadPosition(multiWordCount); // We can safely increment here, because we know, that the last transmission is done.
+    multiWordCount = 0;
+
+    triceMultiDeferredOut(&triceCount, &multiWordCount);
+    return;
+}
+
+    #endif // #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+
+//! TriceTransfer needs to be called cyclically to read out the Ring Buffer.
+void TriceTransfer(void)
+{
+#if TRICE_CGO == 0             // In automated tests we assume last transmission is finished, so we do not test depth to be able to test multiple Trices in deferred mode.
+    if (TriceOutDepth() > 0)   // Last transmission not finished. todo: Write TriceOutDepth() as dummy for TRICE_CGO.
+    {
+        return;
+    }
+#endif
+#if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+    triceTransferSingleFraming();
+#else
+    triceTransferMultiFraming();
+#endif
+}
+
+//! TriceIDAndBuffer evaluates a trice message and returns the ID for routing.
+//! \param pData is where the trice message starts.
+//! \param pWordCount is filled with the word count the trice data occupy from pData.
+//! \param ppTriceNetStart is filled with the trice net data start. That is maybe a 2 bytes offset from pData.
+//! \param pTriceNetLength is filled with the net trice length (without padding bytes), 0 on error.
+//! \retval is the triceID, a positive value on success or error information.
+static int TriceIDAndBuffer(const uint32_t *const pData, int *pWordCount, uint8_t **ppTriceNetStart, size_t *pTriceNetLength)
+{
+    uint16_t TID = TRICE_TTOHS(*(uint16_t *)pData); // type and id
+    int triceID = 0x3FFF & TID;
+    int triceType = TID >> 14; // 2 bits
+    unsigned offset;
+    size_t len;
+    uint8_t *pStart = (uint8_t *)pData;
+    switch (triceType)
+    {
+    case TRICE_TYPE_S0: // S0 = no stamp
+        offset = 0;
+        len = 4 + triceDataLen(pStart + 2); // tyId
+        break;
+    case TRICE_TYPE_S2:                     // S2 = 16-bit stamp
+        len = 6 + triceDataLen(pStart + 6); // tyId ts16
+        offset = 2;
+#if TRICE_DEFERRED_XTEA_ENCRYPT
+        // move trice to start at a uint32_t alignment border
+        memmove(pStart, pStart + 2, len); // https://stackoverflow.com/questions/1201319/what-is-the-difference-between-memmove-and-memcpy
+#else                                     // #if TRICE_DEFERRED_XTEA_ENCRYPT
+        // Like for UART transfer no uint32_t alignment is needed.
+        pStart += 2; // see Id(n) macro definition
+#endif                                    // #else // #if TRICE_DEFERRED_XTEA_ENCRYPT
+        break;
+    case TRICE_TYPE_S4: // S4 = 32-bit stamp
+        offset = 0;
+        len = 8 + triceDataLen(pStart + 6); // tyId ts32
+        break;
+    default: // impossible case (triceType has only 2 bits)
+             // fall thru
+    case TRICE_TYPE_X0:
+        TriceErrorCount++;
+        *ppTriceNetStart = pStart;
+        *pTriceNetLength = 0;
+        return -__LINE__; // extended trices not supported (yet)
+    }
+    // S16 case example:            triceSize  len   t-0-3   t-o
+    // 80id 80id 1616 00cc                8     6      3      6
+    // 80id 80id 1616 01cc dd            12     7      7     10
+    // 80id 80id 1616 02cc dd dd         12     8      7     10
+    // 80id 80id 1616 03cc dd dd dd      12     9      7     10
+    // 80id 80id 1616 04cc dd dd dd dd   12    10      7     10
+    *pWordCount = (len + offset + 3) >> 2;
+    *ppTriceNetStart = pStart;
+    *pTriceNetLength = len;
+    return triceID;
+}
+
+    #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+
+//! triceSingleDeferredOut expects a single trice at TriceRingBufferReadPosition and returns the wordCount of this trice which includes 1-3 padding bytes.
+//! The space from TriceRingBufferReadPosition-TRICE_DATA_OFFSET to TriceRingBufferReadPosition is assumed to be usable as scratch pad.
+//! This function is specific to the ring buffer, because the wordCount value needs to be reconstructed.
+//! \retval The returned value tells how many words where used by the transmitted trice and is usable for the memory management. See RingBuffer for example.
+//! The returned value is typically (TRICE_DATA_OFFSET/4) plus 1 (4 bytes) to 3 (9-12 bytes) but could go up to ((TRICE_DATA_OFFSET/4)+(TRICE_BUFFER_SIZE/4)).
+//! Return values <= 0 signal an error.
+//! TriceRingBufferReadPosition points to the begin of a single trice.
+//! The data at TriceRingBufferReadPosition are getting destroyed, because buffer is used as scratch pad.
+static void triceSingleDeferredOut(int *wordCount)
+{
+    uint8_t *enc = ((uint8_t *)TriceRingBufferReadPosition) - TRICE_DATA_OFFSET; // TRICE_DATA_OFFSET bytes are usable in front of TriceRingBufferReadPosition.
+    uint8_t *pTriceNetStart;                                                    // Trice starts here. That is maybe a 2 bytes offset from TriceRingBufferReadPosition.
+    size_t triceNetLength;                                                      // Trice length without padding bytes.
+    int triceID = TriceIDAndBuffer(TriceRingBufferReadPosition, wordCount, &pTriceNetStart, &triceNetLength);
+    // We can let TRICE_DATA_OFFSET only in front of the ring buffer and pack the Trices without offset space.
+    // And if we allow as max depth only ring buffer size minus TRICE_DATA_OFFSET, we can use space in front of each Trice.
+
+#if (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+#if TRICE_CONFIG_WARNINGS == 1
+#warning configuration: The Trice tool does not support encryption without COBS (or TCOBS) framing.
+#endif
+    size_t encLen = TriceEncode(TRICE_DEFERRED_XTEA_ENCRYPT, TRICE_DEFERRED_OUT_FRAMING, enc, pTriceNetStart, triceNetLength);
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1)
+    // comment: The following 2 steps could be done in an incremental way within one singe loop.
+    // Behind the trice brutto length (with padding bytes), 4 bytes needed as scratch pad when XTEA is active.
+    // After TriceIDAndBuffer pTriceNetStart could have a 2 bytes offset.
+    uint8_t *tmp = ((uint8_t *)TriceRingBufferReadPosition) - 4;
+    memmove(tmp, pTriceNetStart, triceNetLength);           // Make 4 bytes space for scratch pad beind Trice message.
+    size_t len8 = (triceNetLength + 7) & ~7;                // Only multiple of 8 are possible to encrypt, so we adjust len.
+    memset(tmp + triceNetLength, 0, len8 - triceNetLength); // clear padding space
+    XTEAEncrypt((uint32_t *)tmp, len8 >> 2);
+#if TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS
+    size_t encLen = (size_t)TCOBSEncode(enc, tmp, len8);
+#elif TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS
+    size_t encLen = COBSEncode(enc, tmp, len8);
+#else
+#error configuration
+#endif
+    enc[encLen++] = 0; // Add zero as package delimiter.
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS)
+    size_t len = (size_t)TCOBSEncode(enc, pTriceNetStart, triceNetLength);
+    enc[len++] = 0; // Add zero as package delimiter.
+    size_t encLen = len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)
+    size_t len = (size_t)COBSEncode(enc, pTriceNetStart, triceNetLength);
+    enc[len++] = 0; // Add zero as package delimiter.
+    size_t encLen = len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+    enc = pTriceNetStart;
+    size_t encLen = triceNetLength;
+#else
+#error configuration: TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE for ring buffer not implemented yet
+#endif
+#if TRICE_DIAGNOSTICS == 1
+    // enc                 addr  pTriceNetStart           nextData
+    // ^-TRICE_DATA_OFFSET-^-0|2-^-triceNetLength+(0...3)-^
+    // ^-encLen->firstNotModifiedAddress
+    uint8_t *nextData = (uint8_t *)(((uintptr_t)(pTriceNetStart + triceNetLength + 3)) & ~3);
+    uint8_t *firstNotModifiedAddress = enc + encLen;
+    int distance = nextData - firstNotModifiedAddress;
+    int triceDataOffsetDepth = TRICE_DATA_OFFSET - distance; // distance could get > TRICE_DATA_OFFSET, so TriceDataOffsetDepthMax stays unchanged then.
+    TriceDataOffsetDepthMax = triceDataOffsetDepth < TriceDataOffsetDepthMax ? TriceDataOffsetDepthMax : triceDataOffsetDepth;
+#endif // #if TRICE_DIAGNOSTICS == 1
+    TriceNonBlockingDeferredWrite8(triceID, enc, encLen);
+}
+
+    #endif // #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_SINGLE_PACK_MODE
+
+    #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+
+// triceMultiDeferredOut packs Trices until the Ring Buffer end and returns their count and total length in words.
+// These 2 values are used later, after the transmission is finished, for advancing.
+// The value TricesCountRingBuffer is evaluated internally but not modified.
+static void triceMultiDeferredOut(int *triceCount, int *multiWordCount)
+{
+    *triceCount = 0;
+    *multiWordCount = 0;
+    if (TricesCountRingBuffer == 0)
+    {
+        return; // Nothing to do.
+    }
+    // At least one Trice message is ready for transfer.
+    if (TriceRingBufferReadPosition > TriceRingBufferLimit - TRICE_RING_BUFFER_MIN_SPACE32)
+    {
+        for (;;)
+        ;     // unexpected
+    }
+
+    // We can start at TriceRingBufferReadPosition and go to the TriceRingBufferLimit OR go to the TriceBufferWritePosition using TricesCountRingBuffer.
+    uint8_t *enc = ((uint8_t *)TriceRingBufferReadPosition) - TRICE_DATA_OFFSET; // TRICE_DATA_OFFSET bytes are usable in front of TriceRingBufferReadPosition.
+    uint8_t *tmp = enc + TRICE_DATA_OFFSET / 2;                                 // todo
+    uint8_t *nextEnc = tmp;
+    int multiLen = 0;
+    uint32_t *nextTriceRingBufferReadPosition = TriceRingBufferReadPosition;
+    do
+    {
+        int wordCount = 0;
+        uint8_t *pTriceNetStart; // Trice starts here.
+        size_t triceNetLength;   // Trice length without padding bytes.
+        TriceIDAndBuffer(nextTriceRingBufferReadPosition, &wordCount, &pTriceNetStart, &triceNetLength);
+        memmove(nextEnc, pTriceNetStart, triceNetLength);
+        nextEnc += triceNetLength;
+        multiLen += triceNetLength;
+        *multiWordCount += wordCount;
+        (*triceCount)++;
+        nextTriceRingBufferReadPosition += wordCount;
+
+    } while (*triceCount < TricesCountRingBuffer && nextTriceRingBufferReadPosition <= TriceRingBufferLimit - TRICE_RING_BUFFER_MIN_SPACE32);
+
+#if (TRICE_DEFERRED_XTEA_ENCRYPT == 1) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+#if TRICE_CONFIG_WARNINGS == 1
+#warning configuration: The Trice tool does not support encryption without COBS (or TCOBS) framing.
+#endif
+    size_t encLen = TriceEncode(TRICE_DEFERRED_XTEA_ENCRYPT, TRICE_DEFERRED_OUT_FRAMING, enc, enc, multiLen);
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 1)
+    size_t len8 = (multiLen + 7) & ~7;          // Only multiple of 8 are possible to encrypt, so we adjust len.
+    memset(tmp + multiLen, 0, len8 - multiLen); // clear padding space
+    XTEAEncrypt((uint32_t *)tmp, len8 >> 2);
+#if TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS
+    size_t encLen = (size_t)TCOBSEncode(enc, tmp, len8);
+    enc[encLen++] = 0;
+#elif TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS
+    size_t encLen = (size_t)COBSEncode(enc, tmp, len8);
+    enc[encLen++] = 0;
+#else
+#error configuration
+#endif
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_TCOBS)
+    size_t len = (size_t)TCOBSEncode(enc, tmp, multiLen);
+    enc[len++] = 0; // Add zero as package delimiter.
+    size_t encLen = len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_COBS)
+    size_t len = (size_t)COBSEncode(enc, tmp, multiLen);
+    enc[len++] = 0; // Add zero as package delimiter.
+    size_t encLen = len;
+#elif (TRICE_DEFERRED_XTEA_ENCRYPT == 0) && (TRICE_DEFERRED_OUT_FRAMING == TRICE_FRAMING_NONE)
+    size_t encLen = multiLen;
+#else
+#error configuration: TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE for ring buffer not implemented yet
+#endif
+#if TRICE_DIAGNOSTICS == 1
+    // todo ...
+#endif // #if TRICE_DIAGNOSTICS == 1
+    TriceNonBlockingDeferredWrite8(0, enc, encLen);
+}
+
+    #endif // #if TRICE_DEFERRED_TRANSFER_MODE == TRICE_MULTI_PACK_MODE
+
+    #if TRICE_RING_BUFFER_OVERFLOW_WATCH == 1
+
+void TriceInitRingBufferMargins(void)
+{
+    for (int i = 0; i < TRICE_RING_BUFFER_LOWER_MARGIN; i++)
+    {
+        triceRingBuffer[i] = TRICE_RING_BUFFER_MARGIN_FILL_VALUE;
+    }
+    for (int i = 0; i < TRICE_RING_BUFFER_UPPER_MARGIN; i++)
+    {
+        *(TriceRingBufferLimit + i) = TRICE_RING_BUFFER_MARGIN_FILL_VALUE;
+    }
+}
+
+void WatchRingBufferMargins(void)
+{
+    for (int i = 0; i < TRICE_RING_BUFFER_LOWER_MARGIN; i++)
+    {
+        if (triceRingBuffer[i] != TRICE_RING_BUFFER_MARGIN_FILL_VALUE)
+        {
+            for (;;)
+            ;
+        }
+    }
+
+    for (int i = 0; i < TRICE_RING_BUFFER_UPPER_MARGIN; i++)
+    {
+        if (*(TriceRingBufferLimit + i) != TRICE_RING_BUFFER_MARGIN_FILL_VALUE)
+        {
+            for (;;)
+            ;
+        }
+    }
+}
+
+    #endif // #if TRICE_RING_BUFFER_OVERFLOW_WATCH == 1
+
+#endif // #if TRICE_BUFFER == TRICE_RING_BUFFER && TRICE_OFF == 0

Middlewares/trice/triceStackBuffer.c

@@ -0,0 +1,12 @@
+//! \file triceStackBuffer.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//!     //////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+#if TRICE_BUFFER == TRICE_STACK_BUFFER && TRICE_OFF == 0
+
+void TriceTransfer(void)
+{
+}
+
+#endif // #if TRICE_BUFFER == TRICE_STACK_BUFFER && TRICE_OFF == 0

Middlewares/trice/triceStaticBuffer.c

@@ -0,0 +1,16 @@
+//! \file triceStaticBuffer.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//! //////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+
+#if TRICE_BUFFER == TRICE_STATIC_BUFFER && TRICE_OFF == 0
+
+//! triceSingleBuffer holds a single trice during direct trice macro execution.
+uint32_t triceSingleBuffer[TRICE_BUFFER_SIZE >> 2];
+
+//! triceSingleBufferStartWritePosition points to trice data start.
+uint32_t* const triceSingleBufferStartWritePosition = &triceSingleBuffer[TRICE_DATA_OFFSET >> 2];
+
+void TriceTransfer(void) {}
+
+#endif // #if TRICE_BUFFER == TRICE_STATIC_BUFFER && TRICE_OFF == 0

Middlewares/trice/triceUart.c

@@ -0,0 +1,148 @@
+//! \file triceUart.c
+//! \author Thomas.Hoehenleitner [at] seerose.net
+//!     //////////////////////////////////////////////////////////////////////////
+#include "trice.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+#if TRICE_DEFERRED_UARTA == 1 && TRICE_OFF == 0
+
+    #include "triceUart.h" // User has to provide this hardeware specific file, see examples folders.
+
+//! triceOutBufferUartA points into the double or ring buffer to the next (encoded) trice package.
+static const uint8_t *triceOutBufferUartA;
+
+//! triceOutCountUartA is the not yet transmitted byte count after a TriceNonBlockingWriteUartA() call.
+static size_t triceOutCountUartA = 0;
+
+//! triceOutIndexUartA is the triceOutBufferUartA offset to the next to transmit byte.
+static unsigned triceOutIndexUartA = 0;
+
+//! TriceNonBlockingWriteUartA registers a buffer for TRICE_UARTA transmission.
+//! \param buf is byte buffer start.
+//! \param nByte is the number of bytes to transfer
+void TriceNonBlockingWriteUartA(const void *buf, size_t nByte)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(buf, nByte);
+#else // #if TRICE_CGO == 1// automated tests
+    TRICE_ENTER_CRITICAL_SECTION
+#if 1
+        triceOutBufferUartA = buf;
+#else
+    static uint8_t t[TRICE_DEFERRED_BUFFER_SIZE / 2]; // todo: find a better solution to avoid RAM wasting
+    memcpy(t, buf, nByte);
+    triceOutBufferUartA = t;
+#endif
+    triceOutIndexUartA = 0;
+    triceOutCountUartA = nByte;
+    triceEnableTxEmptyInterruptUartA(); // triceTriggerTransmitUartA();
+    TRICE_LEAVE_CRITICAL_SECTION
+#endif // #else // #if TRICE_CGO == 1// automated tests
+}
+
+//! TriceOutDepthUartA returns the amount of bytes not written yet to UARTB.
+unsigned TriceOutDepthUartA(void)
+{
+    unsigned depth;
+    TRICE_ENTER_CRITICAL_SECTION
+        depth = triceOutCountUartA - triceOutIndexUartA;
+    TRICE_LEAVE_CRITICAL_SECTION
+    return depth;
+}
+
+//! triceNextUint8UartA returns the next trice byte for transmission to TRICE_UARTA.
+TRICE_INLINE uint8_t triceNextUint8UartA(void)
+{
+    uint8_t c;
+    TRICE_ENTER_CRITICAL_SECTION
+        c = triceOutBufferUartA[triceOutIndexUartA++];
+    TRICE_LEAVE_CRITICAL_SECTION
+    return c;
+}
+
+//! triceServeTransmitUartA must be called cyclically to proceed ongoing write out.
+//! A good place is UARTA ISR.
+void triceServeTransmitUartA(void)
+{
+    TRICE_ENTER_CRITICAL_SECTION
+        triceTransmitData8UartA(triceNextUint8UartA());
+    if (0 == TriceOutDepthUartA())   // no more bytes
+    {
+        triceDisableTxEmptyInterruptUartA();
+    }
+    TRICE_LEAVE_CRITICAL_SECTION
+}
+
+//  // triceTriggerTransmitUartA must be called cyclically to initialize write out.
+//  void triceTriggerTransmitUartA(void){
+//      if( TriceOutDepthUartA() && triceTxDataRegisterEmptyUartA() ){
+//          triceEnableTxEmptyInterruptUartA(); // next bytes
+//      }
+//  }
+
+#endif // #if TRICE_DEFERRED_UARTA == 1
+
+#if TRICE_DEFERRED_UARTB == 1
+
+    #include "triceUart.h" // User has to provide this hardeware specific file, see examples folders.
+
+//! triceOutBufferUartB holds the uart out buffer address.
+static const uint8_t *triceOutBufferUartB;
+
+//! triceOutCountUartB holds th uarts out buffer size.
+static size_t triceOutCountUartB = 0;
+
+//! triceOutIndexUartB is the next to transmit byte index.
+static unsigned triceOutIndexUartB = 0;
+
+//! TriceNonBlockingWriteUartB registers a buffer for TRICE_UARTB transmission.
+//! \param buf is byte buffer start.
+//! \param nByte is the number of bytes to transfer
+void TriceNonBlockingWriteUartB(const void *buf, size_t nByte)
+{
+#if TRICE_CGO == 1 // automated tests
+    TriceWriteDeviceCgo(buf, nByte);
+#else  // #if TRICE_CGO == 1// automated tests
+    triceOutBufferUartB = buf;
+    triceOutIndexUartB = 0;
+    triceOutCountUartB = nByte;
+    triceTriggerTransmitUartB();
+#endif // #else // #if TRICE_CGO == 1// automated tests
+}
+
+//! TriceOutDepthUartB returns the amount of bytes not written yet to UARTB.
+unsigned TriceOutDepthUartB(void)
+{
+    // unsigned depthRtt0 = 0; -> assuming RTT is fast enough
+    unsigned depth = triceOutCountUartB - triceOutIndexUartB;
+    return depth;
+}
+
+//! triceNextUint8UartB returns the next trice byte for transmission to TRICE_UARTA.
+TRICE_INLINE uint8_t triceNextUint8UartB(void)
+{
+    return triceOutBufferUartB[triceOutIndexUartB++];
+}
+
+//! triceServeTransmitUartB must be called cyclically to proceed ongoing write out.
+//! A good place is UARTA ISR.
+void triceServeTransmitUartB(void)
+{
+    triceTransmitData8UartB(triceNextUint8UartB());
+    if (0 == TriceOutDepthUartB())   // no more bytes
+    {
+        triceDisableTxEmptyInterruptUartB();
+    }
+}
+
+// triceTriggerTransmitUartB must be called cyclically to initialize write out.
+void triceTriggerTransmitUartB(void)
+{
+    if (TriceOutDepthUartB() && triceTxDataRegisterEmptyUartB())
+    {
+        triceEnableTxEmptyInterruptUartB(); // next bytes
+    }
+}
+
+#endif // #if TRICE_DEFERRED_UARTB == 1 && TRICE_OFF == 0

Middlewares/trice/xtea.c

@@ -0,0 +1,89 @@
+/*! \file xtea.c
+\author Thomas.Hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#include "xtea.h"
+#include "trice.h"
+
+#if ((TRICE_DIRECT_XTEA_ENCRYPT == 1) || (TRICE_DEFERRED_XTEA_ENCRYPT == 1)) && TRICE_OFF == 0
+
+//! golang XTEA works with 64 rounds
+static const unsigned int numRounds = 64;
+
+//! 128 bit static key
+static const uint32_t k[4] = XTEA_ENCRYPT_KEY;
+
+//! internal constant
+static const uint32_t delta = 0x9E3779B9;
+
+//! precomputed values for faster execution
+static uint32_t table[64];
+
+//! XTEAInitTable precalculates the table.
+//! It is possible to put this table completely into FLASH by precomputing it during compile time.
+void XTEAInitTable(void) {
+	uint32_t sum = 0;
+	unsigned i;
+	// Two rounds of XTEA applied per loop
+	for (i = 0; i < numRounds;) {
+		table[i] = sum + k[sum & 3];
+		i++;
+		sum += delta;
+		table[i] = sum + k[(sum >> 11) & 3]; // lint !e661 Warning 661: Possible access of out-of-bounds pointer (1 beyond end of data) by operator '['
+		i++;
+	}
+}
+
+// encipher converts 64 bits.
+//! Code taken and adapted from xtea\block.go
+//!\param v 64 bits of data in v[0] and v[1] are encoded in place
+static void encipher(uint32_t v[2]) {
+	uint32_t v0 = v[0], v1 = v[1];
+	unsigned i;
+	for (i = 0; i < numRounds;) {
+		v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ table[i];
+		i++;
+		v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ table[i]; // lint !e661 Warning 661: Possible access of out-of-bounds pointer (1 beyond end of data) by operator '['
+		i++;
+	}
+	v[0] = v0;
+	v[1] = v1;
+}
+
+#if XTEA_DECRYPT == 1
+//! decipher reverses encipher action.
+//! Code taken and adapted from xtea\block.go
+//!\param v 64 bits of data in v[0] and v[1] are decoded in place
+static void decipher(uint32_t v[2]) {
+	uint32_t v0 = v[0], v1 = v[1];
+	for (int i = numRounds; i > 0;) {
+		i--;
+		v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ table[i];
+		i--;
+		v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ table[i];
+	}
+	v[0] = v0;
+	v[1] = v1;
+}
+
+//! XTEADecrypt re-converts from xtea cipher.
+//! \param p pointer to 8 byte buffer
+//! count is expected to be an even number.
+void XTEADecrypt(uint32_t* p, unsigned count) {
+	for (int i = 0; i < count; i += 2) {
+		decipher(&p[i]); // byte swapping is done inside receiver according to endianness.
+	}
+}
+#endif // #if XTEA_DECRYPT == 1
+
+//! XTEAEncrypt converts to xtea cipher.
+//! \param p pointer to 8 byte buffer.
+//! count is expected to be an even number.
+void XTEAEncrypt(uint32_t* p, unsigned count) {
+	unsigned i;
+	for (i = 0; i < count; i += 2) {
+		encipher(&p[i]); // byte swap is done inside receiver
+	}
+}
+
+#endif // #if ((TRICE_DIRECT_XTEA_ENCRYPT == 1) || (TRICE_DEFERRED_XTEA_ENCRYPT == 1)) && TRICE_OFF == 0

Middlewares/trice/xtea.h

@@ -0,0 +1,33 @@
+/*! \file xtea.h
+\author Thomas.Hoehenleitner [at] seerose.net
+*******************************************************************************/
+
+#ifndef TRICE_XTEA_H_
+#define TRICE_XTEA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h> //lint !e537 !e451  Warning 537: Repeated include file,  Warning 451: Header file repeatedly included but does not have a standard
+
+void XTEAInitTable(void);
+void XTEADecrypt(uint32_t* p, unsigned count);
+void XTEAEncrypt(uint32_t* p, unsigned count);
+
+//! little endian! change byte order for big endian machines
+#define XTEA_KEY(b00, b01, b02, b03, \
+                 b10, b11, b12, b13, \
+                 b20, b21, b22, b23, \
+                 b30, b31, b32, b33) \
+	{                                \
+	    0x##b00##b01##b02##b03,      \
+	    0x##b10##b11##b12##b13,      \
+	    0x##b20##b21##b22##b23,      \
+	    0x##b30##b31##b32##b33}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TRICE_XTEA_H_