esp32: SEGGER SystemView Tracing Support

Implements support for system level traces compatible with SEGGER
SystemView tool on top of ESP32 application tracing module.
That kind of traces can help to analyse program's behaviour.
SystemView can show timeline of tasks/ISRs execution, context switches,
statistics related to the CPUs' load distribution etc.

Also this commit adds useful feature to ESP32 application tracing module:
 - Trace data buffering is implemented to handle temporary peaks of events load

Kconfig

@@ -46,6 +46,3 @@ endchoice
 menu "Component config"
 source "$COMPONENT_KCONFIGS"
 endmenu
-
-
-

components/app_trace/Kconfig

@@ -0,0 +1,184 @@
+menu "Application Level Tracing"
+
+choice ESP32_APPTRACE_DESTINATION
+    prompt "Data Destination"
+    default ESP32_APPTRACE_DEST_NONE
+    help
+        Select destination for application trace: trace memory or none (to disable).
+
+config ESP32_APPTRACE_DEST_TRAX
+    bool "Trace memory"
+    select ESP32_APPTRACE_ENABLE
+config ESP32_APPTRACE_DEST_NONE
+    bool "None"
+endchoice
+
+config ESP32_APPTRACE_ENABLE
+    bool
+    depends on !ESP32_TRAX
+    select MEMMAP_TRACEMEM
+    select MEMMAP_TRACEMEM_TWOBANKS
+    default n
+    help
+        Enables/disable application tracing module.
+
+config ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO
+    int "Timeout for flushing last trace data to host on panic"
+    depends on ESP32_APPTRACE_ENABLE
+    range -1 5000
+    default -1
+    help
+        Timeout for flushing last trace data to host in case of panic. In ms.
+        Use -1 to disable timeout and wait forever.
+
+config ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH
+    int "Threshold for flushing last trace data to host on panic"
+    depends on ESP32_APPTRACE_DEST_TRAX
+    range 0 16384
+    default 0
+    help
+        Threshold for flushing last trace data to host on panic in post-mortem mode.
+        This is minimal amount of data needed to perform flush. In bytes.
+
+config ESP32_APPTRACE_PENDING_DATA_SIZE_MAX
+    int "Size of the pending data buffer"
+    depends on ESP32_APPTRACE_DEST_TRAX
+    default 0
+    help
+        Size of the buffer for events in bytes. It is useful for buffering events from
+        the time critical code (scheduler, ISRs etc). If this parameter is 0 then
+        events will be discarded when main HW buffer is full.
+
+menu "FreeRTOS SystemView Tracing"
+config SYSVIEW_ENABLE
+    bool "SystemView Tracing Enable"
+    depends on ESP32_APPTRACE_ENABLE
+    default n
+    help
+        Enables supporrt for SEGGER SystemView tracing functionality.
+
+if !FREERTOS_UNICORE
+choice SYSVIEW_TS_SOURCE
+    prompt "ESP32 timer to use as SystemView timestamp source"
+    depends on SYSVIEW_ENABLE
+    default SYSVIEW_TS_SOURCE_TIMER_00
+    help
+        SystemView needs one source for timestamps when tracing events from both cores.
+        This option selects HW timer for it.
+
+config SYSVIEW_TS_SOURCE_TIMER_00
+    bool "Timer 0, Group 0"
+    help
+        Select this to use timer 0 of group 0
+
+config SYSVIEW_TS_SOURCE_TIMER_01
+    bool "Timer 1, Group 0"
+    help
+        Select this to use timer 1 of group 0
+
+config SYSVIEW_TS_SOURCE_TIMER_10
+    bool "Timer 0, Group 1"
+    help
+        Select this to use timer 0 of group 1
+
+config SYSVIEW_TS_SOURCE_TIMER_11
+    bool "Timer 1, Group 1"
+    help
+        Select this to use timer 1 of group 1
+
+endchoice
+endif #FREERTOS_UNICORE
+
+config SYSVIEW_EVT_OVERFLOW_ENABLE
+    bool "Trace Buffer Overflow Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Trace Buffer Overflow" event.
+
+config SYSVIEW_EVT_ISR_ENTER_ENABLE
+    bool "ISR Enter Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "ISR Enter" event.
+
+config SYSVIEW_EVT_ISR_EXIT_ENABLE
+    bool "ISR Exit Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "ISR Exit" event.
+
+config SYSVIEW_EVT_ISR_TO_SCHEDULER_ENABLE
+    bool "ISR Exit to Scheduler Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "ISR to Scheduler" event.
+
+config SYSVIEW_EVT_TASK_START_EXEC_ENABLE
+    bool "Task Start Execution Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Start Execution" event.
+
+config SYSVIEW_EVT_TASK_STOP_EXEC_ENABLE
+    bool "Task Stop Execution Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Stop Execution" event.
+
+config SYSVIEW_EVT_TASK_START_READY_ENABLE
+    bool "Task Start Ready State Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Start Ready State" event.
+
+config SYSVIEW_EVT_TASK_STOP_READY_ENABLE
+    bool "Task Stop Ready State Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Stop Ready State" event.
+
+config SYSVIEW_EVT_TASK_CREATE_ENABLE
+    bool "Task Create Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Create" event.
+
+config SYSVIEW_EVT_TASK_TERMINATE_ENABLE
+    bool "Task Terminate Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Task Terminate" event.
+
+config SYSVIEW_EVT_IDLE_ENABLE
+    bool "System Idle Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "System Idle" event.
+
+config SYSVIEW_EVT_TIMER_ENTER_ENABLE
+    bool "Timer Enter Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Timer Enter" event.
+
+config SYSVIEW_EVT_TIMER_EXIT_ENABLE
+    bool "Timer Exit Event"
+    depends on SYSVIEW_ENABLE
+    default y
+    help
+        Enables "Timer Exit" event.
+
+endmenu
+endmenu

components/app_trace/app_trace_util.c

@@ -0,0 +1,207 @@
+// Copyright 2017 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_app_trace_util.h"
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////// LOCK ////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#define ESP_TEST_CPUTICKS2US(_t_)       ((_t_)/(XT_CLOCK_FREQ/1000000))
+
+esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo)
+{
+    unsigned cur, elapsed;
+
+    if (tmo->tmo != 0xFFFFFFFF) {
+        cur = portGET_RUN_TIME_COUNTER_VALUE();
+        if (tmo->start <= cur) {
+            elapsed = cur - tmo->start;
+        } else {
+            elapsed = 0xFFFFFFFF - tmo->start + cur;
+        }
+        if (ESP_TEST_CPUTICKS2US(elapsed) >= tmo->tmo) {
+            return ESP_ERR_TIMEOUT;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_apptrace_lock_take(esp_apptrace_lock_t *lock, uint32_t tmo)
+{
+    uint32_t res;
+#if CONFIG_SYSVIEW_ENABLE
+    uint32_t recCnt;
+#endif
+    esp_apptrace_tmo_t sleeping_tmo;
+
+    esp_apptrace_tmo_init(&sleeping_tmo, tmo);
+    while (1) {
+        res = (xPortGetCoreID() << portMUX_VAL_SHIFT) | portMUX_MAGIC_VAL;
+        // first disable IRQs on this CPU, this will prevent current task from been
+        // preempted by higher prio tasks, otherwise deadlock can happen:
+        // when lower prio task took mux and then preempted by higher prio one which also tries to
+        // get mux with INFINITE timeout
+        unsigned int irq_stat = portENTER_CRITICAL_NESTED();
+        // Now try to lock mux
+        uxPortCompareSet(&lock->portmux.mux, portMUX_FREE_VAL, &res);
+        if (res == portMUX_FREE_VAL) {
+            // do not enable IRQs, we will held them disabled until mux is unlocked
+            // we do not need to flush cache region for mux->irq_stat because it is used
+            // to hold and restore IRQ state only for CPU which took mux, other CPUs will not use this value
+            lock->irq_stat = irq_stat;
+            break;
+        }
+#if CONFIG_SYSVIEW_ENABLE
+        else if (((res & portMUX_VAL_MASK) >> portMUX_VAL_SHIFT) == xPortGetCoreID()) {
+            recCnt = (res & portMUX_CNT_MASK) >> portMUX_CNT_SHIFT;
+            recCnt++;
+            // ets_printf("Recursive lock: recCnt=%d\n", recCnt);
+            lock->portmux.mux = portMUX_MAGIC_VAL | (recCnt << portMUX_CNT_SHIFT) | (xPortGetCoreID() << portMUX_VAL_SHIFT);
+            break;
+        }
+#endif
+        // if mux is locked by other task/ISR enable IRQs and let other guys work
+        portEXIT_CRITICAL_NESTED(irq_stat);
+
+        int err = esp_apptrace_tmo_check(&sleeping_tmo);
+        if (err != ESP_OK) {
+            return err;
+        }
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_apptrace_lock_give(esp_apptrace_lock_t *lock)
+{
+    esp_err_t ret = ESP_OK;
+    uint32_t res = 0;
+    unsigned int irq_stat;
+#if CONFIG_SYSVIEW_ENABLE
+    uint32_t recCnt;
+#endif
+    res = portMUX_FREE_VAL;
+
+    // first of all save a copy of IRQ status for this locker because uxPortCompareSet will unlock mux and tasks/ISRs
+    // from other core can overwrite mux->irq_stat
+    irq_stat = lock->irq_stat;
+    uxPortCompareSet(&lock->portmux.mux, (xPortGetCoreID() << portMUX_VAL_SHIFT) | portMUX_MAGIC_VAL, &res);
+
+    if ( ((res & portMUX_VAL_MASK) >> portMUX_VAL_SHIFT) == xPortGetCoreID() ) {
+#if CONFIG_SYSVIEW_ENABLE
+        //Lock is valid, we can return safely. Just need to check if it's a recursive lock; if so we need to decrease the refcount.
+        if ( ((res & portMUX_CNT_MASK) >> portMUX_CNT_SHIFT) != 0) {
+            //We locked this, but the reccount isn't zero. Decrease refcount and continue.
+            recCnt = (res & portMUX_CNT_MASK) >> portMUX_CNT_SHIFT;
+            recCnt--;
+            lock->portmux.mux = portMUX_MAGIC_VAL | (recCnt << portMUX_CNT_SHIFT) | (xPortGetCoreID() << portMUX_VAL_SHIFT);
+        }
+#endif
+    } else if ( res == portMUX_FREE_VAL ) {
+        ret = ESP_FAIL; // should never get here
+    } else {
+        ret = ESP_FAIL;  // should never get here
+    }
+    // restore local interrupts
+    portEXIT_CRITICAL_NESTED(irq_stat);
+    return ret;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+////////////////////////////// RING BUFFER ////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint8_t *esp_apptrace_rb_produce(esp_apptrace_rb_t *rb, uint32_t size)
+{
+    uint8_t *ptr = rb->data + rb->wr;
+    // check for avalable space
+    if (rb->rd <= rb->wr) {
+        // |?R......W??|
+        if (rb->wr + size >= rb->size) {
+            if (rb->rd == 0) {
+                return NULL; // cannot wrap wr
+            }
+            if (rb->wr + size == rb->size) {
+                rb->wr = 0;
+            } else {
+                // check if we can wrap wr earlier to get space for requested size
+                if (size > rb->rd - 1) {
+                    return NULL; // cannot wrap wr
+                }
+                // shrink buffer a bit, full size will be restored at rd wrapping
+                rb->cur_size = rb->wr;
+                rb->wr = 0;
+                ptr = rb->data;
+                if (rb->rd == rb->cur_size) {
+                    rb->rd = 0;
+                    if (rb->cur_size < rb->size) {
+                        rb->cur_size = rb->size;
+                    }
+                }
+                rb->wr += size;
+            }
+        } else {
+            rb->wr += size;
+        }
+    } else {
+        // |?W......R??|
+        if (size > rb->rd - rb->wr - 1) {
+            return NULL;
+        }
+        rb->wr += size;
+    }
+    return ptr;
+}
+
+uint8_t *esp_apptrace_rb_consume(esp_apptrace_rb_t *rb, uint32_t size)
+{
+    uint8_t *ptr = rb->data + rb->rd;
+    if (rb->rd <= rb->wr) {
+        // |?R......W??|
+        if (rb->rd + size > rb->wr) {
+            return NULL;
+        }
+        rb->rd += size;
+    } else {
+        // |?W......R??|
+        if (rb->rd + size > rb->cur_size) {
+            return NULL;
+        } else if (rb->rd + size == rb->cur_size) {
+            // restore full size usage
+            if (rb->cur_size < rb->size) {
+                rb->cur_size = rb->size;
+            }
+            rb->rd = 0;
+        } else {
+            rb->rd += size;
+        }
+    }
+    return ptr;
+}
+
+uint32_t esp_apptrace_rb_read_size_get(esp_apptrace_rb_t *rb)
+{
+    uint32_t size = 0;
+    if (rb->rd <= rb->wr) {
+        // |?R......W??|
+        size = rb->wr - rb->rd;
+    } else {
+        // |?W......R??|
+        size = rb->cur_size - rb->rd;
+    }
+    return size;
+}

components/app_trace/component.mk

@@ -0,0 +1,24 @@
+#
+# Component Makefile
+#
+
+COMPONENT_SRCDIRS := .
+
+COMPONENT_ADD_INCLUDEDIRS := include
+
+COMPONENT_ADD_LDFLAGS := -lapp_trace 
+
+ifdef CONFIG_SYSVIEW_ENABLE
+#COMPONENT_EXTRA_INCLUDES := freertos
+
+COMPONENT_ADD_INCLUDEDIRS += \
+	sys_view/Config \
+	sys_view/SEGGER \
+	sys_view/Sample/OS
+
+COMPONENT_SRCDIRS += \
+	sys_view/SEGGER \
+	sys_view/Sample/OS \
+	sys_view/Sample/Config \
+	sys_view/esp32
+endif

components/app_trace/include/esp_app_trace.h

@@ -16,20 +16,17 @@
 
 #include <stdarg.h>
 #include "esp_err.h"
+#include "freertos/portmacro.h"
 
-// infinite waiting timeout
+/** Infinite waiting timeout */
 #define ESP_APPTRACE_TMO_INFINITE               ((uint32_t)-1)
 
-// Trace memory block size
-#define ESP_APPTRACE_TRAX_BLOCK_SIZE            0x4000UL
-
 /**
  * Application trace data destinations bits.
  */
 typedef enum {
-    ESP_APPTRACE_DEST_TRAX = 0x1,
-    ESP_APPTRACE_DEST_UART0 = 0x2,
-    //ESP_APPTRACE_DEST_UART1 = 0x4,
+    ESP_APPTRACE_DEST_TRAX = 0x1,	///< JTAG destination
+    ESP_APPTRACE_DEST_UART0 = 0x2,	///< UART destination
 } esp_apptrace_dest_t;
 
 /**
@@ -37,7 +34,7 @@ typedef enum {
  *
  * @note   Should be called before any esp_apptrace_xxx call.
  *
- * @return ESP_OK on success, otherwise \see esp_err_t
+ * @return ESP_OK on success, otherwise see esp_err_t
  */
 esp_err_t esp_apptrace_init();
 
@@ -61,7 +58,7 @@ uint8_t *esp_apptrace_buffer_get(esp_apptrace_dest_t dest, size_t size, uint32_t
  * @param ptr  Address of trace buffer to release. Should be the value returned by call to esp_apptrace_buffer_get.
  * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
  *
- * @return ESP_OK on success, otherwise \see esp_err_t
+ * @return ESP_OK on success, otherwise see esp_err_t
  */
 esp_err_t esp_apptrace_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, uint32_t tmo);
 
@@ -73,20 +70,21 @@ esp_err_t esp_apptrace_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, uint32
  * @param size Size of data to write to trace buffer.
  * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
  *
- * @return ESP_OK on success, otherwise \see esp_err_t
+ * @return ESP_OK on success, otherwise see esp_err_t
  */
-esp_err_t esp_apptrace_write(esp_apptrace_dest_t dest, void *data, size_t size, uint32_t tmo);
+esp_err_t esp_apptrace_write(esp_apptrace_dest_t dest, const void *data, size_t size, uint32_t tmo);
 
 /**
  * @brief vprintf-like function to sent log messages to host via specified HW interface.
  *
  * @param dest Indicates HW interface to send data.
+ * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
  * @param fmt  Address of format string.
  * @param ap   List of arguments.
  *
  * @return Number of bytes written.
  */
-int esp_apptrace_vprintf_to(esp_apptrace_dest_t dest, uint32_t user_tmo, const char *fmt, va_list ap);
+int esp_apptrace_vprintf_to(esp_apptrace_dest_t dest, uint32_t tmo, const char *fmt, va_list ap);
 
 /**
  * @brief vprintf-like function to sent log messages to host.
@@ -99,25 +97,38 @@ int esp_apptrace_vprintf_to(esp_apptrace_dest_t dest, uint32_t user_tmo, const c
 int esp_apptrace_vprintf(const char *fmt, va_list ap);
 
 /**
- * @brief  Flushes remaining data in trace buffer to host.
+ * @brief Flushes remaining data in trace buffer to host.
  *
  * @param dest Indicates HW interface to flush data on.
  * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
  *
- * @return ESP_OK on success, otherwise \see esp_err_t
+ * @return ESP_OK on success, otherwise see esp_err_t
  */
 esp_err_t esp_apptrace_flush(esp_apptrace_dest_t dest, uint32_t tmo);
 
 /**
  * @brief Flushes remaining data in trace buffer to host without locking internal data.
-          This is special version of esp_apptrace_flush which should be called from panic handler.
+ *        This is special version of esp_apptrace_flush which should be called from panic handler.
  *
  * @param dest   Indicates HW interface to flush data on.
  * @param min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.
  * @param tmo    Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
  *
- * @return ESP_OK on success, otherwise \see esp_err_t
+ * @return ESP_OK on success, otherwise see esp_err_t
  */
 esp_err_t esp_apptrace_flush_nolock(esp_apptrace_dest_t dest, uint32_t min_sz, uint32_t tmo);
 
+/**
+ * @brief Reads host data from trace buffer.
+ *
+ * @param dest Indicates HW interface to read the data on.
+ * @param data Address of buffer to put data from trace buffer.
+ * @param size Pointer to store size of read data. Before call to this function pointed memory must hold requested size of data
+ * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
+ *
+ * @return ESP_OK on success, otherwise see esp_err_t
+ */
+esp_err_t esp_apptrace_read(esp_apptrace_dest_t dest, void *data, size_t *size, uint32_t tmo);
+
+
 #endif

components/app_trace/include/esp_app_trace_util.h

@@ -0,0 +1,148 @@
+// Copyright 2017 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef ESP_APP_TRACE_UTIL_H_
+#define ESP_APP_TRACE_UTIL_H_
+
+#include "freertos/portmacro.h"
+#include "esp_err.h"
+
+/** Tracing module synchronization lock */
+typedef struct {
+    volatile unsigned int   irq_stat;   ///< local (on 1 CPU) IRQ state
+    portMUX_TYPE            portmux;    ///< mux for synchronization
+} esp_apptrace_lock_t;
+
+/**
+ * @brief Initializes lock structure.
+ *
+ * @param lock Pointer to lock structure to be initialized.
+ */
+static inline void esp_apptrace_lock_init(esp_apptrace_lock_t *lock)
+{
+    lock->portmux.mux = portMUX_FREE_VAL;
+    lock->irq_stat = 0;
+}
+
+/**
+ * @brief Tries to acquire lock in specified time period.
+ *
+ * @param lock Pointer to lock structure.
+ * @param tmo  Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
+ *
+ * @return ESP_OK on success, otherwise \see esp_err_t
+ */
+esp_err_t esp_apptrace_lock_take(esp_apptrace_lock_t *lock, uint32_t tmo);
+
+/**
+ * @brief Releases lock.
+ *
+ * @param lock Pointer to lock structure.
+ *
+ * @return ESP_OK on success, otherwise \see esp_err_t
+ */
+esp_err_t esp_apptrace_lock_give(esp_apptrace_lock_t *lock);
+
+
+/** Structure which holds data necessary for measuring time intervals. 
+ *
+ *  After initialization via esp_apptrace_tmo_init() user needs to call esp_apptrace_tmo_check()
+ *  periodically to check timeout for expiration.
+ */
+typedef struct {
+    uint32_t   start;   ///< time interval start (in ticks)
+    uint32_t   tmo;     ///< timeout value (in us)
+} esp_apptrace_tmo_t;
+
+/**
+ * @brief Initializes timeout structure.
+ *
+ * @param tmo       Pointer to timeout structure to be initialized.
+ * @param user_tmo  Timeout value (in us).
+*/
+static inline void esp_apptrace_tmo_init(esp_apptrace_tmo_t *tmo, uint32_t user_tmo)
+{
+    tmo->start = portGET_RUN_TIME_COUNTER_VALUE();
+    tmo->tmo = user_tmo;
+}
+
+/**
+ * @brief Checks timeout for expiration.
+ *
+ * @param tmo Pointer to timeout structure to be initialized.
+ *
+ * @return ESP_OK on success, otherwise \see esp_err_t
+ */
+esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo);
+
+
+/** Ring buffer control structure.
+ *
+ * @note For purposes of application tracing module if there is no enough space for user data and write pointer can be wrapped 
+ *       current ring buffer size can be temporarily shrinked in order to provide buffer with requested size.
+ */
+typedef struct {
+    uint8_t *data;      ///< pointer to data storage
+    uint32_t size;      ///< size of data storage
+    uint32_t cur_size;  ///< current size of data storage
+    uint32_t rd;        ///< read pointer
+    uint32_t wr;        ///< write pointer
+} esp_apptrace_rb_t;
+
+/**
+ * @brief Initializes ring buffer control  structure.
+ *
+ * @param rb   Pointer to ring buffer structure to be initialized.
+ * @param data Pointer to buffer to be used as ring buffer's data storage.
+ * @param size Size of buffer to be used as ring buffer's data storage.
+ */
+static inline void esp_apptrace_rb_init(esp_apptrace_rb_t *rb, uint8_t *data, uint32_t size)
+{
+    rb->data = data;
+    rb->size = rb->cur_size = size;
+    rb->rd = 0;
+    rb->wr = 0;
+}
+
+/**
+ * @brief Allocates memory chunk in ring buffer.
+ *
+ * @param rb   Pointer to ring buffer structure.
+ * @param size Size of the memory to allocate.
+ *
+ * @return Pointer to the allocated memory or NULL in case of failure.
+ */
+uint8_t *esp_apptrace_rb_produce(esp_apptrace_rb_t *rb, uint32_t size);
+
+/**
+ * @brief Consumes memory chunk in ring buffer.
+ *
+ * @param rb   Pointer to ring buffer structure.
+ * @param size Size of the memory to consume.
+ *
+ * @return Pointer to consumed memory chunk or NULL in case of failure.
+ */
+uint8_t *esp_apptrace_rb_consume(esp_apptrace_rb_t *rb, uint32_t size);
+
+/**
+ * @brief Gets size of memory which can consumed with single call to esp_apptrace_rb_consume().
+ *
+ * @param rb Pointer to ring buffer structure.
+ *
+ * @return Size of memory which can consumed.
+ *
+ * @note Due to read pointer wrapping returned size can be less then the total size of available data.
+ */
+uint32_t esp_apptrace_rb_read_size_get(esp_apptrace_rb_t *rb);
+
+#endif //ESP_APP_TRACE_UTIL_H_

components/app_trace/sys_view/Config/Global.h

@@ -0,0 +1,102 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+----------------------------------------------------------------------
+File    : Global.h
+Purpose : Global types
+          In case your application already has a Global.h, you should
+          merge the files. In order to use Segger code, the types
+          U8, U16, U32, I8, I16, I32 need to be defined in Global.h;
+          additional definitions do not hurt.
+---------------------------END-OF-HEADER------------------------------
+*/
+
+#ifndef GLOBAL_H            // Guard against multiple inclusion
+#define GLOBAL_H
+
+#define U8    unsigned char
+#define U16   unsigned short
+#define U32   unsigned long
+#define I8    signed char
+#define I16   signed short
+#define I32   signed long
+
+#ifdef _WIN32
+  //
+  // Microsoft VC6 compiler related
+  //
+  #define U64   unsigned __int64
+  #define U128  unsigned __int128
+  #define I64   __int64
+  #define I128  __int128
+  #if _MSC_VER <= 1200
+    #define U64_C(x) x##UI64
+  #else
+    #define U64_C(x) x##ULL
+  #endif
+#else 
+  //
+  // C99 compliant compiler
+  //
+  #define U64   unsigned long long
+  #define I64   signed long long
+  #define U64_C(x) x##ULL
+#endif
+
+#endif                      // Avoid multiple inclusion
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/Config/SEGGER_RTT_Conf.h

@@ -0,0 +1,298 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_Conf.h
+Purpose : Implementation of SEGGER real-time transfer (RTT) which
+          allows real-time communication on targets which support
+          debugger memory accesses while the CPU is running.
+Revision: $Rev: 5626 $
+
+*/
+
+#ifndef SEGGER_RTT_CONF_H
+#define SEGGER_RTT_CONF_H
+
+#ifdef __IAR_SYSTEMS_ICC__
+  #include <intrinsics.h>
+#endif
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+
+#define SEGGER_RTT_MAX_NUM_UP_BUFFERS             (3)     // Max. number of up-buffers (T->H) available on this target    (Default: 3)
+#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS           (3)     // Max. number of down-buffers (H->T) available on this target  (Default: 3)
+
+#define BUFFER_SIZE_UP                            (1024)  // Size of the buffer for terminal output of target, up to host (Default: 1k)
+#define BUFFER_SIZE_DOWN                          (16)    // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)
+
+#define SEGGER_RTT_PRINTF_BUFFER_SIZE             (64u)    // Size of buffer for RTT printf to bulk-send chars via RTT     (Default: 64)
+
+#define SEGGER_RTT_MODE_DEFAULT                   SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0)
+
+//
+// Target is not allowed to perform other RTT operations while string still has not been stored completely.
+// Otherwise we would probably end up with a mixed string in the buffer.
+// If using  RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here.
+//
+// SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4.
+// Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches.
+// When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly.
+// (Higher priority = lower priority number)
+// Default value for embOS: 128u
+// Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
+// In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC
+// or define SEGGER_RTT_LOCK() to completely disable interrupts.
+//
+
+#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY         (0x20)   // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20)
+
+/*********************************************************************
+*
+*       RTT lock configuration for SEGGER Embedded Studio,
+*       Rowley CrossStudio and GCC
+*/
+#if (defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)
+  #ifdef __ARM_ARCH_6M__
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                    unsigned int LockState;                                         \
+                                  __asm volatile ("mrs   %0, primask  \n\t"                         \
+                                                  "mov   r1, $1     \n\t"                           \
+                                                  "msr   primask, r1  \n\t"                         \
+                                                  : "=r" (LockState)                                \
+                                                  :                                                 \
+                                                  : "r1"                                            \
+                                                  );
+
+    #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   primask, %0  \n\t"                         \
+                                                  :                                                 \
+                                                  : "r" (LockState)                                 \
+                                                  :                                                 \
+                                                  );                                                \
+                                }
+
+  #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                    unsigned int LockState;                                         \
+                                  __asm volatile ("mrs   %0, basepri  \n\t"                         \
+                                                  "mov   r1, %1       \n\t"                         \
+                                                  "msr   basepri, r1  \n\t"                         \
+                                                  : "=r" (LockState)                                \
+                                                  : "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY)          \
+                                                  : "r1"                                            \
+                                                  );
+
+    #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   basepri, %0  \n\t"                         \
+                                                  :                                                 \
+                                                  : "r" (LockState)                                 \
+                                                  :                                                 \
+                                                  );                                                \
+                                }
+
+  #elif defined(__ARM_ARCH_7A__)
+    #define SEGGER_RTT_LOCK() {                                                \
+                                 unsigned int LockState;                       \
+                                 __asm volatile ("mrs r1, CPSR \n\t"           \
+                                                 "mov %0, r1 \n\t"             \
+                                                 "orr r1, r1, #0xC0 \n\t"      \
+                                                 "msr CPSR_c, r1 \n\t"         \
+                                                 : "=r" (LockState)            \
+                                                 :                             \
+                                                 : "r1"                        \
+                                                 );
+
+    #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t"              \
+                                                "mrs r1, CPSR \n\t"            \
+                                                "bic r1, r1, #0xC0 \n\t"       \
+                                                "and r0, r0, #0xC0 \n\t"       \
+                                                "orr r1, r1, r0 \n\t"          \
+                                                "msr CPSR_c, r1 \n\t"          \
+                                                :                              \
+                                                : "r" (LockState)              \
+                                                : "r0", "r1"                   \
+                                                );                             \
+                            }
+#else
+    #define SEGGER_RTT_LOCK()
+    #define SEGGER_RTT_UNLOCK()
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for IAR EWARM
+*/
+#ifdef __ICCARM__
+  #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__))
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_PRIMASK();                                      \
+                                  __set_PRIMASK(1);
+
+    #define SEGGER_RTT_UNLOCK()   __set_PRIMASK(LockState);                                         \
+                                }
+  #elif ((defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || (defined (__ARM7M__) && (__CORE__ == __ARM7M__)))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_BASEPRI();                                      \
+                                  __set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
+
+    #define SEGGER_RTT_UNLOCK()   __set_BASEPRI(LockState);                                         \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for IAR RX
+*/
+#ifdef __ICCRX__
+  #define SEGGER_RTT_LOCK()   {                                                                     \
+                                unsigned long LockState;                                            \
+                                LockState = __get_interrupt_state();                                \
+                                __disable_interrupt();
+
+  #define SEGGER_RTT_UNLOCK()   __set_interrupt_state(LockState);                                   \
+                              }
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for KEIL ARM
+*/
+#ifdef __CC_ARM
+  #if (defined __TARGET_ARCH_6S_M)
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  register unsigned char PRIMASK __asm( "primask");                 \
+                                  LockState = PRIMASK;                                              \
+                                  PRIMASK = 1u;                                                     \
+                                  __schedule_barrier();
+
+    #define SEGGER_RTT_UNLOCK()   PRIMASK = LockState;                                              \
+                                  __schedule_barrier();                                             \
+                                }
+  #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  register unsigned char BASEPRI __asm( "basepri");                 \
+                                  LockState = BASEPRI;                                              \
+                                  BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY;                      \
+                                  __schedule_barrier();
+
+    #define SEGGER_RTT_UNLOCK()   BASEPRI = LockState;                                              \
+                                  __schedule_barrier();                                             \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for TI ARM
+*/
+#ifdef __TI_ARM__
+  #if defined (__TI_ARM_V6M0__)
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_PRIMASK();                                      \
+                                  __set_PRIMASK(1);
+
+    #define SEGGER_RTT_UNLOCK()   __set_PRIMASK(LockState);                                         \
+                                }
+  #elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = OS_GetBASEPRI();                                      \
+                                  OS_SetBASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
+
+    #define SEGGER_RTT_UNLOCK()   OS_SetBASEPRI(LockState);                                         \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration fallback
+*/
+#ifndef   SEGGER_RTT_LOCK
+  void SEGGER_SYSVIEW_X_RTT_Lock();
+  #define SEGGER_RTT_LOCK()                SEGGER_SYSVIEW_X_RTT_Lock() // Lock RTT (nestable)   (i.e. disable interrupts)
+#endif
+
+#ifndef   SEGGER_RTT_UNLOCK
+  void SEGGER_SYSVIEW_X_RTT_Unlock();
+  #define SEGGER_RTT_UNLOCK()              SEGGER_SYSVIEW_X_RTT_Unlock() // Unlock RTT (nestable) (i.e. enable previous interrupt lock state)
+#endif
+
+#endif
+/*************************** End of file ****************************/

components/app_trace/sys_view/Config/SEGGER_SYSVIEW_Conf.h

@@ -0,0 +1,176 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+
+File    : SEGGER_SYSVIEW_Conf.h
+Purpose : SEGGER SystemView configuration.
+Revision: $Rev: 5927 $
+*/
+
+#ifndef SEGGER_SYSVIEW_CONF_H
+#define SEGGER_SYSVIEW_CONF_H
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+//
+// Constants for known core configuration
+//
+#define SEGGER_SYSVIEW_CORE_OTHER   0
+#define SEGGER_SYSVIEW_CORE_CM0     1 // Cortex-M0/M0+/M1
+#define SEGGER_SYSVIEW_CORE_CM3     2 // Cortex-M3/M4/M7
+#define SEGGER_SYSVIEW_CORE_RX      3 // Renesas RX
+
+#if (defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)
+  #ifdef __ARM_ARCH_6M__
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0
+  #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3
+  #endif
+#elif defined(__ICCARM__)
+  #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0
+  #elif ((defined (__ARM7M__) && (__CORE__ == __ARM7M__)) || (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3
+  #endif
+#elif defined(__CC_ARM)
+  #if (defined(__TARGET_ARCH_6S_M))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0
+  #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3
+  #endif
+#elif defined(__TI_ARM__)
+  #ifdef __TI_ARM_V6M0__
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0
+  #elif (defined(__TI_ARM_V7M3__) || defined(__TI_ARM_V7M4__))
+    #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3
+  #endif
+#elif defined(__ICCRX__)
+  #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_RX
+#elif defined(__RX)
+  #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_RX
+#endif
+
+#ifndef   SEGGER_SYSVIEW_CORE
+  #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_OTHER
+#endif
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       SystemView buffer configuration
+*/
+#define SEGGER_SYSVIEW_RTT_BUFFER_SIZE      1024                                // Number of bytes that SystemView uses for the buffer.
+#define SEGGER_SYSVIEW_RTT_CHANNEL          1                                   // The RTT channel that SystemView will use. 0: Auto selection
+
+#define SEGGER_SYSVIEW_USE_STATIC_BUFFER    1                                   // Use a static buffer to generate events instead of a buffer on the stack
+
+#define SEGGER_SYSVIEW_POST_MORTEM_MODE     0                                   // 1: Enable post mortem analysis mode
+
+/*********************************************************************
+*
+*       SystemView timestamp configuration
+*/
+#if SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM3
+  #define SEGGER_SYSVIEW_GET_TIMESTAMP()      (*(U32 *)(0xE0001004))            // Retrieve a system timestamp. Cortex-M cycle counter.
+  #define SEGGER_SYSVIEW_TIMESTAMP_BITS       32                                // Define number of valid bits low-order delivered by clock source
+#else
+  #define SEGGER_SYSVIEW_GET_TIMESTAMP()      SEGGER_SYSVIEW_X_GetTimestamp()   // Retrieve a system timestamp via user-defined function
+  #define SEGGER_SYSVIEW_TIMESTAMP_BITS       32                                // Define number of valid bits low-order delivered by SEGGER_SYSVIEW_X_GetTimestamp()
+#endif
+
+/*********************************************************************
+*
+*       SystemView Id configuration
+*/
+//TODO: optimise it
+#define SEGGER_SYSVIEW_ID_BASE         0x3F400000                               // Default value for the lowest Id reported by the application. Can be overridden by the application via SEGGER_SYSVIEW_SetRAMBase(). (i.e. 0x20000000 when all Ids are an address in this RAM)
+#define SEGGER_SYSVIEW_ID_SHIFT        0                                        // Number of bits to shift the Id to save bandwidth. (i.e. 2 when Ids are 4 byte aligned)
+
+/*********************************************************************
+*
+*       SystemView interrupt configuration
+*/
+#if SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM3
+  #define SEGGER_SYSVIEW_GET_INTERRUPT_ID()   ((*(U32 *)(0xE000ED04)) & 0x1FF)  // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[8:0] = active vector)
+#elif SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM0
+  #if defined(__ICCARM__)
+    #define SEGGER_SYSVIEW_GET_INTERRUPT_ID()   (__get_IPSR())                  // Workaround for IAR, which might do a byte-access to 0xE000ED04. Read IPSR instead.
+  #else
+    #define SEGGER_SYSVIEW_GET_INTERRUPT_ID()   ((*(U32 *)(0xE000ED04)) & 0x3F) // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[5:0] = active vector)
+  #endif
+#else
+  #define SEGGER_SYSVIEW_GET_INTERRUPT_ID()   SEGGER_SYSVIEW_X_GetInterruptId() // Get the currently active interrupt Id from the user-provided function.
+#endif
+
+void SEGGER_SYSVIEW_X_SysView_Lock();
+void SEGGER_SYSVIEW_X_SysView_Unlock();
+#define SEGGER_SYSVIEW_LOCK()   SEGGER_SYSVIEW_X_SysView_Lock()
+#define SEGGER_SYSVIEW_UNLOCK() SEGGER_SYSVIEW_X_SysView_Unlock()
+
+#endif  // SEGGER_SYSVIEW_CONF_H
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/SEGGER/SEGGER.h

@@ -0,0 +1,155 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+----------------------------------------------------------------------
+File    : SEGGER.h
+Purpose : Global types etc & general purpose utility functions
+---------------------------END-OF-HEADER------------------------------
+*/
+
+#ifndef SEGGER_H            // Guard against multiple inclusion
+#define SEGGER_H
+
+#include "Global.h"         // Type definitions: U8, U16, U32, I8, I16, I32
+
+#if defined(__cplusplus)
+extern "C" {     /* Make sure we have C-declarations in C++ programs */
+#endif
+
+/*********************************************************************
+*
+*       Keywords/specifiers
+*
+**********************************************************************
+*/
+
+#ifndef INLINE
+  #ifdef _WIN32
+    //
+    // Microsoft VC6 and newer.
+    // Force inlining without cost checking.
+    //
+    #define INLINE  __forceinline
+  #else
+    #if (defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__) || defined(__RX) || defined(__ICCRX__))
+      //
+      // Other known compilers.
+      //
+      #define INLINE  inline
+    #else
+      //
+      // Unknown compilers.
+      //
+      #define INLINE
+    #endif
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       Function-like macros
+*
+**********************************************************************
+*/
+
+#define SEGGER_COUNTOF(a)          (sizeof((a))/sizeof((a)[0]))
+#define SEGGER_MIN(a,b)            (((a) < (b)) ? (a) : (b))
+#define SEGGER_MAX(a,b)            (((a) > (b)) ? (a) : (b))
+
+/*********************************************************************
+*
+*       Types
+*
+**********************************************************************
+*/
+
+typedef struct {
+  char *pBuffer;
+  int   BufferSize;
+  int   Cnt;
+} SEGGER_BUFFER_DESC;
+
+typedef struct {
+  int  CacheLineSize;                                // 0: No Cache. Most Systems such as ARM9 use a 32 bytes cache line size.
+  void (*pfDMB)       (void);                        // Optional DMB function for Data Memory Barrier to make sure all memory operations are completed.
+  void (*pfClean)     (void *p, unsigned NumBytes);  // Optional clean function for cached memory.
+  void (*pfInvalidate)(void *p, unsigned NumBytes);  // Optional invalidate function for cached memory.
+} SEGGER_CACHE_CONFIG;
+
+/*********************************************************************
+*
+*       Utility functions
+*
+**********************************************************************
+*/
+
+void SEGGER_ARM_memcpy   (void *pDest, const void *pSrc, int NumBytes);
+void SEGGER_memcpy       (void *pDest, const void *pSrc, int NumBytes);
+void SEGGER_memxor       (void *pDest, const void *pSrc, unsigned NumBytes);
+void SEGGER_StoreChar    (SEGGER_BUFFER_DESC *p, char c);
+void SEGGER_PrintUnsigned(SEGGER_BUFFER_DESC *pBufferDesc, U32 v, unsigned Base, int NumDigits);
+void SEGGER_PrintInt     (SEGGER_BUFFER_DESC *pBufferDesc, I32 v, unsigned Base, unsigned NumDigits);
+int  SEGGER_snprintf     (char *pBuffer, int BufferSize, const char *sFormat, ...);
+
+
+#if defined(__cplusplus)
+}                /* Make sure we have C-declarations in C++ programs */
+#endif
+
+#endif                      // Avoid multiple inclusion
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/SEGGER/SEGGER_RTT.h

@@ -0,0 +1,251 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+---------------------------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: 5626 $
+----------------------------------------------------------------------
+*/
+
+#ifndef SEGGER_RTT_H
+#define SEGGER_RTT_H
+
+#include "SEGGER_RTT_Conf.h"
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+
+/*********************************************************************
+*
+*       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
+} 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
+} 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
+} 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);
+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_WriteString             (unsigned BufferIndex, const char* s);
+void         SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+void         SEGGER_RTT_ESP32_FlushNoLock       (unsigned long min_sz, unsigned long tmo);
+//
+// Function macro for performance optimization
+//
+// @AGv: This macro is used inside SEGGER SystemView code.
+// For ESP32 we use our own implementation of RTT, so this macro should not check SEGGER's RTT buffer state.
+#define      SEGGER_RTT_HASDATA(n)       (1)
+
+/*********************************************************************
+*
+*       RTT "Terminal" API functions
+*
+**********************************************************************
+*/
+int     SEGGER_RTT_SetTerminal        (char TerminalId);
+int     SEGGER_RTT_TerminalOut        (char TerminalId, const char* s);
+
+/*********************************************************************
+*
+*       RTT printf functions (require SEGGER_RTT_printf.c)
+*
+**********************************************************************
+*/
+int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...);
+#ifdef __cplusplus
+  }
+#endif
+
+/*********************************************************************
+*
+*       Defines
+*
+**********************************************************************
+*/
+
+//
+// Operating modes. Define behavior if buffer is full (not enough space for entire message)
+//
+#define SEGGER_RTT_MODE_NO_BLOCK_SKIP         (0U)     // Skip. Do not block, output nothing. (Default)
+#define SEGGER_RTT_MODE_NO_BLOCK_TRIM         (1U)     // Trim: Do not block, output as much as fits.
+#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL    (2U)     // Block: Wait until there is space in the buffer.
+#define SEGGER_RTT_MODE_MASK                  (3U)
+
+//
+// Control sequences, based on ANSI.
+// Can be used to control color, and clear the screen
+//
+#define RTT_CTRL_RESET                ""         // Reset to default colors
+#define RTT_CTRL_CLEAR                ""         // Clear screen, reposition cursor to top left
+
+#define RTT_CTRL_TEXT_BLACK           ""
+#define RTT_CTRL_TEXT_RED             ""
+#define RTT_CTRL_TEXT_GREEN           ""
+#define RTT_CTRL_TEXT_YELLOW          ""
+#define RTT_CTRL_TEXT_BLUE            ""
+#define RTT_CTRL_TEXT_MAGENTA         ""
+#define RTT_CTRL_TEXT_CYAN            ""
+#define RTT_CTRL_TEXT_WHITE           ""
+
+#define RTT_CTRL_TEXT_BRIGHT_BLACK    ""
+#define RTT_CTRL_TEXT_BRIGHT_RED      ""
+#define RTT_CTRL_TEXT_BRIGHT_GREEN    ""
+#define RTT_CTRL_TEXT_BRIGHT_YELLOW   ""
+#define RTT_CTRL_TEXT_BRIGHT_BLUE     ""
+#define RTT_CTRL_TEXT_BRIGHT_MAGENTA  ""
+#define RTT_CTRL_TEXT_BRIGHT_CYAN     ""
+#define RTT_CTRL_TEXT_BRIGHT_WHITE    ""
+
+#define RTT_CTRL_BG_BLACK             ""
+#define RTT_CTRL_BG_RED               ""
+#define RTT_CTRL_BG_GREEN             ""
+#define RTT_CTRL_BG_YELLOW            ""
+#define RTT_CTRL_BG_BLUE              ""
+#define RTT_CTRL_BG_MAGENTA           ""
+#define RTT_CTRL_BG_CYAN              ""
+#define RTT_CTRL_BG_WHITE             ""
+
+#define RTT_CTRL_BG_BRIGHT_BLACK      ""
+#define RTT_CTRL_BG_BRIGHT_RED        ""
+#define RTT_CTRL_BG_BRIGHT_GREEN      ""
+#define RTT_CTRL_BG_BRIGHT_YELLOW     ""
+#define RTT_CTRL_BG_BRIGHT_BLUE       ""
+#define RTT_CTRL_BG_BRIGHT_MAGENTA    ""
+#define RTT_CTRL_BG_BRIGHT_CYAN       ""
+#define RTT_CTRL_BG_BRIGHT_WHITE      ""
+
+
+#endif
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/SEGGER/SEGGER_SYSVIEW.h

@@ -0,0 +1,334 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+File    : SEGGER_SYSVIEW.h
+Purpose : System visualization API.
+Revision: $Rev: 5626 $
+*/
+
+#ifndef SEGGER_SYSVIEW_H
+#define SEGGER_SYSVIEW_H
+
+/*********************************************************************
+*
+*       #include Section
+*
+**********************************************************************
+*/
+
+#include "SEGGER.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+
+#define SEGGER_SYSVIEW_VERSION        21000
+
+#define SEGGER_SYSVIEW_INFO_SIZE      9   // Minimum size, which has to be reserved for a packet. 1-2 byte of message type, 0-2  byte of payload length, 1-5 bytes of timestamp.
+#define SEGGER_SYSVIEW_QUANTA_U32     5   // Maximum number of bytes to encode a U32, should be reserved for each 32-bit value in a packet.
+
+#define SEGGER_SYSVIEW_LOG            (0u)
+#define SEGGER_SYSVIEW_WARNING        (1u)
+#define SEGGER_SYSVIEW_ERROR          (2u)
+#define SEGGER_SYSVIEW_FLAG_APPEND    (1u << 6)
+
+#define SEGGER_SYSVIEW_PREPARE_PACKET(p)  (p) + 4
+//
+// SystemView events. First 32 IDs from 0 .. 31 are reserved for these
+//
+#define   SYSVIEW_EVTID_NOP                0  // Dummy packet.
+#define   SYSVIEW_EVTID_OVERFLOW           1
+#define   SYSVIEW_EVTID_ISR_ENTER          2
+#define   SYSVIEW_EVTID_ISR_EXIT           3
+#define   SYSVIEW_EVTID_TASK_START_EXEC    4
+#define   SYSVIEW_EVTID_TASK_STOP_EXEC     5
+#define   SYSVIEW_EVTID_TASK_START_READY   6
+#define   SYSVIEW_EVTID_TASK_STOP_READY    7
+#define   SYSVIEW_EVTID_TASK_CREATE        8
+#define   SYSVIEW_EVTID_TASK_INFO          9
+#define   SYSVIEW_EVTID_TRACE_START       10
+#define   SYSVIEW_EVTID_TRACE_STOP        11
+#define   SYSVIEW_EVTID_SYSTIME_CYCLES    12
+#define   SYSVIEW_EVTID_SYSTIME_US        13
+#define   SYSVIEW_EVTID_SYSDESC           14
+#define   SYSVIEW_EVTID_USER_START        15
+#define   SYSVIEW_EVTID_USER_STOP         16
+#define   SYSVIEW_EVTID_IDLE              17
+#define   SYSVIEW_EVTID_ISR_TO_SCHEDULER  18
+#define   SYSVIEW_EVTID_TIMER_ENTER       19
+#define   SYSVIEW_EVTID_TIMER_EXIT        20
+#define   SYSVIEW_EVTID_STACK_INFO        21
+#define   SYSVIEW_EVTID_MODULEDESC        22
+
+#define   SYSVIEW_EVTID_INIT              24
+#define   SYSVIEW_EVTID_NAME_RESOURCE     25
+#define   SYSVIEW_EVTID_PRINT_FORMATTED   26
+#define   SYSVIEW_EVTID_NUMMODULES        27
+#define   SYSVIEW_EVTID_END_CALL          28
+#define   SYSVIEW_EVTID_TASK_TERMINATE    29
+
+#define   SYSVIEW_EVTID_EX                31
+//
+// Event masks to disable/enable events
+//
+#define   SYSVIEW_EVTMASK_NOP               (1 << SYSVIEW_EVTID_NOP)
+#define   SYSVIEW_EVTMASK_OVERFLOW          (1 << SYSVIEW_EVTID_OVERFLOW)
+#define   SYSVIEW_EVTMASK_ISR_ENTER         (1 << SYSVIEW_EVTID_ISR_ENTER)
+#define   SYSVIEW_EVTMASK_ISR_EXIT          (1 << SYSVIEW_EVTID_ISR_EXIT)
+#define   SYSVIEW_EVTMASK_TASK_START_EXEC   (1 << SYSVIEW_EVTID_TASK_START_EXEC)
+#define   SYSVIEW_EVTMASK_TASK_STOP_EXEC    (1 << SYSVIEW_EVTID_TASK_STOP_EXEC)
+#define   SYSVIEW_EVTMASK_TASK_START_READY  (1 << SYSVIEW_EVTID_TASK_START_READY)
+#define   SYSVIEW_EVTMASK_TASK_STOP_READY   (1 << SYSVIEW_EVTID_TASK_STOP_READY)
+#define   SYSVIEW_EVTMASK_TASK_CREATE       (1 << SYSVIEW_EVTID_TASK_CREATE)
+#define   SYSVIEW_EVTMASK_TASK_INFO         (1 << SYSVIEW_EVTID_TASK_INFO)
+#define   SYSVIEW_EVTMASK_TRACE_START       (1 << SYSVIEW_EVTID_TRACE_START)
+#define   SYSVIEW_EVTMASK_TRACE_STOP        (1 << SYSVIEW_EVTID_TRACE_STOP)
+#define   SYSVIEW_EVTMASK_SYSTIME_CYCLES    (1 << SYSVIEW_EVTID_SYSTIME_CYCLES)
+#define   SYSVIEW_EVTMASK_SYSTIME_US        (1 << SYSVIEW_EVTID_SYSTIME_US)
+#define   SYSVIEW_EVTMASK_SYSDESC           (1 << SYSVIEW_EVTID_SYSDESC)
+#define   SYSVIEW_EVTMASK_USER_START        (1 << SYSVIEW_EVTID_USER_START)
+#define   SYSVIEW_EVTMASK_USER_STOP         (1 << SYSVIEW_EVTID_USER_STOP)
+#define   SYSVIEW_EVTMASK_IDLE              (1 << SYSVIEW_EVTID_IDLE)
+#define   SYSVIEW_EVTMASK_ISR_TO_SCHEDULER  (1 << SYSVIEW_EVTID_ISR_TO_SCHEDULER)
+#define   SYSVIEW_EVTMASK_TIMER_ENTER       (1 << SYSVIEW_EVTID_TIMER_ENTER)
+#define   SYSVIEW_EVTMASK_TIMER_EXIT        (1 << SYSVIEW_EVTID_TIMER_EXIT)
+#define   SYSVIEW_EVTMASK_STACK_INFO        (1 << SYSVIEW_EVTID_STACK_INFO)
+#define   SYSVIEW_EVTMASK_MODULEDESC        (1 << SYSVIEW_EVTID_MODULEDESC)
+
+#define   SYSVIEW_EVTMASK_INIT              (1 << SYSVIEW_EVTID_INIT)
+#define   SYSVIEW_EVTMASK_NAME_RESOURCE     (1 << SYSVIEW_EVTID_NAME_RESOURCE)
+#define   SYSVIEW_EVTMASK_PRINT_FORMATTED   (1 << SYSVIEW_EVTID_PRINT_FORMATTED)
+#define   SYSVIEW_EVTMASK_NUMMODULES        (1 << SYSVIEW_EVTID_NUMMODULES)
+#define   SYSVIEW_EVTMASK_END_CALL          (1 << SYSVIEW_EVTID_END_CALL)
+#define   SYSVIEW_EVTMASK_TASK_TERMINATE    (1 << SYSVIEW_EVTID_TASK_TERMINATE)
+
+#define   SYSVIEW_EVTMASK_EX                (1 << SYSVIEW_EVTID_EX)
+
+#define   SYSVIEW_EVTMASK_ALL_INTERRUPTS    ( SYSVIEW_EVTMASK_ISR_ENTER           \
+                                            | SYSVIEW_EVTMASK_ISR_EXIT            \
+                                            | SYSVIEW_EVTMASK_ISR_TO_SCHEDULER)
+#define   SYSVIEW_EVTMASK_ALL_TASKS         ( SYSVIEW_EVTMASK_TASK_START_EXEC     \
+                                            | SYSVIEW_EVTMASK_TASK_STOP_EXEC      \
+                                            | SYSVIEW_EVTMASK_TASK_START_READY    \
+                                            | SYSVIEW_EVTMASK_TASK_STOP_READY     \
+                                            | SYSVIEW_EVTMASK_TASK_CREATE         \
+                                            | SYSVIEW_EVTMASK_TASK_INFO           \
+                                            | SYSVIEW_EVTMASK_STACK_INFO          \
+                                            | SYSVIEW_EVTMASK_TASK_TERMINATE)
+
+/*********************************************************************
+*
+*       Structures
+*
+**********************************************************************
+*/
+
+typedef struct {
+  U32          TaskID;
+  const char*  sName;
+  U32          Prio;
+  U32          StackBase;
+  U32          StackSize;
+} SEGGER_SYSVIEW_TASKINFO;
+
+typedef struct SEGGER_SYSVIEW_MODULE_STRUCT SEGGER_SYSVIEW_MODULE;
+
+struct SEGGER_SYSVIEW_MODULE_STRUCT {
+  const char*                   sModule;
+        U32                     NumEvents;
+        U32                     EventOffset;
+        void                    (*pfSendModuleDesc)(void);
+        SEGGER_SYSVIEW_MODULE*  pNext;
+};
+
+typedef void (SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC)(void);
+
+/*********************************************************************
+*
+*       API functions
+*
+**********************************************************************
+*/
+
+typedef struct {
+  U64  (*pfGetTime)      (void);
+  void (*pfSendTaskList) (void);
+} SEGGER_SYSVIEW_OS_API;
+
+/*********************************************************************
+*
+*       Control and initialization functions
+*/
+void SEGGER_SYSVIEW_Init                          (U32 SysFreq, U32 CPUFreq, const SEGGER_SYSVIEW_OS_API *pOSAPI, SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC pfSendSysDesc);
+void SEGGER_SYSVIEW_SetRAMBase                    (U32 RAMBaseAddress);
+void SEGGER_SYSVIEW_Start                         (void);
+void SEGGER_SYSVIEW_Stop                          (void);
+void SEGGER_SYSVIEW_GetSysDesc                    (void);
+void SEGGER_SYSVIEW_SendTaskList                  (void);
+void SEGGER_SYSVIEW_SendTaskInfo                  (const SEGGER_SYSVIEW_TASKINFO* pInfo);
+void SEGGER_SYSVIEW_SendSysDesc                   (const char* sSysDesc);
+
+/*********************************************************************
+*
+*       Event recording functions
+*/
+void SEGGER_SYSVIEW_RecordVoid                    (unsigned int EventId);
+void SEGGER_SYSVIEW_RecordU32                     (unsigned int EventId, U32 Para0);
+void SEGGER_SYSVIEW_RecordU32x2                   (unsigned int EventId, U32 Para0, U32 Para1);
+void SEGGER_SYSVIEW_RecordU32x3                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2);
+void SEGGER_SYSVIEW_RecordU32x4                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3);
+void SEGGER_SYSVIEW_RecordU32x5                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4);
+void SEGGER_SYSVIEW_RecordU32x6                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5);
+void SEGGER_SYSVIEW_RecordU32x7                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6);
+void SEGGER_SYSVIEW_RecordU32x8                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7);
+void SEGGER_SYSVIEW_RecordU32x9                   (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8);
+void SEGGER_SYSVIEW_RecordU32x10                  (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8, U32 Para9);
+void SEGGER_SYSVIEW_RecordString                  (unsigned int EventId, const char* pString);
+void SEGGER_SYSVIEW_RecordSystime                 (void);
+void SEGGER_SYSVIEW_RecordEnterISR                (U32 IrqId);
+void SEGGER_SYSVIEW_RecordExitISR                 (void);
+void SEGGER_SYSVIEW_RecordExitISRToScheduler      (void);
+void SEGGER_SYSVIEW_RecordEnterTimer              (U32 TimerId);
+void SEGGER_SYSVIEW_RecordExitTimer               (void);
+void SEGGER_SYSVIEW_RecordEndCall                 (unsigned int EventID);
+void SEGGER_SYSVIEW_RecordEndCallU32              (unsigned int EventID, U32 Para0);
+
+void SEGGER_SYSVIEW_OnIdle                        (void);
+void SEGGER_SYSVIEW_OnTaskCreate                  (U32 TaskId);
+void SEGGER_SYSVIEW_OnTaskTerminate               (U32 TaskId);
+void SEGGER_SYSVIEW_OnTaskStartExec               (U32 TaskId);
+void SEGGER_SYSVIEW_OnTaskStopExec                (void);
+void SEGGER_SYSVIEW_OnTaskStartReady              (U32 TaskId);
+void SEGGER_SYSVIEW_OnTaskStopReady               (U32 TaskId, unsigned int Cause);
+void SEGGER_SYSVIEW_OnUserStart                   (unsigned int UserId);       // Start of user defined event (such as a subroutine to profile)
+void SEGGER_SYSVIEW_OnUserStop                    (unsigned int UserId);       // Start of user defined event
+
+void SEGGER_SYSVIEW_NameResource                  (U32 ResourceId, const char* sName);
+
+int  SEGGER_SYSVIEW_SendPacket                    (U8* pPacket, U8* pPayloadEnd, unsigned int EventId);
+
+/*********************************************************************
+*
+*       Event parameter encoding functions
+*/
+U8*  SEGGER_SYSVIEW_EncodeU32                     (U8* pPayload, U32 Value);
+U8*  SEGGER_SYSVIEW_EncodeData                    (U8* pPayload, const char* pSrc, unsigned int Len);
+U8*  SEGGER_SYSVIEW_EncodeString                  (U8* pPayload, const char* s, unsigned int MaxLen);
+U8*  SEGGER_SYSVIEW_EncodeId                      (U8* pPayload, U32 Id);
+U32  SEGGER_SYSVIEW_ShrinkId                      (U32 Id);
+
+
+/*********************************************************************
+*
+*       Middleware module registration
+*/
+void SEGGER_SYSVIEW_RegisterModule                (SEGGER_SYSVIEW_MODULE* pModule);
+void SEGGER_SYSVIEW_RecordModuleDescription       (const SEGGER_SYSVIEW_MODULE* pModule, const char* sDescription);
+void SEGGER_SYSVIEW_SendModule                    (U8 ModuleId);
+void SEGGER_SYSVIEW_SendModuleDescription         (void);
+void SEGGER_SYSVIEW_SendNumModules                (void);
+
+/*********************************************************************
+*
+*       printf-Style functions
+*/
+#ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list
+void SEGGER_SYSVIEW_PrintfHostEx                  (const char* s, U32 Options, ...);
+void SEGGER_SYSVIEW_PrintfTargetEx                (const char* s, U32 Options, ...);
+void SEGGER_SYSVIEW_PrintfHost                    (const char* s, ...);
+void SEGGER_SYSVIEW_PrintfTarget                  (const char* s, ...);
+void SEGGER_SYSVIEW_WarnfHost                     (const char* s, ...);
+void SEGGER_SYSVIEW_WarnfTarget                   (const char* s, ...);
+void SEGGER_SYSVIEW_ErrorfHost                    (const char* s, ...);
+void SEGGER_SYSVIEW_ErrorfTarget                  (const char* s, ...);
+#endif
+
+void SEGGER_SYSVIEW_Print                         (const char* s);
+void SEGGER_SYSVIEW_Warn                          (const char* s);
+void SEGGER_SYSVIEW_Error                         (const char* s);
+
+/*********************************************************************
+*
+*       Run-time configuration functions
+*/
+void SEGGER_SYSVIEW_EnableEvents                  (U32 EnableMask);
+void SEGGER_SYSVIEW_DisableEvents                 (U32 DisableMask);
+
+/*********************************************************************
+*
+*       Application-provided functions
+*/
+void SEGGER_SYSVIEW_Conf                          (void);
+U32  SEGGER_SYSVIEW_X_GetTimestamp                (void);
+U32  SEGGER_SYSVIEW_X_GetInterruptId              (void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/SEGGER/SEGGER_SYSVIEW_ConfDefaults.h

@@ -0,0 +1,178 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+File    : SEGGER_SYSVIEW_ConfDefaults.h
+Purpose : Defines defaults for configurable defines used in
+          SEGGER SystemView.
+Revision: $Rev: 3734 $
+*/
+
+#ifndef SEGGER_SYSVIEW_CONFDEFAULTS_H
+#define SEGGER_SYSVIEW_CONFDEFAULTS_H
+
+/*********************************************************************
+*
+*       #include Section
+*
+**********************************************************************
+*/
+
+#include "SEGGER_SYSVIEW_Conf.h"
+#include "SEGGER_RTT_Conf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************************************************************
+*
+*       Configuration defaults
+*
+**********************************************************************
+*/
+
+// Number of bytes that SystemView uses for a buffer.
+#ifndef   SEGGER_SYSVIEW_RTT_BUFFER_SIZE
+  #define SEGGER_SYSVIEW_RTT_BUFFER_SIZE    1024
+#endif
+
+// The RTT channel that SystemView will use.
+#ifndef   SEGGER_SYSVIEW_RTT_CHANNEL
+  #define SEGGER_SYSVIEW_RTT_CHANNEL        0
+#endif
+// Sanity check of RTT channel
+#if (SEGGER_SYSVIEW_RTT_CHANNEL == 0) && (SEGGER_RTT_MAX_NUM_UP_BUFFERS < 2)
+  #error "SEGGER_RTT_MAX_NUM_UP_BUFFERS in SEGGER_RTT_Conf.h has to be > 1!"
+#elif (SEGGER_SYSVIEW_RTT_CHANNEL >= SEGGER_RTT_MAX_NUM_UP_BUFFERS)
+  #error "SEGGER_RTT_MAX_NUM_UP_BUFFERS  in SEGGER_RTT_Conf.h has to be > SEGGER_SYSVIEW_RTT_CHANNEL!"
+#endif
+
+// Place the SystemView buffer into its own/the RTT section
+#if !(defined SEGGER_SYSVIEW_BUFFER_SECTION) && (defined SEGGER_RTT_SECTION)
+  #define SEGGER_SYSVIEW_BUFFER_SECTION            SEGGER_RTT_SECTION
+#endif
+
+// Retrieve a system timestamp.  This gets the Cortex-M cycle counter.
+#ifndef   SEGGER_SYSVIEW_GET_TIMESTAMP
+  #error "SEGGER_SYSVIEW_GET_TIMESTAMP has to be defined in SEGGER_SYSVIEW_Conf.h!"
+#endif
+
+// Define number of valid bits low-order delivered by clock source.
+#ifndef   SEGGER_SYSVIEW_TIMESTAMP_BITS
+  #define SEGGER_SYSVIEW_TIMESTAMP_BITS     32
+#endif
+
+// Lowest Id reported by the Application.
+#ifndef   SEGGER_SYSVIEW_ID_BASE 
+  #define SEGGER_SYSVIEW_ID_BASE            0
+#endif
+
+// Number of bits to shift Ids to save bandwidth
+#ifndef   SEGGER_SYSVIEW_ID_SHIFT
+  #define SEGGER_SYSVIEW_ID_SHIFT           0
+#endif
+
+#ifndef   SEGGER_SYSVIEW_GET_INTERRUPT_ID
+  #error "SEGGER_SYSVIEW_GET_INTERRUPT_ID has to be defined in SEGGER_SYSVIEW_Conf.h!"
+#endif
+
+#ifndef   SEGGER_SYSVIEW_MAX_ARGUMENTS
+  #define SEGGER_SYSVIEW_MAX_ARGUMENTS      16
+#endif
+
+#ifndef   SEGGER_SYSVIEW_MAX_STRING_LEN
+  #define SEGGER_SYSVIEW_MAX_STRING_LEN     128
+#endif
+
+// Use a static buffer instead of a buffer on the stack for packets
+#ifndef   SEGGER_SYSVIEW_USE_STATIC_BUFFER
+  #define SEGGER_SYSVIEW_USE_STATIC_BUFFER  1
+#endif
+
+// Maximum packet size used by SystemView for the static buffer
+#ifndef   SEGGER_SYSVIEW_MAX_PACKET_SIZE
+  #define SEGGER_SYSVIEW_MAX_PACKET_SIZE   SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_MAX_STRING_LEN + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_ARGUMENTS * SEGGER_SYSVIEW_QUANTA_U32
+#endif
+
+// Use post-mortem analysis instead of real-time analysis
+#ifndef   SEGGER_SYSVIEW_POST_MORTEM_MODE
+  #define SEGGER_SYSVIEW_POST_MORTEM_MODE   0
+#endif
+
+// Configure how frequently syncronization is sent
+#ifndef   SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT
+  #define SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT  8
+#endif
+
+// Lock SystemView (nestable)
+#ifndef   SEGGER_SYSVIEW_LOCK
+  #define SEGGER_SYSVIEW_LOCK()             SEGGER_RTT_LOCK()
+#endif
+
+// Unlock SystemView (nestable)
+#ifndef   SEGGER_SYSVIEW_UNLOCK
+  #define SEGGER_SYSVIEW_UNLOCK()           SEGGER_RTT_UNLOCK()
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/SEGGER/SEGGER_SYSVIEW_Int.h

@@ -0,0 +1,110 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+File    : SEGGER_SYSVIEW_Int.h
+Purpose : SEGGER SystemView internal header.
+Revision: $Rev: 5626 $
+*/
+
+#ifndef SEGGER_SYSVIEW_INT_H
+#define SEGGER_SYSVIEW_INT_H
+
+/*********************************************************************
+*
+*       #include Section
+*
+**********************************************************************
+*/
+
+#include "SEGGER_SYSVIEW.h"
+#include "SEGGER_SYSVIEW_Conf.h"
+#include "SEGGER_SYSVIEW_ConfDefaults.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*********************************************************************
+*
+*       Private data types
+*
+**********************************************************************
+*/
+//
+// Commands that Host can send to target
+//
+typedef enum {
+  SEGGER_SYSVIEW_COMMAND_ID_START = 1,
+  SEGGER_SYSVIEW_COMMAND_ID_STOP,
+  SEGGER_SYSVIEW_COMMAND_ID_GET_SYSTIME,
+  SEGGER_SYSVIEW_COMMAND_ID_GET_TASKLIST,
+  SEGGER_SYSVIEW_COMMAND_ID_GET_SYSDESC,
+  SEGGER_SYSVIEW_COMMAND_ID_GET_NUMMODULES,
+  SEGGER_SYSVIEW_COMMAND_ID_GET_MODULEDESC,
+  // Extended commands: Commands >= 128 have a second parameter
+  SEGGER_SYSVIEW_COMMAND_ID_GET_MODULE = 128
+} SEGGER_SYSVIEW_COMMAND_ID;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/Sample/Config/SEGGER_SYSVIEW_Config_FreeRTOS.c

@@ -0,0 +1,333 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+
+File    : SEGGER_SYSVIEW_Config_FreeRTOS.c
+Purpose : Sample setup configuration of SystemView with FreeRTOS.
+Revision: $Rev: 3734 $
+*/
+#include "freertos/FreeRTOS.h"
+#include "SEGGER_SYSVIEW.h"
+#include "rom/ets_sys.h"
+#if CONFIG_FREERTOS_UNICORE == 0
+#include "driver/timer.h"
+#endif
+#include "esp_app_trace.h"
+#include "esp_app_trace_util.h"
+#include "esp_intr_alloc.h"
+
+extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI;
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+// The application name to be displayed in SystemViewer
+#define SYSVIEW_APP_NAME        "FreeRTOS Application"
+
+// The target device name
+#define SYSVIEW_DEVICE_NAME     "ESP32"
+
+// Frequency of the timestamp.
+#if CONFIG_FREERTOS_UNICORE == 0
+#define SYSVIEW_TIMESTAMP_FREQ  (TIMER_BASE_CLK/2)
+#else
+#define SYSVIEW_TIMESTAMP_FREQ  (XT_CLOCK_FREQ)
+#endif
+// System Frequency.
+#define SYSVIEW_CPU_FREQ        (XT_CLOCK_FREQ)
+
+// The lowest RAM address used for IDs (pointers)
+#define SYSVIEW_RAM_BASE        (0x3F400000)
+
+#if CONFIG_FREERTOS_CORETIMER_0
+    #define SYSTICK_INTR_ID (ETS_INTERNAL_TIMER0_INTR_SOURCE+ETS_INTERNAL_INTR_SOURCE_OFF)
+#endif
+#if CONFIG_FREERTOS_CORETIMER_1
+    #define SYSTICK_INTR_ID (ETS_INTERNAL_TIMER1_INTR_SOURCE+ETS_INTERNAL_INTR_SOURCE_OFF)
+#endif
+
+#if CONFIG_FREERTOS_UNICORE == 0
+static timer_idx_t s_ts_timer_idx;
+static timer_group_t s_ts_timer_group;
+#endif
+
+// SystemView is single core specific: it implies that SEGGER_SYSVIEW_LOCK()
+// disables IRQs (disables rescheduling globaly). So we can not use finite timeouts for locks and return error
+// in case of expiration, because error will not be handled and SEGGER's code will go further implying that
+// everything is fine, so for multi-core env we have to wait on underlying lock forever
+#define SEGGER_LOCK_WAIT_TMO  ESP_APPTRACE_TMO_INFINITE
+
+static esp_apptrace_lock_t s_sys_view_lock = {.irq_stat = 0, .portmux = portMUX_INITIALIZER_UNLOCKED};
+
+static const char * const s_isr_names[] = {
+    [0] = "WIFI_MAC",
+    [1] = "WIFI_NMI",
+    [2] = "WIFI_BB",
+    [3] = "BT_MAC",
+    [4] = "BT_BB",
+    [5] = "BT_BB_NMI",
+    [6] = "RWBT",
+    [7] = "RWBLE",
+    [8] = "RWBT_NMI",
+    [9] = "RWBLE_NMI",
+    [10] = "SLC0",
+    [11] = "SLC1",
+    [12] = "UHCI0",
+    [13] = "UHCI1",
+    [14] = "TG0_T0_LEVEL",
+    [15] = "TG0_T1_LEVEL",
+    [16] = "TG0_WDT_LEVEL",
+    [17] = "TG0_LACT_LEVEL",
+    [18] = "TG1_T0_LEVEL",
+    [19] = "TG1_T1_LEVEL",
+    [20] = "TG1_WDT_LEVEL",
+    [21] = "TG1_LACT_LEVEL",
+    [22] = "GPIO",
+    [23] = "GPIO_NMI",
+    [24] = "FROM_CPU0",
+    [25] = "FROM_CPU1",
+    [26] = "FROM_CPU2",
+    [27] = "FROM_CPU3",
+    [28] = "SPI0",
+    [29] = "SPI1",
+    [30] = "SPI2",
+    [31] = "SPI3",
+    [32] = "I2S0",
+    [33] = "I2S1",
+    [34] = "UART0",
+    [35] = "UART1",
+    [36] = "UART2",
+    [37] = "SDIO_HOST",
+    [38] = "ETH_MAC",
+    [39] = "PWM0",
+    [40] = "PWM1",
+    [41] = "PWM2",
+    [42] = "PWM3",
+    [43] = "LEDC",
+    [44] = "EFUSE",
+    [45] = "CAN",
+    [46] = "RTC_CORE",
+    [47] = "RMT",
+    [48] = "PCNT",
+    [49] = "I2C_EXT0",
+    [50] = "I2C_EXT1",
+    [51] = "RSA",
+    [52] = "SPI1_DMA",
+    [53] = "SPI2_DMA",
+    [54] = "SPI3_DMA",
+    [55] = "WDT",
+    [56] = "TIMER1",
+    [57] = "TIMER2",
+    [58] = "TG0_T0_EDGE",
+    [59] = "TG0_T1_EDGE",
+    [60] = "TG0_WDT_EDGE",
+    [61] = "TG0_LACT_EDGE",
+    [62] = "TG1_T0_EDGE",
+    [63] = "TG1_T1_EDGE",
+    [64] = "TG1_WDT_EDGE",
+    [65] = "TG1_LACT_EDGE",
+    [66] = "MMU_IA",
+    [67] = "MPU_IA",
+    [68] = "CACHE_IA",
+};
+
+/*********************************************************************
+*
+*       _cbSendSystemDesc()
+*
+*  Function description
+*    Sends SystemView description strings.
+*/
+static void _cbSendSystemDesc(void) {
+    char irq_str[32];
+    SEGGER_SYSVIEW_SendSysDesc("N="SYSVIEW_APP_NAME",D="SYSVIEW_DEVICE_NAME",C=Xtensa,O=FreeRTOS");
+    snprintf(irq_str, sizeof(irq_str), "I#%d=SysTick", SYSTICK_INTR_ID);
+    SEGGER_SYSVIEW_SendSysDesc(irq_str);
+    size_t isr_count = sizeof(s_isr_names)/sizeof(s_isr_names[0]);
+    for (size_t i = 0; i < isr_count; ++i) {
+        snprintf(irq_str, sizeof(irq_str), "I#%d=%s", ETS_INTERNAL_INTR_SOURCE_OFF + i, s_isr_names[i]);
+        SEGGER_SYSVIEW_SendSysDesc(irq_str);
+    }
+}
+
+/*********************************************************************
+*
+*       Global functions
+*
+**********************************************************************
+*/
+#if CONFIG_FREERTOS_UNICORE == 0
+static void SEGGER_SYSVIEW_TS_Init()
+{
+    timer_config_t config;
+
+#if CONFIG_SYSVIEW_TS_SOURCE_TIMER_00
+    s_ts_timer_group = TIMER_GROUP_0;
+    s_ts_timer_idx = TIMER_0;
+#endif
+#if CONFIG_SYSVIEW_TS_SOURCE_TIMER_01
+    s_ts_timer_group = TIMER_GROUP_0;
+    s_ts_timer_idx = TIMER_1;
+#endif
+#if CONFIG_SYSVIEW_TS_SOURCE_TIMER_10
+    s_ts_timer_group = TIMER_GROUP_1;
+    s_ts_timer_idx = TIMER_0;
+#endif
+#if CONFIG_SYSVIEW_TS_SOURCE_TIMER_11
+    s_ts_timer_group = TIMER_GROUP_1;
+    s_ts_timer_idx = TIMER_1;
+#endif
+    config.alarm_en = 0;
+    config.auto_reload = 0;
+    config.counter_dir = TIMER_COUNT_UP;
+    config.divider = 2;
+    config.counter_en = 0;
+    /*Configure timer*/
+    timer_init(s_ts_timer_group, s_ts_timer_idx, &config);
+    /*Load counter value */
+    timer_set_counter_value(s_ts_timer_group, s_ts_timer_idx, 0x00000000ULL);
+    /*Enable timer interrupt*/
+    timer_start(s_ts_timer_group, s_ts_timer_idx);
+}
+#endif
+
+void SEGGER_SYSVIEW_Conf(void) {
+    U32 disable_evts = 0;
+
+#if CONFIG_FREERTOS_UNICORE == 0
+    SEGGER_SYSVIEW_TS_Init();
+#endif
+    SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ,
+                        &SYSVIEW_X_OS_TraceAPI, _cbSendSystemDesc);
+    SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE);
+
+#if !CONFIG_SYSVIEW_EVT_OVERFLOW_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_OVERFLOW;
+#endif
+#if !CONFIG_SYSVIEW_EVT_ISR_ENTER_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_ISR_ENTER;
+#endif
+#if !CONFIG_SYSVIEW_EVT_ISR_EXIT_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_ISR_EXIT;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_START_EXEC_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_START_EXEC;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_STOP_EXEC_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_STOP_EXEC;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_START_READY_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_START_READY;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_STOP_READY_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_STOP_READY;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_CREATE_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_CREATE;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TASK_TERMINATE_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TASK_TERMINATE;
+#endif
+#if !CONFIG_SYSVIEW_EVT_IDLE_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_IDLE;
+#endif
+#if !CONFIG_SYSVIEW_EVT_ISR_TO_SCHEDULER_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_ISR_TO_SCHEDULER;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TIMER_ENTER_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TIMER_ENTER;
+#endif
+#if !CONFIG_SYSVIEW_EVT_TIMER_EXIT_ENABLE
+    disable_evts |= SYSVIEW_EVTMASK_TIMER_EXIT;
+#endif
+  SEGGER_SYSVIEW_DisableEvents(disable_evts);
+}
+
+U32 SEGGER_SYSVIEW_X_GetTimestamp()
+{
+#if CONFIG_FREERTOS_UNICORE == 0
+    uint64_t ts = 0;
+    timer_get_counter_value(s_ts_timer_group, s_ts_timer_idx, &ts);
+    return (U32)ts; // return lower part of counter value
+#else
+    return portGET_RUN_TIME_COUNTER_VALUE();
+#endif
+}
+
+void SEGGER_SYSVIEW_X_RTT_Lock()
+{
+}
+
+void SEGGER_SYSVIEW_X_RTT_Unlock()
+{
+}
+
+void SEGGER_SYSVIEW_X_SysView_Lock()
+{
+    esp_apptrace_lock_take(&s_sys_view_lock, SEGGER_LOCK_WAIT_TMO);
+}
+
+void SEGGER_SYSVIEW_X_SysView_Unlock()
+{
+    esp_apptrace_lock_give(&s_sys_view_lock);
+}
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/Sample/OS/SEGGER_SYSVIEW_FreeRTOS.c

@@ -0,0 +1,290 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+
+File    : SEGGER_SYSVIEW_FreeRTOS.c
+Purpose : Interface between FreeRTOS and SystemView.
+Revision: $Rev: 3734 $
+*/
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "SEGGER_SYSVIEW.h"
+#include "SEGGER_SYSVIEW_FreeRTOS.h"
+#include "string.h" // Required for memset
+
+
+
+typedef struct SYSVIEW_FREERTOS_TASK_STATUS SYSVIEW_FREERTOS_TASK_STATUS;
+
+struct SYSVIEW_FREERTOS_TASK_STATUS {
+  U32         xHandle;
+  const char* pcTaskName;
+  unsigned    uxCurrentPriority;
+  U32         pxStack;
+  unsigned    uStackHighWaterMark;
+};
+
+static SYSVIEW_FREERTOS_TASK_STATUS _aTasks[SYSVIEW_FREERTOS_MAX_NOF_TASKS];
+
+/*********************************************************************
+*
+*       _cbSendTaskList()
+*
+*  Function description
+*    This function is part of the link between FreeRTOS and SYSVIEW.
+*    Called from SystemView when asked by the host, it uses SYSVIEW
+*    functions to send the entire task list to the host.
+*/
+static void _cbSendTaskList(void) {
+  unsigned n;
+
+  for (n = 0; n < SYSVIEW_FREERTOS_MAX_NOF_TASKS; n++) {
+    if (_aTasks[n].xHandle) {
+#if INCLUDE_uxTaskGetStackHighWaterMark // Report Task Stack High Watermark
+      _aTasks[n].uStackHighWaterMark = uxTaskGetStackHighWaterMark((TaskHandle_t)_aTasks[n].xHandle);
+#endif
+      SYSVIEW_SendTaskInfo((U32)_aTasks[n].xHandle, _aTasks[n].pcTaskName, (unsigned)_aTasks[n].uxCurrentPriority, (U32)_aTasks[n].pxStack, (unsigned)_aTasks[n].uStackHighWaterMark);
+    }
+  }
+}
+
+/*********************************************************************
+*
+*       _cbGetTime()
+*
+*  Function description
+*    This function is part of the link between FreeRTOS and SYSVIEW.
+*    Called from SystemView when asked by the host, returns the
+*    current system time in micro seconds.
+*/
+static U64 _cbGetTime(void) {
+  U64 Time;
+
+  Time = xTaskGetTickCountFromISR();
+  Time *= portTICK_PERIOD_MS;
+  Time *= 1000;
+  return Time;
+}
+
+/*********************************************************************
+*
+*       Global functions
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       SYSVIEW_AddTask()
+*
+*  Function description
+*    Add a task to the internal list and record its information.
+*/
+void SYSVIEW_AddTask(U32 xHandle, const char* pcTaskName, unsigned uxCurrentPriority, U32  pxStack, unsigned uStackHighWaterMark) {
+  unsigned n;
+  
+  if (memcmp(pcTaskName, "IDLE", 5) == 0) {
+    return;
+  }
+  
+  for (n = 0; n < SYSVIEW_FREERTOS_MAX_NOF_TASKS; n++) {
+    if (_aTasks[n].xHandle == 0) {
+      break;
+    }
+  }
+  if (n == SYSVIEW_FREERTOS_MAX_NOF_TASKS) {
+    SEGGER_SYSVIEW_Warn("SYSTEMVIEW: Could not record task information. Maximum number of tasks reached.");
+    return;
+  }
+
+  _aTasks[n].xHandle = xHandle;
+  _aTasks[n].pcTaskName = pcTaskName;
+  _aTasks[n].uxCurrentPriority = uxCurrentPriority;
+  _aTasks[n].pxStack = pxStack;
+  _aTasks[n].uStackHighWaterMark = uStackHighWaterMark;
+
+  SYSVIEW_SendTaskInfo(xHandle, pcTaskName,uxCurrentPriority, pxStack, uStackHighWaterMark);
+
+}
+
+/*********************************************************************
+*
+*       SYSVIEW_UpdateTask()
+*
+*  Function description
+*    Update a task in the internal list and record its information.
+*/
+void SYSVIEW_UpdateTask(U32 xHandle, const char* pcTaskName, unsigned uxCurrentPriority, U32 pxStack, unsigned uStackHighWaterMark) {
+  unsigned n;
+  
+  if (memcmp(pcTaskName, "IDLE", 5) == 0) {
+    return;
+  }
+
+  for (n = 0; n < SYSVIEW_FREERTOS_MAX_NOF_TASKS; n++) {
+    if (_aTasks[n].xHandle == xHandle) {
+      break;
+    }
+  }
+  if (n < SYSVIEW_FREERTOS_MAX_NOF_TASKS) {
+    _aTasks[n].pcTaskName = pcTaskName;
+    _aTasks[n].uxCurrentPriority = uxCurrentPriority;
+    _aTasks[n].pxStack = pxStack;
+    _aTasks[n].uStackHighWaterMark = uStackHighWaterMark;
+
+    SYSVIEW_SendTaskInfo(xHandle, pcTaskName, uxCurrentPriority, pxStack, uStackHighWaterMark);
+  } else {
+    SYSVIEW_AddTask(xHandle, pcTaskName, uxCurrentPriority, pxStack, uStackHighWaterMark);
+  }
+}
+
+/*********************************************************************
+*
+*       SYSVIEW_DeleteTask()
+*
+*  Function description
+*    Delete a task from the internal list.
+*/
+void SYSVIEW_DeleteTask(U32 xHandle) {
+  unsigned n;
+
+  for (n = 0; n < SYSVIEW_FREERTOS_MAX_NOF_TASKS; n++) {
+    if (_aTasks[n].xHandle == xHandle) {
+      break;
+    }
+  }
+  if (n == SYSVIEW_FREERTOS_MAX_NOF_TASKS) {
+    SEGGER_SYSVIEW_Warn("SYSTEMVIEW: Could not find task information. Cannot delete task.");
+    return;
+  }
+
+  _aTasks[n].xHandle = 0;
+}
+
+/*********************************************************************
+*
+*       SYSVIEW_SendTaskInfo()
+*
+*  Function description
+*    Record task information.
+*/
+void SYSVIEW_SendTaskInfo(U32 TaskID, const char* sName, unsigned Prio, U32 StackBase, unsigned StackSize) {
+  SEGGER_SYSVIEW_TASKINFO TaskInfo;
+
+  memset(&TaskInfo, 0, sizeof(TaskInfo)); // Fill all elements with 0 to allow extending the structure in future version without breaking the code
+  TaskInfo.TaskID     = TaskID;
+  TaskInfo.sName      = sName;
+  TaskInfo.Prio       = Prio;
+  TaskInfo.StackBase  = StackBase;
+  TaskInfo.StackSize  = StackSize;
+  SEGGER_SYSVIEW_SendTaskInfo(&TaskInfo);
+}
+
+/*********************************************************************
+*
+*       SYSVIEW_RecordU32x4()
+*
+*  Function description
+*    Record an event with 4 parameters
+*/
+void SYSVIEW_RecordU32x4(unsigned Id, U32 Para0, U32 Para1, U32 Para2, U32 Para3) {
+      U8  aPacket[SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32];
+      U8* pPayload;
+      //
+      pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket);                // Prepare the packet for SystemView
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para0);             // Add the first parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para1);             // Add the second parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para2);             // Add the third parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para3);             // Add the fourth parameter to the packet
+      //
+      SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, Id);             // Send the packet
+}
+
+/*********************************************************************
+*
+*       SYSVIEW_RecordU32x5()
+*
+*  Function description
+*    Record an event with 5 parameters
+*/
+void SYSVIEW_RecordU32x5(unsigned Id, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4) {
+      U8  aPacket[SEGGER_SYSVIEW_INFO_SIZE + 5 * SEGGER_SYSVIEW_QUANTA_U32];
+      U8* pPayload;
+      //
+      pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket);                // Prepare the packet for SystemView
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para0);             // Add the first parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para1);             // Add the second parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para2);             // Add the third parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para3);             // Add the fourth parameter to the packet
+      pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para4);             // Add the fifth parameter to the packet
+      //
+      SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, Id);             // Send the packet
+}
+
+/*********************************************************************
+*
+*       Public API structures
+*
+**********************************************************************
+*/
+// Callbacks provided to SYSTEMVIEW by FreeRTOS
+const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI = {
+  _cbGetTime,
+  _cbSendTaskList,
+};
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/Sample/OS/SEGGER_SYSVIEW_FreeRTOS.h

@@ -0,0 +1,335 @@
+/*********************************************************************
+*                SEGGER Microcontroller GmbH & Co. KG                *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*       (c) 2015 - 2017  SEGGER Microcontroller GmbH & Co. KG        *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER SystemView * Real-time application analysis           *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* 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    *
+* conditions are met:                                                *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this list of conditions and the following disclaimer.    *
+*                                                                    *
+* o Redistributions in binary form must reproduce the above          *
+*   copyright notice, this list of conditions and the following      *
+*   disclaimer in the documentation and/or other materials provided  *
+*   with the distribution.                                           *
+*                                                                    *
+* o Neither the name of SEGGER Microcontroller GmbH & Co. KG         *
+*   nor the names of its contributors may be used to endorse or      *
+*   promote products derived from this software without specific     *
+*   prior written permission.                                        *
+*                                                                    *
+* 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.                                                            *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SystemView version: V2.42                                    *
+*                                                                    *
+**********************************************************************
+-------------------------- END-OF-HEADER -----------------------------
+
+File    : SEGGER_SYSVIEW_FreeRTOS.h
+Purpose : Interface between FreeRTOS and SystemView.
+Revision: $Rev: 3734 $
+
+Notes:
+  (1) Include this file at the end of FreeRTOSConfig.h
+*/
+
+#ifndef SYSVIEW_FREERTOS_H
+#define SYSVIEW_FREERTOS_H
+
+#include "SEGGER_SYSVIEW.h"
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+#ifndef portSTACK_GROWTH
+  #define portSTACK_GROWTH              ( -1 )
+#endif
+
+#define SYSVIEW_FREERTOS_MAX_NOF_TASKS  16
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+
+// for dual-core targets we use event ID to keep core ID bit (0 or 1)
+// use the highest - 1 bit of event ID to indicate core ID
+// the highest bit can not be used due to event ID encoding method
+// this reduces supported ID range to [0..63] (for 1 byte IDs) plus [128..16383] (for 2 bytes IDs)
+// so original continuous event IDs range is split into two sub-ranges for 1-bytes IDs and 2-bytes ones
+
+// events which use apiFastID_OFFSET will have 1 byte ID,
+// so for the sake of bandwidth economy events which are generated more frequently should use this ID offset
+// currently all used events fall into this range
+#define apiFastID_OFFSET                          (32u)
+
+#define apiID_VTASKDELETE                         (1u)
+#define apiID_VTASKDELAY                          (2u)
+#define apiID_VTASKDELAYUNTIL                     (3u)
+#define apiID_VTASKSUSPEND                        (4u)
+#define apiID_ULTASKNOTIFYTAKE                    (5u)
+#define apiID_VTASKNOTIFYGIVEFROMISR              (6u)
+#define apiID_VTASKPRIORITYINHERIT                (7u)
+#define apiID_VTASKRESUME                         (8u)
+#define apiID_VTASKSTEPTICK                       (9u)
+#define apiID_XTASKPRIORITYDISINHERIT             (10u)
+#define apiID_XTASKRESUMEFROMISR                  (11u)
+#define apiID_XTASKGENERICNOTIFY                  (12u)
+#define apiID_XTASKGENERICNOTIFYFROMISR           (13u)
+#define apiID_XTASKNOTIFYWAIT                     (14u)
+#define apiID_XQUEUEGENERICCREATE                 (15u)
+#define apiID_VQUEUEDELETE                        (16u)
+#define apiID_XQUEUEGENERICRECEIVE                (17u)
+#define apiID_XQUEUEPEEKFROMISR                   (18u)
+#define apiID_XQUEUERECEIVEFROMISR                (19u)
+#define apiID_VQUEUEADDTOREGISTRY                 (20u)
+#define apiID_XQUEUEGENERICSEND                   (21u)
+#define apiID_XQUEUEGENERICSENDFROMISR            (22u)
+#define apiID_VTASKPRIORITYSET                    (23u)
+#define apiID_UXTASKPRIORITYGETFROMISR            (24u)
+#define apiID_XTASKGETTICKCOUNTFROMISR            (25u)
+#define apiID_XEVENTGROUPCLEARBITSFROMISR         (26u)
+#define apiID_XEVENTGROUPSETBITSFROMISR           (27u)
+#define apiID_XEVENTGROUPGETBITSFROMISR           (28u)
+#define apiID_XQUEUEGIVEFROMISR                   (29u)
+#define apiID_XQUEUEISQUEUEEMPTYFROMISR           (30u)
+#define apiID_XQUEUEISQUEUEFULLFROMISR            (31u) // the maximum allowed apiID for the first ID range
+
+// events which use apiSlowID_OFFSET will have 2-bytes ID
+#define apiSlowID_OFFSET                          (127u)
+
+#define apiID_VTASKALLOCATEMPUREGIONS             (1u)
+#define apiID_UXTASKPRIORITYGET                   (2u)
+#define apiID_ETASKGETSTATE                       (3u)
+#define apiID_VTASKSTARTSCHEDULER                 (4u)
+#define apiID_VTASKENDSCHEDULER                   (5u)
+#define apiID_VTASKSUSPENDALL                     (6u)
+#define apiID_XTASKRESUMEALL                      (7u)
+#define apiID_XTASKGETTICKCOUNT                   (8u)
+#define apiID_UXTASKGETNUMBEROFTASKS              (9u)
+#define apiID_PCTASKGETTASKNAME                   (10u)
+#define apiID_UXTASKGETSTACKHIGHWATERMARK         (11u)
+#define apiID_VTASKSETAPPLICATIONTASKTAG          (12u)
+#define apiID_XTASKGETAPPLICATIONTASKTAG          (13u)
+#define apiID_VTASKSETTHREADLOCALSTORAGEPOINTER   (14u)
+#define apiID_PVTASKGETTHREADLOCALSTORAGEPOINTER  (15u)
+#define apiID_XTASKCALLAPPLICATIONTASKHOOK        (16u)
+#define apiID_XTASKGETIDLETASKHANDLE              (17u)
+#define apiID_UXTASKGETSYSTEMSTATE                (18u)
+#define apiID_VTASKLIST                           (19u)
+#define apiID_VTASKGETRUNTIMESTATS                (20u)
+#define apiID_XTASKNOTIFYSTATECLEAR               (21u)
+#define apiID_XTASKGETCURRENTTASKHANDLE           (22u)
+#define apiID_VTASKSETTIMEOUTSTATE                (23u)
+#define apiID_XTASKCHECKFORTIMEOUT                (24u)
+#define apiID_VTASKMISSEDYIELD                    (25u)
+#define apiID_XTASKGETSCHEDULERSTATE              (26u)
+#define apiID_XTASKGENERICCREATE                  (27u)
+#define apiID_UXTASKGETTASKNUMBER                 (28u)
+#define apiID_VTASKSETTASKNUMBER                  (29u)
+#define apiID_ETASKCONFIRMSLEEPMODESTATUS         (30u)
+#define apiID_XTIMERCREATE                        (31u)
+#define apiID_PVTIMERGETTIMERID                   (32u)
+#define apiID_VTIMERSETTIMERID                    (33u)
+#define apiID_XTIMERISTIMERACTIVE                 (34u)
+#define apiID_XTIMERGETTIMERDAEMONTASKHANDLE      (35u)
+#define apiID_XTIMERPENDFUNCTIONCALLFROMISR       (36u)
+#define apiID_XTIMERPENDFUNCTIONCALL              (37u)
+#define apiID_PCTIMERGETTIMERNAME                 (38u)
+#define apiID_XTIMERCREATETIMERTASK               (39u)
+#define apiID_XTIMERGENERICCOMMAND                (40u)
+#define apiID_UXQUEUEMESSAGESWAITING              (41u)
+#define apiID_UXQUEUESPACESAVAILABLE              (42u)
+#define apiID_UXQUEUEMESSAGESWAITINGFROMISR       (43u)
+#define apiID_XQUEUEALTGENERICSEND                (44u)
+#define apiID_XQUEUEALTGENERICRECEIVE             (45u)
+#define apiID_XQUEUECRSENDFROMISR                 (46u)
+#define apiID_XQUEUECRRECEIVEFROMISR              (47u)
+#define apiID_XQUEUECRSEND                        (48u)
+#define apiID_XQUEUECRRECEIVE                     (49u)
+#define apiID_XQUEUECREATEMUTEX                   (50u)
+#define apiID_XQUEUECREATECOUNTINGSEMAPHORE       (51u)
+#define apiID_XQUEUEGETMUTEXHOLDER                (52u)
+#define apiID_XQUEUETAKEMUTEXRECURSIVE            (53u)
+#define apiID_XQUEUEGIVEMUTEXRECURSIVE            (54u)
+#define apiID_VQUEUEUNREGISTERQUEUE               (55u)
+#define apiID_XQUEUECREATESET                     (56u)
+#define apiID_XQUEUEADDTOSET                      (57u)
+#define apiID_XQUEUEREMOVEFROMSET                 (58u)
+#define apiID_XQUEUESELECTFROMSET                 (59u)
+#define apiID_XQUEUESELECTFROMSETFROMISR          (60u)
+#define apiID_XQUEUEGENERICRESET                  (61u)
+#define apiID_VLISTINITIALISE                     (62u)
+#define apiID_VLISTINITIALISEITEM                 (63u)
+#define apiID_VLISTINSERT                         (64u)
+#define apiID_VLISTINSERTEND                      (65u)
+#define apiID_UXLISTREMOVE                        (66u)
+#define apiID_XEVENTGROUPCREATE                   (67u)
+#define apiID_XEVENTGROUPWAITBITS                 (68u)
+#define apiID_XEVENTGROUPCLEARBITS                (69u)
+#define apiID_XEVENTGROUPSETBITS                  (70u)
+#define apiID_XEVENTGROUPSYNC                     (71u)
+#define apiID_VEVENTGROUPDELETE                   (72u)
+#define apiID_UXEVENTGROUPGETNUMBER               (73u)
+
+#define traceTASK_NOTIFY_TAKE()                                       SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_ULTASKNOTIFYTAKE, xClearCountOnExit, xTicksToWait)
+#define traceTASK_DELAY()                                             SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKDELAY, xTicksToDelay)
+#define traceTASK_DELAY_UNTIL()                                       SEGGER_SYSVIEW_RecordVoid(apiFastID_OFFSET + apiID_VTASKDELAYUNTIL)
+#define traceTASK_DELETE( pxTCB )                                     if (pxTCB != NULL) {                                              \
+						                                                SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKDELETE,  \
+						                                                                      SEGGER_SYSVIEW_ShrinkId((U32)pxTCB)); 	\
+					                                                    SYSVIEW_DeleteTask((U32)pxTCB);                                 \
+					                                                  }
+#define traceTASK_NOTIFY_GIVE_FROM_ISR()                              SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_VTASKNOTIFYGIVEFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB), (U32)pxHigherPriorityTaskWoken)
+#define traceTASK_PRIORITY_INHERIT( pxTCB, uxPriority )               SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKPRIORITYINHERIT, (U32)pxMutexHolder)
+#define traceTASK_RESUME( pxTCB )                                     SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKRESUME, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB))
+#define traceINCREASE_TICK_COUNT( xTicksToJump )                      SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKSTEPTICK, xTicksToJump)
+#define traceTASK_SUSPEND( pxTCB )                                    SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VTASKSUSPEND, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB))
+#define traceTASK_PRIORITY_DISINHERIT( pxTCB, uxBasePriority )        SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_XTASKPRIORITYDISINHERIT, (U32)pxMutexHolder)
+#define traceTASK_RESUME_FROM_ISR( pxTCB )                            SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_XTASKRESUMEFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB))
+#define traceTASK_NOTIFY()                                            SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XTASKGENERICNOTIFY, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB), ulValue, eAction, (U32)pulPreviousNotificationValue)
+#define traceTASK_NOTIFY_FROM_ISR()                                   SYSVIEW_RecordU32x5(apiFastID_OFFSET + apiID_XTASKGENERICNOTIFYFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxTCB), ulValue, eAction, (U32)pulPreviousNotificationValue, (U32)pxHigherPriorityTaskWoken)
+#define traceTASK_NOTIFY_WAIT()                                       SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XTASKNOTIFYWAIT, ulBitsToClearOnEntry, ulBitsToClearOnExit, (U32)pulNotificationValue, xTicksToWait)
+
+#define traceQUEUE_CREATE( pxNewQueue )                               SEGGER_SYSVIEW_RecordU32x3(apiFastID_OFFSET + apiID_XQUEUEGENERICCREATE, uxQueueLength, uxItemSize, ucQueueType)
+#define traceQUEUE_DELETE( pxQueue )                                  SEGGER_SYSVIEW_RecordU32(apiFastID_OFFSET + apiID_VQUEUEDELETE, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue))
+#define traceQUEUE_PEEK( pxQueue )                                    SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICRECEIVE, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer), xTicksToWait, xJustPeeking)
+#define traceQUEUE_PEEK_FROM_ISR( pxQueue )                           SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_XQUEUEPEEKFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer))
+#define traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue )                    SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_XQUEUEPEEKFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer))
+#define traceQUEUE_RECEIVE( pxQueue )                                 SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICRECEIVE, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer), xTicksToWait, xJustPeeking)
+#define traceQUEUE_RECEIVE_FAILED( pxQueue )                          SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICRECEIVE, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer), xTicksToWait, xJustPeeking)
+#define traceQUEUE_RECEIVE_FROM_ISR( pxQueue )                        SEGGER_SYSVIEW_RecordU32x3(apiFastID_OFFSET + apiID_XQUEUERECEIVEFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer), (U32)pxHigherPriorityTaskWoken)
+#define traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue )                 SEGGER_SYSVIEW_RecordU32x3(apiFastID_OFFSET + apiID_XQUEUERECEIVEFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), SEGGER_SYSVIEW_ShrinkId((U32)pvBuffer), (U32)pxHigherPriorityTaskWoken)
+#define traceQUEUE_REGISTRY_ADD( xQueue, pcQueueName )                SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_VQUEUEADDTOREGISTRY, SEGGER_SYSVIEW_ShrinkId((U32)xQueue), (U32)pcQueueName)
+#if ( configUSE_QUEUE_SETS != 1 )
+  #define traceQUEUE_SEND( pxQueue )                                    SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICSEND, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), (U32)pvItemToQueue, xTicksToWait, xCopyPosition)
+#else
+  #define traceQUEUE_SEND( pxQueue )                                    SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICSEND, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), 0, 0, xCopyPosition)
+#endif
+#define traceQUEUE_SEND_FAILED( pxQueue )                             SYSVIEW_RecordU32x4(apiFastID_OFFSET + apiID_XQUEUEGENERICSEND, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), (U32)pvItemToQueue, xTicksToWait, xCopyPosition)
+#define traceQUEUE_SEND_FROM_ISR( pxQueue )                           SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_XQUEUEGENERICSENDFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), (U32)pxHigherPriorityTaskWoken)
+#define traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue )                    SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET + apiID_XQUEUEGENERICSENDFROMISR, SEGGER_SYSVIEW_ShrinkId((U32)pxQueue), (U32)pxHigherPriorityTaskWoken)
+
+#if( portSTACK_GROWTH < 0 )
+#define traceTASK_CREATE(pxNewTCB)                  if (pxNewTCB != NULL) {                                             \
+                                                      SEGGER_SYSVIEW_OnTaskCreate((U32)pxNewTCB);                       \
+                                                      SYSVIEW_AddTask((U32)pxNewTCB,                                    \
+                                                                      &(pxNewTCB->pcTaskName[0]),                       \
+                                                                      pxNewTCB->uxPriority,                             \
+                                                                      (U32)pxNewTCB->pxStack,                           \
+                                                                      ((U32)pxNewTCB->pxTopOfStack - (U32)pxNewTCB->pxStack) \
+                                                                      );                                                \
+                                                    }
+#else
+#define traceTASK_CREATE(pxNewTCB)                  if (pxNewTCB != NULL) {                                             \
+                                                      SEGGER_SYSVIEW_OnTaskCreate((U32)pxNewTCB);                       \
+                                                      SYSVIEW_AddTask((U32)pxNewTCB,                                    \
+                                                                      &(pxNewTCB->pcTaskName[0]),                       \
+                                                                      pxNewTCB->uxPriority,                             \
+                                                                      (U32)pxNewTCB->pxStack,                           \
+                                                                      (U32)(pxNewTCB->pxStack-pxNewTCB->pxTopOfStack)   \
+                                                                      );                                                \
+                                                    }
+#endif
+#define traceTASK_PRIORITY_SET(pxTask, uxNewPriority) {                                                                 \
+                                                        SEGGER_SYSVIEW_RecordU32x2(apiFastID_OFFSET+apiID_VTASKPRIORITYSET, \
+                                                                                   SEGGER_SYSVIEW_ShrinkId((U32)pxTCB), \
+                                                                                   uxNewPriority                        \
+                                                                                  );                                    \
+                                                        SYSVIEW_UpdateTask((U32)pxTask,                                 \
+                                                                           &(pxTask->pcTaskName[0]),                    \
+                                                                           uxNewPriority,                               \
+                                                                           (U32)pxTask->pxStack,                        \
+                                                                           0                                            \
+                                                                          );                                            \
+                                                      }
+//
+// Define INCLUDE_xTaskGetIdleTaskHandle as 1 in FreeRTOSConfig.h to allow identification of Idle state.
+//
+#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
+  #define traceTASK_SWITCHED_IN()                   if(prvGetTCBFromHandle(NULL) == xTaskGetIdleTaskHandle()) {           \
+                                                      SEGGER_SYSVIEW_OnIdle();                                          \
+                                                    } else {                                                            \
+                                                      SEGGER_SYSVIEW_OnTaskStartExec((U32)pxCurrentTCB[xPortGetCoreID()]); \
+                                                    }
+#else
+  #define traceTASK_SWITCHED_IN()                   {                                                                   \
+                                                      if (memcmp(pxCurrentTCB[xPortGetCoreID()]->pcTaskName, "IDLE", 5) != 0) { \
+                                                        SEGGER_SYSVIEW_OnTaskStartExec((U32)pxCurrentTCB[xPortGetCoreID()]);    \
+                                                      } else {                                                          \
+                                                        SEGGER_SYSVIEW_OnIdle();                                        \
+                                                      }                                                                 \
+                                                    }
+#endif
+
+#define traceMOVED_TASK_TO_READY_STATE(pxTCB)       SEGGER_SYSVIEW_OnTaskStartReady((U32)pxTCB)
+#define traceREADDED_TASK_TO_READY_STATE(pxTCB)
+
+#define traceMOVED_TASK_TO_DELAYED_LIST()           SEGGER_SYSVIEW_OnTaskStopReady((U32)pxCurrentTCB[xPortGetCoreID()],  (1u << 2))
+#define traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST()  SEGGER_SYSVIEW_OnTaskStopReady((U32)pxCurrentTCB[xPortGetCoreID()],  (1u << 2))
+#define traceMOVED_TASK_TO_SUSPENDED_LIST(pxTCB)    SEGGER_SYSVIEW_OnTaskStopReady((U32)pxTCB,         ((3u << 3) | 3))
+
+#define traceISR_EXIT_TO_SCHEDULER()                SEGGER_SYSVIEW_RecordExitISRToScheduler()
+#define traceISR_EXIT()                             SEGGER_SYSVIEW_RecordExitISR()
+#define traceISR_ENTER(_n_)                         SEGGER_SYSVIEW_RecordEnterISR(_n_)
+
+/*********************************************************************
+*
+*       API functions
+*
+**********************************************************************
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+void SYSVIEW_AddTask      (U32 xHandle, const char* pcTaskName, unsigned uxCurrentPriority, U32  pxStack, unsigned uStackHighWaterMark);
+void SYSVIEW_UpdateTask   (U32 xHandle, const char* pcTaskName, unsigned uxCurrentPriority, U32 pxStack, unsigned uStackHighWaterMark);
+void SYSVIEW_DeleteTask   (U32 xHandle);
+void SYSVIEW_SendTaskInfo (U32 TaskID, const char* sName, unsigned Prio, U32 StackBase, unsigned StackSize);
+void SYSVIEW_RecordU32x4  (unsigned Id, U32 Para0, U32 Para1, U32 Para2, U32 Para3);
+void SYSVIEW_RecordU32x5  (unsigned Id, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/*************************** End of file ****************************/

components/app_trace/sys_view/esp32/SEGGER_RTT_esp32.c

@@ -0,0 +1,222 @@
+// Copyright 2017 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "string.h"
+#include "freertos/FreeRTOS.h"
+#include "SEGGER_RTT.h"
+#include "SEGGER_SYSVIEW.h"
+
+#include "rom/ets_sys.h"
+#include "esp_app_trace.h"
+
+#define LOG_LOCAL_LEVEL ESP_LOG_ERROR
+#include "esp_log.h"
+const static char *TAG = "segger_rtt";
+
+#define SYSVIEW_EVENTS_BUF_SZ         255U
+
+#if SYSVIEW_RTT_MAX_DATA_RATE > 0
+#include "SEGGER_SYSVIEW_Conf.h"
+#if CONFIG_FREERTOS_UNICORE == 0
+#include "driver/timer.h"
+#define SYSVIEW_TIMESTAMP_FREQ  (TIMER_BASE_CLK/2)
+#else
+#define SYSVIEW_TIMESTAMP_FREQ  (XT_CLOCK_FREQ)
+#endif
+#endif
+
+#define SEGGER_HOST_WAIT_TMO  500 //us
+#define SEGGER_STOP_WAIT_TMO  1000000 //us
+
+static uint8_t s_events_buf[SYSVIEW_EVENTS_BUF_SZ];
+static uint16_t s_events_buf_filled;
+
+/*********************************************************************
+*
+*       Public code
+*
+**********************************************************************
+*/
+
+/*********************************************************************
+*
+*       SEGGER_RTT_ESP32_FlushNoLock()
+*
+*  Function description
+*    Flushes buffered events.
+*
+*  Parameters
+*    min_sz  Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.
+*    tmo     Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
+*
+*  Return value
+*    None.
+*/
+void SEGGER_RTT_ESP32_FlushNoLock(unsigned long min_sz, unsigned long tmo)
+{
+    esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, s_events_buf, s_events_buf_filled, tmo);
+    if (res != ESP_OK) {
+      ESP_LOGE(TAG, "Failed to flush buffered events (%d)!\n", res);
+    }
+    // flush even if we failed to write buffered events, because no new events will be sent after STOP
+    res = esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, min_sz, tmo);
+    if (res != ESP_OK) {
+      ESP_LOGE(TAG, "Failed to flush apptrace data (%d)!\n", res);
+    }
+    s_events_buf_filled = 0;
+}
+
+/*********************************************************************
+*
+*       SEGGER_RTT_ReadNoLock()
+*
+*  Function description
+*    Reads characters from SEGGER real-time-terminal control block
+*    which have been previously stored by the host.
+*    Do not lock against interrupts and multiple access.
+*
+*  Parameters
+*    BufferIndex  Index of Down-buffer to be used (e.g. 0 for "Terminal").
+*    pBuffer      Pointer to buffer provided by target application, to copy characters from RTT-down-buffer to.
+*    BufferSize   Size of the target application buffer.
+*
+*  Return value
+*    Number of bytes that have been read.
+*/
+unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) {
+  uint32_t size = BufferSize;
+  esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_TRAX, pData, &size, 0);
+  if (res != ESP_OK) {
+    return 0;
+  }
+  return size;
+}
+
+/*********************************************************************
+*
+*       SEGGER_RTT_WriteSkipNoLock
+*
+*  Function description
+*    Stores a specified number of characters in SEGGER RTT
+*    control block which is then read by the host.
+*    SEGGER_RTT_WriteSkipNoLock does not lock the application and
+*    skips all data, if the data does not fit into the buffer.
+*
+*  Parameters
+*    BufferIndex  Index of "Up"-buffer to be used (e.g. 0 for "Terminal").
+*    pBuffer      Pointer to character array. Does not need to point to a \0 terminated string.
+*    NumBytes     Number of bytes to be stored in the SEGGER RTT control block.
+*
+*  Return value
+*    Number of bytes which have been stored in the "Up"-buffer.
+*
+*  Notes
+*    (1) If there is not enough space in the "Up"-buffer, all data is dropped.
+*    (2) For performance reasons this function does not call Init()
+*        and may only be called after RTT has been initialized.
+*        Either by calling SEGGER_RTT_Init() or calling another RTT API function first.
+*/
+unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) {
+  uint8_t *pbuf = (uint8_t *)pBuffer;
+  uint8_t event_id = *pbuf;
+
+  if (NumBytes > SYSVIEW_EVENTS_BUF_SZ) {
+      ESP_LOGE(TAG, "Too large event %d bytes!", NumBytes);
+      return 0;
+  }
+  if (xPortGetCoreID()) { // dual core specific code
+    // use the highest - 1 bit of event ID to indicate core ID
+    // the highest bit can not be used due to event ID encoding method
+    // this reduces supported ID range to [0..63] (for 1 byte IDs) plus [128..16383] (for 2 bytes IDs)
+    if (*pbuf & 0x80) { // 2 bytes ID
+      *(pbuf + 1) |= (1 << 6);
+    } else if (NumBytes != 10 || *pbuf != 0) { // ignore sync sequence
+      *pbuf |= (1 << 6);
+    }
+  }
+  if (s_events_buf_filled + NumBytes > SYSVIEW_EVENTS_BUF_SZ) {
+    esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, s_events_buf, s_events_buf_filled, SEGGER_HOST_WAIT_TMO);
+    if (res != ESP_OK) {
+      return 0; // skip current data buffer only, accumulated events are kept
+    }
+    s_events_buf_filled = 0;
+  }
+  memcpy(&s_events_buf[s_events_buf_filled], pBuffer, NumBytes);
+  s_events_buf_filled += NumBytes;
+  if (event_id == SYSVIEW_EVTID_TRACE_STOP) {
+    SEGGER_RTT_ESP32_FlushNoLock(0, SEGGER_STOP_WAIT_TMO);
+  }
+  return NumBytes;
+}
+
+/*********************************************************************
+*
+*       SEGGER_RTT_ConfigUpBuffer
+*
+*  Function description
+*    Run-time configuration of a specific up-buffer (T->H).
+*    Buffer to be configured is specified by index.
+*    This includes: Buffer address, size, name, flags, ...
+*
+*  Parameters
+*    BufferIndex  Index of the buffer to configure.
+*    sName        Pointer to a constant name string.
+*    pBuffer      Pointer to a buffer to be used.
+*    BufferSize   Size of the buffer.
+*    Flags        Operating modes. Define behavior if buffer is full (not enough space for entire message).
+*
+*  Return value
+*    >= 0 - O.K.
+*     < 0 - Error
+*
+*  Additional information
+*    Buffer 0 is configured on compile-time.
+*    May only be called once per buffer.
+*    Buffer name and flags can be reconfigured using the appropriate functions.
+*/
+int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) {
+  s_events_buf_filled = 0;
+  return 0;
+}
+
+/*********************************************************************
+*
+*       SEGGER_RTT_ConfigDownBuffer
+*
+*  Function description
+*    Run-time configuration of a specific down-buffer (H->T).
+*    Buffer to be configured is specified by index.
+*    This includes: Buffer address, size, name, flags, ...
+*
+*  Parameters
+*    BufferIndex  Index of the buffer to configure.
+*    sName        Pointer to a constant name string.
+*    pBuffer      Pointer to a buffer to be used.
+*    BufferSize   Size of the buffer.
+*    Flags        Operating modes. Define behavior if buffer is full (not enough space for entire message).
+*
+*  Return value
+*    >= 0  O.K.
+*     < 0  Error
+*
+*  Additional information
+*    Buffer 0 is configured on compile-time.
+*    May only be called once per buffer.
+*    Buffer name and flags can be reconfigured using the appropriate functions.
+*/
+int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) {
+  return 0;
+}
+
+/*************************** End of file ****************************/

components/app_trace/test/component.mk

@@ -0,0 +1,5 @@
+#
+#Component Makefile
+#
+
+COMPONENT_ADD_LDFLAGS = -Wl,--whole-archive -l$(COMPONENT_NAME) -Wl,--no-whole-archive

components/app_trace/test/test_trace.c

@@ -5,11 +5,13 @@
 #include <stdarg.h>
 #include "unity.h"
 #include "driver/timer.h"
+#include "soc/cpu.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "freertos/task.h"
 #if CONFIG_ESP32_APPTRACE_ENABLE == 1
 #include "esp_app_trace.h"
+#include "esp_app_trace_util.h"
 
 #define ESP_APPTRACE_TEST_USE_PRINT_LOCK        0
 #define ESP_APPTRACE_TEST_PRN_WRERR_MAX         5
@@ -57,8 +59,32 @@ const static char *TAG = "esp_apptrace_test";
 #define ESP_APPTRACE_TEST_LOGV( format, ... )  ESP_APPTRACE_TEST_LOG_LEVEL(V, ESP_LOG_VERBOSE, format, ##__VA_ARGS__)
 #define ESP_APPTRACE_TEST_LOGO( format, ... )  ESP_APPTRACE_TEST_LOG_LEVEL(E, ESP_LOG_NONE, format, ##__VA_ARGS__)
 
+static void esp_apptrace_test_timer_init(int timer_group, int timer_idx, uint32_t period)
+{
+    timer_config_t config;
+    uint64_t alarm_val = (period * (TIMER_BASE_CLK / 1000000UL)) / 2;
+
+    config.alarm_en = 1;
+    config.auto_reload = 1;
+    config.counter_dir = TIMER_COUNT_UP;
+    config.divider = 1;
+    config.intr_type = TIMER_INTR_LEVEL;
+    config.counter_en = TIMER_PAUSE;
+    /*Configure timer*/
+    timer_init(timer_group, timer_idx, &config);
+    /*Stop timer counter*/
+    timer_pause(timer_group, timer_idx);
+    /*Load counter value */
+    timer_set_counter_value(timer_group, timer_idx, 0x00000000ULL);
+    /*Set alarm value*/
+    timer_set_alarm_value(timer_group, timer_idx, alarm_val);
+    /*Enable timer interrupt*/
+    timer_enable_intr(timer_group, timer_idx);
+}
+
+#if CONFIG_SYSVIEW_ENABLE == 0
 #define ESP_APPTRACE_TEST_WRITE(_b_, _s_)            esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, ESP_APPTRACE_TMO_INFINITE)
-#define ESP_APPTRACE_TEST_WRITE_FROM_ISR(_b_, _s_)   esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 100UL)
+#define ESP_APPTRACE_TEST_WRITE_FROM_ISR(_b_, _s_)   esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0UL)
 #define ESP_APPTRACE_TEST_WRITE_NOWAIT(_b_, _s_)     esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0)
 
 #define ESP_APPTRACE_TEST_CPUTICKS2US(_t_)       ((_t_)/(XT_CLOCK_FREQ/1000000))
@@ -103,29 +129,6 @@ static SemaphoreHandle_t s_print_lock;
 
 static uint64_t esp_apptrace_test_ts_get();
 
-static void esp_apptrace_test_timer_init(int timer_group, int timer_idx, uint32_t period)
-{
-    timer_config_t config;
-    uint64_t alarm_val = (period * (TIMER_BASE_CLK / 1000000UL)) / 2;
-
-    config.alarm_en = 1;
-    config.auto_reload = 1;
-    config.counter_dir = TIMER_COUNT_UP;
-    config.divider = 1;
-    config.intr_type = TIMER_INTR_LEVEL;
-    config.counter_en = TIMER_PAUSE;
-    /*Configure timer*/
-    timer_init(timer_group, timer_idx, &config);
-    /*Stop timer counter*/
-    timer_pause(timer_group, timer_idx);
-    /*Load counter value */
-    timer_set_counter_value(timer_group, timer_idx, 0x00000000ULL);
-    /*Set alarm value*/
-    timer_set_alarm_value(timer_group, timer_idx, alarm_val);
-    /*Enable timer interrupt*/
-    timer_enable_intr(timer_group, timer_idx);
-}
-
 static void esp_apptrace_test_timer_isr(void *arg)
 {
     esp_apptrace_test_timer_arg_t *tim_arg = (esp_apptrace_test_timer_arg_t *)arg;
@@ -309,13 +312,14 @@ static void esp_apptrace_test_task(void *p)
         uint32_t *ts = (uint32_t *)(arg->data.buf + sizeof(uint32_t));
         *ts = (uint32_t)esp_apptrace_test_ts_get();
         memset(arg->data.buf + 2 * sizeof(uint32_t), arg->data.wr_cnt & arg->data.mask, arg->data.buf_sz - 2 * sizeof(uint32_t));
+        // ESP_APPTRACE_TEST_LOGD("%x:%x: Write chunk%d %d bytes, %x", xTaskGetCurrentTaskHandle(), *ts, arg->data.wr_cnt, arg->data.buf_sz, arg->data.wr_cnt & arg->data.mask);
         if (arg->nowait) {
             res = ESP_APPTRACE_TEST_WRITE_NOWAIT(arg->data.buf, arg->data.buf_sz);
         } else {
             res = ESP_APPTRACE_TEST_WRITE(arg->data.buf, arg->data.buf_sz);
         }
         if (res) {
-            if (arg->data.wr_err++ < ESP_APPTRACE_TEST_PRN_WRERR_MAX) {
+            if (1){//arg->data.wr_err++ < ESP_APPTRACE_TEST_PRN_WRERR_MAX) {
                 ESP_APPTRACE_TEST_LOGE("%x: Failed to write trace %d %x!", xTaskGetCurrentTaskHandle(), res, arg->data.wr_cnt & arg->data.mask);
                 if (arg->data.wr_err == ESP_APPTRACE_TEST_PRN_WRERR_MAX) {
                     ESP_APPTRACE_TEST_LOGE("\n");
@@ -490,8 +494,9 @@ static void esp_apptrace_test(esp_apptrace_test_cfg_t *test_cfg)
         ESP_APPTRACE_TEST_LOGI("Created task %x", thnd);
     }
     xTaskCreatePinnedToCore(esp_apptrace_dummy_task, "dummy0", 2048, &dummy_task_arg[0], dummy_task_arg[0].prio, NULL, 0);
+#if CONFIG_FREERTOS_UNICORE == 0
     xTaskCreatePinnedToCore(esp_apptrace_dummy_task, "dummy1", 2048, &dummy_task_arg[0], dummy_task_arg[0].prio, NULL, 1);
-
+#endif
     for (int i = 0; i < test_cfg->tasks_num; i++) {
         //arg1.stop = 1;
         xSemaphoreTake(test_cfg->tasks[i].done, portMAX_DELAY);
@@ -567,6 +572,7 @@ TEST_CASE("App trace test (1 crashed task)", "[trace][ignore]")
     esp_apptrace_test(&test_cfg);
 }
 
+#if CONFIG_FREERTOS_UNICORE == 0
 TEST_CASE("App trace test (2 tasks + 1 timer @ each core", "[trace][ignore]")
 {
     int ntask = 0;
@@ -628,9 +634,9 @@ TEST_CASE("App trace test (2 tasks + 1 timer @ each core", "[trace][ignore]")
     s_test_tasks[ntask].timers_num = 0;
     s_test_tasks[ntask].timers = NULL;
     ntask++;
-
     esp_apptrace_test(&test_cfg);
 }
+#endif
 
 TEST_CASE("App trace test (1 task + 1 timer @ 1 core)", "[trace][ignore]")
 {
@@ -661,6 +667,7 @@ TEST_CASE("App trace test (1 task + 1 timer @ 1 core)", "[trace][ignore]")
     esp_apptrace_test(&test_cfg);
 }
 
+#if CONFIG_FREERTOS_UNICORE == 0
 TEST_CASE("App trace test (2 tasks (nowait): 1 @ each core)", "[trace][ignore]")
 {
     esp_apptrace_test_cfg_t test_cfg = {
@@ -722,6 +729,7 @@ TEST_CASE("App trace test (2 tasks: 1 @ each core)", "[trace][ignore]")
 
     esp_apptrace_test(&test_cfg);
 }
+#endif
 
 TEST_CASE("App trace test (1 task)", "[trace][ignore]")
 {
@@ -732,7 +740,7 @@ TEST_CASE("App trace test (1 task)", "[trace][ignore]")
 
     memset(s_test_tasks, 0, sizeof(s_test_tasks));
 
-    s_test_tasks[0].core = 1;
+    s_test_tasks[0].core = 0;
     s_test_tasks[0].prio = 3;
     s_test_tasks[0].task_func = esp_apptrace_test_task;
     s_test_tasks[0].data.buf = s_bufs[0];
@@ -759,6 +767,7 @@ static int esp_logtrace_printf(const char *fmt, ...)
 
 typedef struct {
     SemaphoreHandle_t done;
+    uint32_t work_count;
 } esp_logtrace_task_t;
 
 static void esp_logtrace_task(void *p)
@@ -793,7 +802,7 @@ static void esp_logtrace_task(void *p)
     vTaskDelete(NULL);
 }
 
-TEST_CASE("Log trace test (1 task)", "[trace][ignore]")
+TEST_CASE("Log trace test (2 tasks)", "[trace][ignore]")
 {
     TaskHandle_t thnd;
 
@@ -806,7 +815,11 @@ TEST_CASE("Log trace test (1 task)", "[trace][ignore]")
 
     xTaskCreatePinnedToCore(esp_logtrace_task, "logtrace0", 2048, &arg1, 3, &thnd, 0);
     ESP_APPTRACE_TEST_LOGI("Created task %x", thnd);
+#if CONFIG_FREERTOS_UNICORE == 0
     xTaskCreatePinnedToCore(esp_logtrace_task, "logtrace1", 2048, &arg2, 3, &thnd, 1);
+#else
+    xTaskCreatePinnedToCore(esp_logtrace_task, "logtrace1", 2048, &arg2, 3, &thnd, 0);
+#endif
     ESP_APPTRACE_TEST_LOGI("Created task %x", thnd);
 
     xSemaphoreTake(arg1.done, portMAX_DELAY);
@@ -814,4 +827,234 @@ TEST_CASE("Log trace test (1 task)", "[trace][ignore]")
     xSemaphoreTake(arg2.done, portMAX_DELAY);
     vSemaphoreDelete(arg2.done);
 }
+
+#else
+
+typedef struct {
+    int group;
+    int timer;
+    int flags;
+    uint32_t id;
+} esp_sysviewtrace_timer_arg_t;
+
+typedef struct {
+    SemaphoreHandle_t done;
+    SemaphoreHandle_t *sync;
+    esp_sysviewtrace_timer_arg_t *timer;
+    uint32_t work_count;
+    uint32_t sleep_tmo;
+    uint32_t id;
+} esp_sysviewtrace_task_arg_t;
+
+static void esp_sysview_test_timer_isr(void *arg)
+{
+    esp_sysviewtrace_timer_arg_t *tim_arg = (esp_sysviewtrace_timer_arg_t *)arg;
+
+    //ESP_APPTRACE_TEST_LOGI("tim-%d: IRQ %d/%d\n", tim_arg->id, tim_arg->group, tim_arg->timer);
+
+    if (tim_arg->group == 0) {
+        if (tim_arg->timer == 0) {
+            TIMERG0.int_clr_timers.t0 = 1;
+            TIMERG0.hw_timer[0].update = 1;
+            TIMERG0.hw_timer[0].config.alarm_en = 1;
+        } else {
+            TIMERG0.int_clr_timers.t1 = 1;
+            TIMERG0.hw_timer[1].update = 1;
+            TIMERG0.hw_timer[1].config.alarm_en = 1;
+        }
+    }
+    if (tim_arg->group == 1) {
+        if (tim_arg->timer == 0) {
+            TIMERG1.int_clr_timers.t0 = 1;
+            TIMERG1.hw_timer[0].update = 1;
+            TIMERG1.hw_timer[0].config.alarm_en = 1;
+        } else {
+            TIMERG1.int_clr_timers.t1 = 1;
+            TIMERG1.hw_timer[1].update = 1;
+            TIMERG1.hw_timer[1].config.alarm_en = 1;
+        }
+    }
+}
+
+static void esp_sysviewtrace_test_task(void *p)
+{
+    esp_sysviewtrace_task_arg_t *arg = (esp_sysviewtrace_task_arg_t *) p;
+    volatile uint32_t tmp = 0;
+    timer_isr_handle_t inth;
+
+    printf("%x: run sysview task\n", (uint32_t)xTaskGetCurrentTaskHandle());
+
+    if (arg->timer) {
+        esp_err_t res = timer_isr_register(arg->timer->group, arg->timer->timer, esp_sysview_test_timer_isr, arg->timer, arg->timer->flags, &inth);
+        if (res != ESP_OK) {
+            printf("%x: failed to register timer ISR\n", (uint32_t)xTaskGetCurrentTaskHandle());
+        }
+        else {
+            res = timer_start(arg->timer->group, arg->timer->timer);
+            if (res != ESP_OK) {
+                printf("%x: failed to start timer\n", (uint32_t)xTaskGetCurrentTaskHandle());
+            }
+        }
+    }
+
+    int i = 0;
+    while (1) {
+        static uint32_t count;
+        printf("%d", arg->id);
+        if((++count % 80) == 0)
+            printf("\n");
+        if (arg->sync) {
+            xSemaphoreTake(*arg->sync, portMAX_DELAY);
+        }
+        for (uint32_t k = 0; k < arg->work_count; k++) {
+            tmp++;
+        }
+        vTaskDelay(arg->sleep_tmo/portTICK_PERIOD_MS);
+        i++;
+        if (arg->sync) {
+            xSemaphoreGive(*arg->sync);
+        }
+    }
+    ESP_APPTRACE_TEST_LOGI("%x: finished", xTaskGetCurrentTaskHandle());
+
+    xSemaphoreGive(arg->done);
+    vTaskDelay(1);
+    vTaskDelete(NULL);
+}
+
+TEST_CASE("SysView trace test 1", "[trace][ignore]")
+{
+    TaskHandle_t thnd;
+
+    esp_sysviewtrace_timer_arg_t tim_arg1 = {
+        .group = TIMER_GROUP_1,
+        .timer = TIMER_1,
+        .flags = ESP_INTR_FLAG_SHARED,
+        .id = 0,
+    };
+    esp_sysviewtrace_task_arg_t arg1 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = NULL,
+        .work_count = 10000,
+        .sleep_tmo = 1,
+        .timer = &tim_arg1,
+        .id = 0,
+    };
+    esp_sysviewtrace_timer_arg_t tim_arg2 = {
+        .group = TIMER_GROUP_1,
+        .timer = TIMER_0,
+        .flags = 0,
+        .id = 1,
+    };
+    esp_sysviewtrace_task_arg_t arg2 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = NULL,
+        .work_count = 10000,
+        .sleep_tmo = 1,
+        .timer = &tim_arg2,
+        .id = 1,
+    };
+
+    esp_apptrace_test_timer_init(TIMER_GROUP_1, TIMER_1, 500);
+    esp_apptrace_test_timer_init(TIMER_GROUP_1, TIMER_0, 100);
+
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace0", 2048, &arg1, 3, &thnd, 0);
+    ESP_APPTRACE_TEST_LOGI("Created task %x", thnd);
+#if CONFIG_FREERTOS_UNICORE == 0
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace1", 2048, &arg2, 5, &thnd, 1);
+#else
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace1", 2048, &arg2, 5, &thnd, 0);
+#endif
+    ESP_APPTRACE_TEST_LOGI("Created task %x", thnd);
+
+    xSemaphoreTake(arg1.done, portMAX_DELAY);
+    vSemaphoreDelete(arg1.done);
+    xSemaphoreTake(arg2.done, portMAX_DELAY);
+    vSemaphoreDelete(arg2.done);
+}
+
+TEST_CASE("SysView trace test 2", "[trace][ignore]")
+{
+    TaskHandle_t thnd;
+
+    esp_sysviewtrace_timer_arg_t tim_arg1 = {
+        .group = TIMER_GROUP_1,
+        .timer = TIMER_1,
+        .flags = ESP_INTR_FLAG_SHARED,
+        .id = 0,
+    };
+    esp_sysviewtrace_task_arg_t arg1 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = NULL,
+        .work_count = 10000,
+        .sleep_tmo = 1,
+        .timer = &tim_arg1,
+        .id = 0,
+    };
+    esp_sysviewtrace_timer_arg_t tim_arg2 = {
+        .group = TIMER_GROUP_1,
+        .timer = TIMER_0,
+        .flags = 0,
+        .id = 1,
+    };
+    esp_sysviewtrace_task_arg_t arg2 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = NULL,
+        .work_count = 10000,
+        .sleep_tmo = 1,
+        .timer = &tim_arg2,
+        .id = 1,
+    };
+
+    SemaphoreHandle_t test_sync = xSemaphoreCreateBinary();
+    xSemaphoreGive(test_sync);
+    esp_sysviewtrace_task_arg_t arg3 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = &test_sync,
+        .work_count = 1000,
+        .sleep_tmo = 1,
+        .timer = NULL,
+        .id = 2,
+    };
+    esp_sysviewtrace_task_arg_t arg4 = {
+        .done = xSemaphoreCreateBinary(),
+        .sync = &test_sync,
+        .work_count = 10000,
+        .sleep_tmo = 1,
+        .timer = NULL,
+        .id = 3,
+    };
+
+    esp_apptrace_test_timer_init(TIMER_GROUP_1, TIMER_1, 500);
+    esp_apptrace_test_timer_init(TIMER_GROUP_1, TIMER_0, 100);
+
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace0", 2048, &arg1, 3, &thnd, 0);
+    printf("Created task %x\n", (uint32_t)thnd);
+#if CONFIG_FREERTOS_UNICORE == 0
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace1", 2048, &arg2, 4, &thnd, 1);
+#else
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svtrace1", 2048, &arg2, 4, &thnd, 0);
+#endif
+    printf("Created task %x\n", (uint32_t)thnd);
+
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svsync0", 2048, &arg3, 3, &thnd, 0);
+    printf("Created task %x\n", (uint32_t)thnd);
+#if CONFIG_FREERTOS_UNICORE == 0
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svsync1", 2048, &arg4, 5, &thnd, 1);
+#else
+    xTaskCreatePinnedToCore(esp_sysviewtrace_test_task, "svsync1", 2048, &arg4, 5, &thnd, 0);
+#endif
+    printf("Created task %x\n", (uint32_t)thnd);
+
+    xSemaphoreTake(arg1.done, portMAX_DELAY);
+    vSemaphoreDelete(arg1.done);
+    xSemaphoreTake(arg2.done, portMAX_DELAY);
+    vSemaphoreDelete(arg2.done);
+    xSemaphoreTake(arg3.done, portMAX_DELAY);
+    vSemaphoreDelete(arg3.done);
+    xSemaphoreTake(arg4.done, portMAX_DELAY);
+    vSemaphoreDelete(arg4.done);
+    vSemaphoreDelete(test_sync);
+}
+#endif
 #endif

components/esp32/Kconfig

@@ -104,45 +104,6 @@ config ESP32_CORE_DUMP_LOG_LEVEL
     help
         Config core dump module logging level (0-5).
 
-choice ESP32_APPTRACE_DESTINATION
-    prompt "AppTrace: destination"
-    default ESP32_APPTRACE_DEST_NONE
-    help
-        Select destination for application trace: trace memory, uart or none (to disable).
-
-config ESP32_APPTRACE_DEST_TRAX
-    bool "Trace memory"
-    select ESP32_APPTRACE_ENABLE
-config ESP32_APPTRACE_DEST_UART
-    bool "UART"
-    select ESP32_APPTRACE_ENABLE
-config ESP32_APPTRACE_DEST_NONE
-    bool "None"
-endchoice
-
-config ESP32_APPTRACE_ENABLE
-    bool
-    depends on !ESP32_TRAX
-    select MEMMAP_TRACEMEM
-    select MEMMAP_TRACEMEM_TWOBANKS
-    default F
-    help
-        Enables/disable application tracing module.
-
-config ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO
-    int "AppTrace: Timeout for flushing last trace data to host on panic"
-    depends on ESP32_APPTRACE_ENABLE
-    default 4294967295
-    help
-        Timeout for flushing last trace data to host in case of panic. In us.
-
-config ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TRAX_THRESH
-    int "AppTrace: Threshold for flushing last trace data to host on panic"
-    depends on ESP32_APPTRACE_DEST_TRAX
-    default 50
-    help
-        Threshold for flushing last trace data to host on panic. In percents of TRAX memory block length.
-
 # Not implemented and/or needs new silicon rev to work
 config MEMMAP_SPISRAM
     bool "Use external SPI SRAM chip as main memory"

components/esp32/cpu_start.c

@@ -188,7 +188,7 @@ void IRAM_ATTR call_start_cpu1()
                   "wsr    %0, vecbase\n" \
                   ::"r"(&_init_start));
 
-    ets_set_appcpu_boot_addr(0); 
+    ets_set_appcpu_boot_addr(0);
     cpu_configure_region_protection();
 
 #if CONFIG_CONSOLE_UART_NONE
@@ -257,6 +257,9 @@ void start_cpu0_default(void)
     if (err != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to init apptrace module on CPU0 (%d)!", err);
     }
+#endif
+#if CONFIG_SYSVIEW_ENABLE
+    SEGGER_SYSVIEW_Conf();
 #endif
     do_global_ctors();
 #if CONFIG_INT_WDT

components/esp32/dport_access.c

@@ -188,9 +188,9 @@ static void dport_access_init_core1(void *arg)
 void esp_dport_access_int_init(void)
 {
     if (xPortGetCoreID() == 0) {
-        xTaskCreatePinnedToCore(&dport_access_init_core0, "dport0", 512, NULL, 5, NULL, 0);
+        xTaskCreatePinnedToCore(&dport_access_init_core0, "dport0", 2048, NULL, 5, NULL, 0);
     } else {
-        xTaskCreatePinnedToCore(&dport_access_init_core1, "dport1", 512, NULL, 5, NULL, 1);
+        xTaskCreatePinnedToCore(&dport_access_init_core1, "dport1", 2048, NULL, 5, NULL, 1);
     }
 }
 

components/esp32/include/esp_intr_alloc.h

@@ -77,6 +77,9 @@ extern "C" {
 
 /**@}*/
 
+// This is used to provide SystemView with positive IRQ IDs, otherwise sheduler events are not shown properly
+#define ETS_INTERNAL_INTR_SOURCE_OFF		(-ETS_INTERNAL_PROFILING_INTR_SOURCE)
+
 typedef void (*intr_handler_t)(void *arg); 
 
 
@@ -221,7 +224,6 @@ int esp_intr_get_cpu(intr_handle_t handle);
  */
 int esp_intr_get_intno(intr_handle_t handle);
 
-
 /**
  * @brief Disable the interrupt associated with the handle
  * 

components/esp32/intr_alloc.c

@@ -24,6 +24,7 @@
 #include "freertos/task.h"
 #include <esp_types.h>
 #include "esp_err.h"
+//#define LOG_LOCAL_LEVEL ESP_LOG_VERBOSE
 #include "esp_log.h"
 #include "esp_intr.h"
 #include "esp_attr.h"
@@ -33,7 +34,6 @@
 
 static const char* TAG = "intr_alloc";
 
-
 #define ETS_INTERNAL_TIMER0_INTR_NO 6
 #define ETS_INTERNAL_TIMER1_INTR_NO 15
 #define ETS_INTERNAL_TIMER2_INTR_NO 16
@@ -74,7 +74,7 @@ typedef struct {
 } int_desc_t;
 
 
-//We should mark the interrupt for the timer used by FreeRTOS as reserved. The specific timer 
+//We should mark the interrupt for the timer used by FreeRTOS as reserved. The specific timer
 //is selectable using menuconfig; we use these cpp bits to convert that into something we can use in
 //the table below.
 #if CONFIG_FREERTOS_CORETIMER_0
@@ -159,6 +159,13 @@ struct intr_handle_data_t {
     shared_vector_desc_t *shared_vector_desc;
 };
 
+typedef struct non_shared_isr_arg_t non_shared_isr_arg_t;
+
+struct non_shared_isr_arg_t {
+    intr_handler_t isr;
+    void *isr_arg;
+    int source;
+};
 
 //Linked list of vector descriptions, sorted by cpu.intno value
 static vector_desc_t *vector_desc_head;
@@ -169,12 +176,15 @@ static uint32_t non_iram_int_mask[portNUM_PROCESSORS];
 static uint32_t non_iram_int_disabled[portNUM_PROCESSORS];
 static bool non_iram_int_disabled_flag[portNUM_PROCESSORS];
 
+#if CONFIG_SYSVIEW_ENABLE
+extern uint32_t port_switch_flag[];
+#endif
 
 static portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;
 
 //Inserts an item into vector_desc list so that the list is sorted
 //with an incrementing cpu.intno value.
-static void insert_vector_desc(vector_desc_t *to_insert) 
+static void insert_vector_desc(vector_desc_t *to_insert)
 {
     vector_desc_t *vd=vector_desc_head;
     vector_desc_t *prev=NULL;
@@ -195,7 +205,7 @@ static void insert_vector_desc(vector_desc_t *to_insert)
 }
 
 //Returns a vector_desc entry for an intno/cpu, or NULL if none exists.
-static vector_desc_t *find_desc_for_int(int intno, int cpu) 
+static vector_desc_t *find_desc_for_int(int intno, int cpu)
 {
     vector_desc_t *vd=vector_desc_head;
     while(vd!=NULL) {
@@ -208,7 +218,7 @@ static vector_desc_t *find_desc_for_int(int intno, int cpu)
 //Returns a vector_desc entry for an intno/cpu.
 //Either returns a preexisting one or allocates a new one and inserts
 //it into the list. Returns NULL on malloc fail.
-static vector_desc_t *get_desc_for_int(int intno, int cpu) 
+static vector_desc_t *get_desc_for_int(int intno, int cpu)
 {
     vector_desc_t *vd=find_desc_for_int(intno, cpu);
     if (vd==NULL) {
@@ -234,7 +244,7 @@ esp_err_t esp_intr_mark_shared(int intno, int cpu, bool is_int_ram)
     if (vd==NULL) {
         portEXIT_CRITICAL(&spinlock);
         return ESP_ERR_NO_MEM;
-    } 
+    }
     vd->flags=VECDESC_FL_SHARED;
     if (is_int_ram) vd->flags|=VECDESC_FL_INIRAM;
     portEXIT_CRITICAL(&spinlock);
@@ -252,16 +262,16 @@ esp_err_t esp_intr_reserve(int intno, int cpu)
     if (vd==NULL) {
         portEXIT_CRITICAL(&spinlock);
         return ESP_ERR_NO_MEM;
-    } 
+    }
     vd->flags=VECDESC_FL_RESERVED;
     portEXIT_CRITICAL(&spinlock);
 
     return ESP_OK;
 }
 
-//Interrupt handler table and unhandled uinterrupt routine. Duplicated 
-//from xtensa_intr.c... it's supposed to be private, but we need to look 
-//into it in order to see if someone allocated an int using 
+//Interrupt handler table and unhandled uinterrupt routine. Duplicated
+//from xtensa_intr.c... it's supposed to be private, but we need to look
+//into it in order to see if someone allocated an int using
 //xt_set_interrupt_handler.
 typedef struct xt_handler_table_entry {
     void * handler;
@@ -271,7 +281,7 @@ extern xt_handler_table_entry _xt_interrupt_table[XCHAL_NUM_INTERRUPTS*portNUM_P
 extern void xt_unhandled_interrupt(void * arg);
 
 //Returns true if handler for interrupt is not the default unhandled interrupt handler
-static bool int_has_handler(int intr, int cpu) 
+static bool int_has_handler(int intr, int cpu)
 {
     return (_xt_interrupt_table[intr*portNUM_PROCESSORS+cpu].handler != xt_unhandled_interrupt);
 }
@@ -303,8 +313,8 @@ static int get_free_int(int flags, int cpu, int force)
             ALCHLOG(TAG, "Ignoring int %d: forced to %d", x, force);
             continue;
         }
-        ALCHLOG(TAG, "Int %d reserved %d level %d %s hasIsr %d", 
-            x, int_desc[x].cpuflags[cpu]==INTDESC_RESVD, int_desc[x].level, 
+        ALCHLOG(TAG, "Int %d reserved %d level %d %s hasIsr %d",
+            x, int_desc[x].cpuflags[cpu]==INTDESC_RESVD, int_desc[x].level,
             int_desc[x].type==INTTP_LEVEL?"LEVEL":"EDGE", int_has_handler(x, cpu));
         //Check if interrupt is not reserved by design
         if (int_desc[x].cpuflags[cpu]==INTDESC_RESVD) {
@@ -321,7 +331,7 @@ static int get_free_int(int flags, int cpu, int force)
             continue;
         }
         //check if edge/level type matches what we want
-        if (((flags&ESP_INTR_FLAG_EDGE) && (int_desc[x].type==INTTP_LEVEL)) || 
+        if (((flags&ESP_INTR_FLAG_EDGE) && (int_desc[x].type==INTTP_LEVEL)) ||
                 (((!(flags&ESP_INTR_FLAG_EDGE)) && (int_desc[x].type==INTTP_EDGE)))) {
             ALCHLOG(TAG, "....Unusable: incompatible trigger type");
             continue;
@@ -373,7 +383,7 @@ static int get_free_int(int flags, int cpu, int force)
                 }
             } else {
                 if (best==-1) {
-                    //We haven't found a feasible shared interrupt yet. This one is still free and usable, even if 
+                    //We haven't found a feasible shared interrupt yet. This one is still free and usable, even if
                     //not marked as shared.
                     //Remember it in case we don't find any other shared interrupt that qualifies.
                     if (bestLevel>int_desc[x].level) {
@@ -406,9 +416,8 @@ static int get_free_int(int flags, int cpu, int force)
     return best;
 }
 
-
 //Common shared isr handler. Chain-call all ISRs.
-static void IRAM_ATTR shared_intr_isr(void *arg) 
+static void IRAM_ATTR shared_intr_isr(void *arg)
 {
     vector_desc_t *vd=(vector_desc_t*)arg;
     shared_vector_desc_t *sh_vec=vd->shared_vec_info;
@@ -416,7 +425,16 @@ static void IRAM_ATTR shared_intr_isr(void *arg)
     while(sh_vec) {
         if (!sh_vec->disabled) {
             if ((sh_vec->statusreg == NULL) || (*sh_vec->statusreg & sh_vec->statusmask)) {
+#if CONFIG_SYSVIEW_ENABLE
+                traceISR_ENTER(sh_vec->source+ETS_INTERNAL_INTR_SOURCE_OFF);
+#endif
                 sh_vec->isr(sh_vec->arg);
+#if CONFIG_SYSVIEW_ENABLE
+                // check if we will return to scheduler or to interrupted task after ISR
+                if (!port_switch_flag[xPortGetCoreID()]) {
+                    traceISR_EXIT();
+                }
+#endif
             }
         }
         sh_vec=sh_vec->next;
@@ -424,10 +442,27 @@ static void IRAM_ATTR shared_intr_isr(void *arg)
     portEXIT_CRITICAL(&spinlock);
 }
 
+#if CONFIG_SYSVIEW_ENABLE
+//Common non-shared isr handler wrapper.
+static void IRAM_ATTR non_shared_intr_isr(void *arg)
+{
+    non_shared_isr_arg_t *ns_isr_arg=(non_shared_isr_arg_t*)arg;
+    portENTER_CRITICAL(&spinlock);
+    traceISR_ENTER(ns_isr_arg->source+ETS_INTERNAL_INTR_SOURCE_OFF);
+    // FIXME: can we call ISR and check port_switch_flag after releasing spinlock?
+    // when CONFIG_SYSVIEW_ENABLE = 0 ISRs for non-shared IRQs are called without spinlock
+    ns_isr_arg->isr(ns_isr_arg->isr_arg);
+    // check if we will return to scheduler or to interrupted task after ISR
+    if (!port_switch_flag[xPortGetCoreID()]) {
+        traceISR_EXIT();
+    }
+    portEXIT_CRITICAL(&spinlock);
+}
+#endif
 
 //We use ESP_EARLY_LOG* here because this can be called before the scheduler is running.
-esp_err_t esp_intr_alloc_intrstatus(int source, int flags, uint32_t intrstatusreg, uint32_t intrstatusmask, intr_handler_t handler, 
-                                        void *arg, intr_handle_t *ret_handle) 
+esp_err_t esp_intr_alloc_intrstatus(int source, int flags, uint32_t intrstatusreg, uint32_t intrstatusmask, intr_handler_t handler,
+                                        void *arg, intr_handle_t *ret_handle)
 {
     intr_handle_data_t *ret=NULL;
     int force=-1;
@@ -456,7 +491,7 @@ esp_err_t esp_intr_alloc_intrstatus(int source, int flags, uint32_t intrstatusre
         }
     }
     ESP_EARLY_LOGV(TAG, "esp_intr_alloc_intrstatus (cpu %d): Args okay. Resulting flags 0x%X", xPortGetCoreID(), flags);
-    
+
     //Check 'special' interrupt sources. These are tied to one specific interrupt, so we
     //have to force get_free_int to only look at that.
     if (source==ETS_INTERNAL_TIMER0_INTR_SOURCE) force=ETS_INTERNAL_TIMER0_INTR_NO;
@@ -513,7 +548,20 @@ esp_err_t esp_intr_alloc_intrstatus(int source, int flags, uint32_t intrstatusre
         //Mark as unusable for other interrupt sources. This is ours now!
         vd->flags=VECDESC_FL_NONSHARED;
         if (handler) {
+#if CONFIG_SYSVIEW_ENABLE
+            non_shared_isr_arg_t *ns_isr_arg=malloc(sizeof(non_shared_isr_arg_t));
+            if (!ns_isr_arg) {
+                portEXIT_CRITICAL(&spinlock);
+                free(ret);
+                return ESP_ERR_NO_MEM;
+            }
+            ns_isr_arg->isr=handler;
+            ns_isr_arg->isr_arg=arg;
+            ns_isr_arg->source=source;
+            xt_set_interrupt_handler(intr, non_shared_intr_isr, ns_isr_arg);
+#else
             xt_set_interrupt_handler(intr, handler, arg);
+#endif
         }
         if (flags&ESP_INTR_FLAG_EDGE) xthal_set_intclear(1 << intr);
         vd->source=source;
@@ -555,18 +603,18 @@ esp_err_t esp_intr_alloc_intrstatus(int source, int flags, uint32_t intrstatusre
     return ESP_OK;
 }
 
-esp_err_t esp_intr_alloc(int source, int flags, intr_handler_t handler, void *arg, intr_handle_t *ret_handle) 
+esp_err_t esp_intr_alloc(int source, int flags, intr_handler_t handler, void *arg, intr_handle_t *ret_handle)
 {
     /*
       As an optimization, we can create a table with the possible interrupt status registers and masks for every single
-      source there is. We can then add code here to look up an applicable value and pass that to the 
+      source there is. We can then add code here to look up an applicable value and pass that to the
       esp_intr_alloc_intrstatus function.
     */
     return esp_intr_alloc_intrstatus(source, flags, 0, 0, handler, arg, ret_handle);
 }
 
 
-esp_err_t esp_intr_free(intr_handle_t handle) 
+esp_err_t esp_intr_free(intr_handle_t handle)
 {
     bool free_shared_vector=false;
     if (!handle) return ESP_ERR_INVALID_ARG;
@@ -576,7 +624,7 @@ esp_err_t esp_intr_free(intr_handle_t handle)
     portENTER_CRITICAL(&spinlock);
     esp_intr_disable(handle);
     if (handle->vector_desc->flags&VECDESC_FL_SHARED) {
-        //Find and kill the shared int 
+        //Find and kill the shared int
         shared_vector_desc_t *svd=handle->vector_desc->shared_vec_info;
         shared_vector_desc_t *prevsvd=NULL;
         assert(svd); //should be something in there for a shared int
@@ -601,11 +649,19 @@ esp_err_t esp_intr_free(intr_handle_t handle)
 
     if ((handle->vector_desc->flags&VECDESC_FL_NONSHARED) || free_shared_vector) {
         ESP_LOGV(TAG, "esp_intr_free: Disabling int, killing handler");
+#if CONFIG_SYSVIEW_ENABLE
+        if (!free_shared_vector) {
+            void *isr_arg = xt_get_interrupt_handler_arg(handle->vector_desc->intno);
+            if (isr_arg) {
+                free(isr_arg);
+            }
+        }
+#endif
         //Reset to normal handler
         xt_set_interrupt_handler(handle->vector_desc->intno, xt_unhandled_interrupt, (void*)((int)handle->vector_desc->intno));
         //Theoretically, we could free the vector_desc... not sure if that's worth the few bytes of memory
-        //we save.(We can also not use the same exit path for empty shared ints anymore if we delete 
-        //the desc.) For now, just mark it as free. 
+        //we save.(We can also not use the same exit path for empty shared ints anymore if we delete
+        //the desc.) For now, just mark it as free.
         handle->vector_desc->flags&=!(VECDESC_FL_NONSHARED|VECDESC_FL_RESERVED);
         //Also kill non_iram mask bit.
         non_iram_int_mask[handle->vector_desc->cpu]&=~(1<<(handle->vector_desc->intno));

components/esp32/ld/esp32.common.ld

@@ -86,7 +86,8 @@ SECTIONS
     *libesp32.a:panic.o(.literal .text .literal.* .text.*)
     *libesp32.a:core_dump.o(.literal .text .literal.* .text.*)
     *libesp32.a:heap_alloc_caps.o(.literal .text .literal.* .text.*)
-    *libesp32.a:app_trace.o(.literal .text .literal.* .text.*)
+    *libapp_trace.a:(.literal .text .literal.* .text.*)
+    *libxtensa-debug-module.a:eri.o(.literal .text .literal.* .text.*)
     *libphy.a:(.literal .text .literal.* .text.*)
     *librtc.a:(.literal .text .literal.* .text.*)
     *libsoc.a:(.literal .text .literal.* .text.*)
@@ -111,8 +112,8 @@ SECTIONS
     KEEP(*(.jcr))
     *(.dram1 .dram1.*)
     *libesp32.a:panic.o(.rodata .rodata.*)
-    *libesp32.a:app_trace.o(.rodata .rodata.*)
     *libphy.a:(.rodata .rodata.*)
+    *libapp_trace.a:(.rodata .rodata.*)
     _data_end = ABSOLUTE(.);
     . = ALIGN(4);
   } >dram0_0_seg

components/esp32/panic.c

@@ -39,7 +39,15 @@
 #include "esp_spi_flash.h"
 #include "esp_cache_err_int.h"
 #include "esp_app_trace.h"
+#if CONFIG_SYSVIEW_ENABLE
+#include "SEGGER_RTT.h"
+#endif
 
+#if CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1
+#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   ESP_APPTRACE_TMO_INFINITE
+#else
+#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   (1000*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO)
+#endif
 /*
   Panic handlers; these get called when an unhandled exception occurs or the assembly-level
   task switching / interrupt code runs into an unrecoverable error. The default task stack
@@ -116,7 +124,12 @@ static __attribute__((noreturn)) inline void invoke_abort()
 {
     abort_called = true;
 #if CONFIG_ESP32_APPTRACE_ENABLE
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TRAX_BLOCK_SIZE*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TRAX_THRESH/100, CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#if CONFIG_SYSVIEW_ENABLE
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#else
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+                            APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#endif
 #endif
     while(1) {
         if (esp_cpu_in_ocd_debug_mode()) {
@@ -233,7 +246,12 @@ void panicHandler(XtExcFrame *frame)
 
     if (esp_cpu_in_ocd_debug_mode()) {
 #if CONFIG_ESP32_APPTRACE_ENABLE
-        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TRAX_BLOCK_SIZE*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TRAX_THRESH/100, CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#if CONFIG_SYSVIEW_ENABLE
+        SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#else
+        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+                                APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#endif
 #endif
         setFirstBreakpoint(frame->pc);
         return;
@@ -259,7 +277,12 @@ void xt_unhandled_exception(XtExcFrame *frame)
             panicPutHex(frame->pc);
             panicPutStr(". Setting bp and returning..\r\n");
 #if CONFIG_ESP32_APPTRACE_ENABLE
-            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TRAX_BLOCK_SIZE*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TRAX_THRESH/100, CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#if CONFIG_SYSVIEW_ENABLE
+            SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#else
+            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+                                    APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#endif
 #endif
             //Stick a hardware breakpoint on the address the handler returns to. This way, the OCD debugger
             //will kick in exactly at the context the error happened.
@@ -430,7 +453,12 @@ static __attribute__((noreturn)) void commonErrorHandler(XtExcFrame *frame)
 
 #if CONFIG_ESP32_APPTRACE_ENABLE
     disableAllWdts();
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TRAX_BLOCK_SIZE*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TRAX_THRESH/100, CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#if CONFIG_SYSVIEW_ENABLE
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#else
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+                            APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+#endif
     reconfigureAllWdts();
 #endif
 

components/ethernet/emac_main.c

@@ -236,7 +236,7 @@ static void emac_set_user_config_data(eth_config_t *config )
     emac_config.emac_phy_get_duplex_mode = config->phy_get_duplex_mode;
 #if DMA_RX_BUF_NUM > 9
     emac_config.emac_flow_ctrl_enable = config->flow_ctrl_enable;
-#else 
+#else
     if(config->flow_ctrl_enable == true) {
         ESP_LOGE(TAG, "eth flow ctrl init err!!! Please run make menuconfig and make sure DMA_RX_BUF_NUM > 9 .");
     }

components/freertos/component.mk

@@ -6,3 +6,6 @@ COMPONENT_ADD_LDFLAGS = -l$(COMPONENT_NAME) -Wl,--undefined=uxTopUsedPriority
 COMPONENT_ADD_INCLUDEDIRS := include
 COMPONENT_PRIV_INCLUDEDIRS := include/freertos
 
+#ifdef CONFIG_SYSVIEW_ENABLE
+#COMPONENT_ADD_INCLUDEDIRS += app_trace
+#endif

components/freertos/include/freertos/FreeRTOS.h

@@ -204,6 +204,10 @@ extern "C" {
 	#define INCLUDE_uxTaskGetStackHighWaterMark 0
 #endif
 
+#ifndef INCLUDE_pxTaskGetStackStart
+	#define INCLUDE_pxTaskGetStackStart 0
+#endif
+
 #ifndef INCLUDE_eTaskGetState
 	#define INCLUDE_eTaskGetState 0
 #endif
@@ -406,6 +410,22 @@ extern "C" {
 	#define traceMOVED_TASK_TO_READY_STATE( pxTCB )
 #endif
 
+#ifndef traceREADDED_TASK_TO_READY_STATE
+	#define traceREADDED_TASK_TO_READY_STATE( pxTCB )	traceMOVED_TASK_TO_READY_STATE( pxTCB )
+#endif
+
+#ifndef traceMOVED_TASK_TO_DELAYED_LIST
+	#define traceMOVED_TASK_TO_DELAYED_LIST()
+#endif
+
+#ifndef traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST
+	#define traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST()
+#endif
+
+#ifndef traceMOVED_TASK_TO_SUSPENDED_LIST
+	#define traceMOVED_TASK_TO_SUSPENDED_LIST( pxTCB )
+#endif
+
 #ifndef traceQUEUE_CREATE
 	#define traceQUEUE_CREATE( pxNewQueue )
 #endif
@@ -618,6 +638,22 @@ extern "C" {
 	#define traceQUEUE_REGISTRY_ADD(xQueue, pcQueueName)
 #endif
 
+#ifndef traceTASK_NOTIFY_GIVE_FROM_ISR
+ 	#define traceTASK_NOTIFY_GIVE_FROM_ISR()
+ #endif
+ 
+#ifndef traceISR_EXIT_TO_SCHEDULER
+	#define traceISR_EXIT_TO_SCHEDULER()
+#endif
+
+#ifndef traceISR_EXIT
+	#define traceISR_EXIT()
+#endif
+
+#ifndef traceISR_ENTER
+	#define traceISR_ENTER(_n_)
+#endif
+
 #ifndef configGENERATE_RUN_TIME_STATS
 	#define configGENERATE_RUN_TIME_STATS 0
 #endif

components/freertos/include/freertos/FreeRTOSConfig.h

@@ -227,6 +227,7 @@
 #define INCLUDE_vTaskDelay					1
 #define INCLUDE_uxTaskGetStackHighWaterMark	1
 #define INCLUDE_pcTaskGetTaskName			1
+#define INCLUDE_xTaskGetIdleTaskHandle      1
 
 #if CONFIG_ENABLE_MEMORY_DEBUG
 #define configENABLE_MEMORY_DEBUG 1
@@ -276,6 +277,12 @@ extern void vPortCleanUpTCB ( void *pxTCB );
 #define configENABLE_TASK_SNAPSHOT			1
 #endif
 
+#if CONFIG_SYSVIEW_ENABLE
+#ifndef __ASSEMBLER__
+#include "SEGGER_SYSVIEW_FreeRTOS.h"
+#undef INLINE // to avoid redefinition
+#endif /* def __ASSEMBLER__ */
+#endif
 
 #endif /* FREERTOS_CONFIG_H */
 

components/freertos/include/freertos/portmacro.h

@@ -268,7 +268,7 @@ static inline void uxPortCompareSet(volatile uint32_t *addr, uint32_t compare, u
 void vPortYield( void );
 void _frxt_setup_switch( void );
 #define portYIELD()					vPortYield()
-#define portYIELD_FROM_ISR()		_frxt_setup_switch()
+#define portYIELD_FROM_ISR()        {traceISR_EXIT_TO_SCHEDULER(); _frxt_setup_switch();}
 
 static inline uint32_t xPortGetCoreID();
 

components/freertos/include/freertos/task.h

@@ -1297,6 +1297,25 @@ char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint
  */
 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
+/**
+ * task.h
+ * <PRE>uint8_t* pxTaskGetStackStart( TaskHandle_t xTask);</PRE>
+ *
+ * INCLUDE_pxTaskGetStackStart must be set to 1 in FreeRTOSConfig.h for
+ * this function to be available.
+ *
+ * Returns the start of the stack associated with xTask.  That is,
+ * the highest stack memory address on architectures where the stack grows down
+ * from high memory, and the lowest memory address on architectures where the
+ * stack grows up from low memory.
+ *
+ * @param xTask Handle of the task associated with the stack returned.
+ * Set xTask to NULL to return the stack of the calling task.
+ *
+ * @return A pointer to the start of the stack.
+ */
+uint8_t* pxTaskGetStackStart( TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+
 /* When using trace macros it is sometimes necessary to include task.h before
 FreeRTOS.h.  When this is done TaskHookFunction_t will not yet have been defined,
 so the following two prototypes will cause a compilation error.  This can be

components/freertos/include/freertos/xtensa_api.h

@@ -117,6 +117,14 @@ static inline void xt_set_intclear(unsigned int arg)
     xthal_set_intclear(arg);
 }
 
+/*
+-------------------------------------------------------------------------------
+  Call this function to get handler's argument for the specified interrupt.
+ 
+    n        - Interrupt number.
+-------------------------------------------------------------------------------
+*/
+extern void * xt_get_interrupt_handler_arg(int n);
 
 #endif /* __XTENSA_API_H__ */
 

components/freertos/port.c

@@ -105,6 +105,8 @@
 
 #include "esp_crosscore_int.h"
 
+#include "esp_intr_alloc.h"
+
 /* Defined in portasm.h */
 extern void _frxt_tick_timer_init(void);
 
@@ -112,6 +114,13 @@ extern void _frxt_tick_timer_init(void);
 extern void _xt_coproc_init(void);
 
 
+#if CONFIG_FREERTOS_CORETIMER_0
+    #define SYSTICK_INTR_ID (ETS_INTERNAL_TIMER0_INTR_SOURCE+ETS_INTERNAL_INTR_SOURCE_OFF)
+#endif
+#if CONFIG_FREERTOS_CORETIMER_1
+    #define SYSTICK_INTR_ID (ETS_INTERNAL_TIMER1_INTR_SOURCE+ETS_INTERNAL_INTR_SOURCE_OFF)
+#endif
+
 /*-----------------------------------------------------------*/
 
 unsigned port_xSchedulerRunning[portNUM_PROCESSORS] = {0}; // Duplicate of inaccessible xSchedulerRunning; needed at startup to avoid counting nesting
@@ -122,7 +131,7 @@ unsigned port_interruptNesting[portNUM_PROCESSORS] = {0};  // Interrupt nesting
 // User exception dispatcher when exiting
 void _xt_user_exit(void);
 
-/* 
+/*
  * Stack initialization
  */
 #if portUSING_MPU_WRAPPERS
@@ -222,12 +231,14 @@ BaseType_t xPortSysTickHandler( void )
 	BaseType_t ret;
 
 	portbenchmarkIntLatency();
+	traceISR_ENTER(SYSTICK_INTR_ID);
 	ret = xTaskIncrementTick();
 	if( ret != pdFALSE )
 	{
 		portYIELD_FROM_ISR();
+	} else {
+		traceISR_EXIT();
 	}
-
 	return ret;
 }
 

components/freertos/portasm.S

@@ -30,7 +30,6 @@
 
 .extern pxCurrentTCB
 
-
 /*
 *******************************************************************************
 * Interrupt stack. The size of the interrupt stack is determined by the config
@@ -42,6 +41,7 @@
     .align      16
     .global     port_IntStack
     .global     port_IntStackTop
+    .global     port_switch_flag
 port_IntStack:
     .space      configISR_STACK_SIZE*portNUM_PROCESSORS		/* This allocates stacks for each individual CPU. */
 port_IntStackTop:

components/freertos/queue.c

@@ -70,7 +70,7 @@
 
 
 /*
- ToDo: The multicore implementation of this uses taskENTER_CRITICAL etc to make sure the 
+ ToDo: The multicore implementation of this uses taskENTER_CRITICAL etc to make sure the
  queue structures aren't accessed by another processor or core. It would be useful to have
  IRQs be able to schedule stuff while doing task-related stuff, meaning we have to convert
  the taskENTER_CRITICAL stuff to a lock + a scheduler suspend instead.
@@ -262,7 +262,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 
 	configASSERT( pxQueue );
 
-	if ( xNewQueue == pdTRUE ) 
+	if ( xNewQueue == pdTRUE )
 	{
 		vPortCPUInitializeMutex(&pxQueue->mux);
 	}
@@ -1181,7 +1181,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 		if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
 		{
 			traceQUEUE_SEND_FROM_ISR( pxQueue );
-	
+
 			/* A task can only have an inherited priority if it is a mutex
 			holder - and if there is a mutex holder then the mutex cannot be
 			given from an ISR.  Therefore, unlike the xQueueGenericGive()
@@ -2315,7 +2315,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 	void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcQueueName ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 	{
 	UBaseType_t ux;
-		
+
 		UNTESTED_FUNCTION();
 		/* See if there is an empty space in the registry.  A NULL name denotes
 		a free slot. */

components/freertos/tasks.c

@@ -277,7 +277,7 @@ PRIVILEGED_DATA static List_t xPendingReadyList[ portNUM_PROCESSORS ];						/*<
 
 #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
 
-	PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle = NULL;			/*< Holds the handle of the idle task.  The idle task is created automatically when the scheduler is started. */
+	PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle[portNUM_PROCESSORS] = {NULL};			/*< Holds the handle of the idle task.  The idle task is created automatically when the scheduler is started. */
 
 #endif
 
@@ -314,6 +314,12 @@ PRIVILEGED_DATA static portMUX_TYPE xTickCountMutex = portMUX_INITIALIZER_UNLOCK
 
 #endif
 
+
+// per-CPU flags indicating that we are doing context switch, it is used by apptrace and sysview modules
+// in order to avoid calls of vPortYield from traceTASK_SWITCHED_IN/OUT when waiting
+// for locks to be free or for host to read full trace buffer
+PRIVILEGED_DATA static volatile BaseType_t xSwitchingContext[ portNUM_PROCESSORS ]  = { pdFALSE };
+
 /*lint +e956 */
 
 /* Debugging and trace facilities private variables and macros. ------------*/
@@ -436,12 +442,20 @@ count overflows. */
  * the task.  It is inserted at the end of the list.
  */
 #define prvAddTaskToReadyList( pxTCB )																\
-	traceMOVED_TASK_TO_READY_STATE( pxTCB )															\
+	traceMOVED_TASK_TO_READY_STATE( pxTCB );														\
 	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );												\
 	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) )
+/*
+ * Place the task represented by pxTCB which has been in a ready list before
+ * into the appropriate ready list for the task.
+ * It is inserted at the end of the list.
+ */
+#define prvReaddTaskToReadyList( pxTCB )                                                               \
+   traceREADDED_TASK_TO_READY_STATE( pxTCB );                                                      \
+   taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );                                             \
+   vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) )
 /*-----------------------------------------------------------*/
 
-
 #define tskCAN_RUN_HERE( cpuid ) ( cpuid==xPortGetCoreID() || cpuid==tskNO_AFFINITY )
 
 /*
@@ -621,7 +635,7 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode
 
 /*
  * This routine tries to send an interrupt to another core if needed to make it execute a task
- * of higher priority. We try to figure out if needed first by inspecting the pxTCB of the 
+ * of higher priority. We try to figure out if needed first by inspecting the pxTCB of the
  * other CPU first. Specifically for Xtensa, we can do this because pxTCB is an atomic pointer. It
  * is possible that it is inaccurate because the other CPU just did a task switch, but in that case
  * at most a superfluous interrupt is generated.
@@ -1046,8 +1060,8 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode
 {
 	TCB_t *curTCB, *tcb0, *tcb1;
 
-	/* Assure that xCoreID is valid or we'll have an out-of-bounds on pxCurrentTCB 
-	   You will assert here if e.g. you only have one CPU enabled in menuconfig and 
+	/* Assure that xCoreID is valid or we'll have an out-of-bounds on pxCurrentTCB
+	   You will assert here if e.g. you only have one CPU enabled in menuconfig and
 	   are trying to start a task on core 1. */
 	configASSERT( xCoreID == tskNO_AFFINITY || xCoreID < portNUM_PROCESSORS);
 
@@ -1609,7 +1623,7 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode
 						{
 							xYieldRequired = pdTRUE;
 						}
-						else if ( pxTCB->xCoreID != xPortGetCoreID() ) 
+						else if ( pxTCB->xCoreID != xPortGetCoreID() )
 						{
 							taskYIELD_OTHER_CORE( pxTCB->xCoreID, uxNewPriority );
 						}
@@ -1697,7 +1711,7 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode
 					{
 						mtCOVERAGE_TEST_MARKER();
 					}
-					prvAddTaskToReadyList( pxTCB );
+                    prvReaddTaskToReadyList( pxTCB );
 				}
 				else
 				{
@@ -1758,7 +1772,7 @@ static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB, TaskFunction_t pxTaskCode
 			{
 				mtCOVERAGE_TEST_MARKER();
 			}
-
+            traceMOVED_TASK_TO_SUSPENDED_LIST(pxTCB);
 			vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );
 			curTCB = pxCurrentTCB[ xPortGetCoreID() ];
 		}
@@ -2064,7 +2078,7 @@ void vTaskEndScheduler( void )
 
 
 #if ( configUSE_NEWLIB_REENTRANT == 1 )
-//Return global reent struct if FreeRTOS isn't running, 
+//Return global reent struct if FreeRTOS isn't running,
 struct _reent* __getreent() {
 	//No lock needed because if this changes, we won't be running anymore.
 	TCB_t *currTask=xTaskGetCurrentTaskHandle();
@@ -2353,8 +2367,8 @@ UBaseType_t uxTaskGetNumberOfTasks( void )
 	{
 		/* If xTaskGetIdleTaskHandle() is called before the scheduler has been
 		started, then xIdleTaskHandle will be NULL. */
-		configASSERT( ( xIdleTaskHandle != NULL ) );
-		return xIdleTaskHandle;
+		configASSERT( ( xIdleTaskHandle[ xPortGetCoreID() ] != NULL ) );
+		return xIdleTaskHandle[ xPortGetCoreID() ];
 	}
 
 #endif /* INCLUDE_xTaskGetIdleTaskHandle */
@@ -2393,7 +2407,7 @@ BaseType_t xSwitchRequired = pdFALSE;
 
 	/* Only let core 0 increase the tick count, to keep accurate track of time. */
 	/* ToDo: This doesn't really play nice with the logic below: it means when core 1 is
-	   running a low-priority task, it will keep running it until there is a context 
+	   running a low-priority task, it will keep running it until there is a context
 	   switch, even when this routine (running on core 0) unblocks a bunch of high-priority
 	   tasks... this is less than optimal -- JD. */
 	if ( xPortGetCoreID()!=0 ) {
@@ -2688,6 +2702,7 @@ void vTaskSwitchContext( void )
 	else
 	{
 		xYieldPending[ xPortGetCoreID() ] = pdFALSE;
+        xSwitchingContext[ xPortGetCoreID() ] = pdTRUE;
 		traceTASK_SWITCHED_OUT();
 
 		#if ( configGENERATE_RUN_TIME_STATS == 1 )
@@ -2724,7 +2739,7 @@ void vTaskSwitchContext( void )
 		taskSECOND_CHECK_FOR_STACK_OVERFLOW();
 
 		/* Select a new task to run */
-		
+
 		/*
 		 We cannot do taskENTER_CRITICAL_ISR(&xTaskQueueMutex); here because it saves the interrupt context to the task tcb, and we're
 		 swapping that out here. Instead, we're going to do the work here ourselves. Because interrupts are already disabled, we only
@@ -2735,11 +2750,11 @@ void vTaskSwitchContext( void )
 #else
 		vPortCPUAcquireMutex( &xTaskQueueMutex );
 #endif
-		
+
 		unsigned portBASE_TYPE foundNonExecutingWaiter = pdFALSE, ableToSchedule = pdFALSE, resetListHead;
 		portBASE_TYPE uxDynamicTopReady = uxTopReadyPriority;
 		unsigned portBASE_TYPE holdTop=pdFALSE;
-		
+
 		/*
 		 *  ToDo: This scheduler doesn't correctly implement the round-robin scheduling as done in the single-core
 		 *  FreeRTOS stack when multiple tasks have the same priority and are all ready; it just keeps grabbing the
@@ -2747,21 +2762,21 @@ void vTaskSwitchContext( void )
 		 *  (Is this still true? if any, there's the issue with one core skipping over the processes for the other
 		 *  core, potentially not giving the skipped-over processes any time.)
 		 */
-		
+
 		while ( ableToSchedule == pdFALSE && uxDynamicTopReady >= 0 )
 		{
 			resetListHead = pdFALSE;
 			// Nothing to do for empty lists
 			if (!listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxDynamicTopReady ] ) )) {
-				
+
 				ableToSchedule = pdFALSE;
 				tskTCB * pxRefTCB;
-				
+
 				/* Remember the current list item so that we
 				can detect if all items have been inspected.
 				Once this happens, we move on to a lower
 				priority list (assuming nothing is suitable
-				for scheduling). Note: This can return NULL if 
+				for scheduling). Note: This can return NULL if
 				the list index is at the listItem */
 				pxRefTCB = pxReadyTasksLists[ uxDynamicTopReady ].pxIndex->pvOwner;
 
@@ -2769,7 +2784,7 @@ void vTaskSwitchContext( void )
 					//pxIndex points to the list end marker. Skip that and just get the next item.
 					listGET_OWNER_OF_NEXT_ENTRY( pxRefTCB, &( pxReadyTasksLists[ uxDynamicTopReady ] ) );
 				}
-				
+
 				do {
 					listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ uxDynamicTopReady ] ) );
 					/* Find out if the next task in the list is
@@ -2785,7 +2800,7 @@ void vTaskSwitchContext( void )
 							break;
 						}
 					}
-					
+
 					if (foundNonExecutingWaiter == pdTRUE) {
 						/* If the task is not being executed
 						by another core and its affinity is
@@ -2804,7 +2819,7 @@ void vTaskSwitchContext( void )
 					} else {
 						ableToSchedule = pdFALSE;
 					}
-					
+
 					if (ableToSchedule == pdFALSE) {
 						resetListHead = pdTRUE;
 					} else if ((ableToSchedule == pdTRUE) && (resetListHead == pdTRUE)) {
@@ -2821,6 +2836,7 @@ void vTaskSwitchContext( void )
 		}
 
 		traceTASK_SWITCHED_IN();
+        xSwitchingContext[ xPortGetCoreID() ] = pdFALSE;
 
 		//Exit critical region manually as well: release the mux now, interrupts will be re-enabled when we
 		//exit the function.
@@ -2834,7 +2850,6 @@ void vTaskSwitchContext( void )
 		vPortSetStackWatchpoint(pxCurrentTCB[xPortGetCoreID()]->pxStack);
 #endif
 
-
 	}
 	portEXIT_CRITICAL_NESTED(irqstate);
 }
@@ -2875,6 +2890,7 @@ TickType_t xTimeToWake;
 			/* Add the task to the suspended task list instead of a delayed task
 			list to ensure the task is not woken by a timing event.  It will
 			block indefinitely. */
+            traceMOVED_TASK_TO_SUSPENDED_LIST(pxCurrentTCB);
 			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB[ xPortGetCoreID() ]->xGenericListItem ) );
 		}
 		else
@@ -3567,7 +3583,7 @@ static void prvCheckTasksWaitingTermination( void )
 						break;
 					}
 				}
-				
+
 				#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 ) && ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS )
 				{
 					int x;
@@ -3586,7 +3602,7 @@ static void prvCheckTasksWaitingTermination( void )
 			{
 				mtCOVERAGE_TEST_MARKER();
 			}
-		}		
+		}
 		taskEXIT_CRITICAL(&xTaskQueueMutex);
 	}
 	#endif /* vTaskDelete */
@@ -3601,11 +3617,13 @@ static void prvAddCurrentTaskToDelayedList( const BaseType_t xCoreID, const Tick
 
 	if( xTimeToWake < xTickCount )
 	{
+        traceMOVED_TASK_TO_OVERFLOW_DELAYED_LIST();
 		/* Wake time has overflowed.  Place this item in the overflow list. */
 		vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB[ xCoreID ]->xGenericListItem ) );
 	}
 	else
 	{
+        traceMOVED_TASK_TO_DELAYED_LIST();
 		/* The wake time has not overflowed, so the current block list is used. */
 		vListInsert( pxDelayedTaskList, &( pxCurrentTCB[ xCoreID ]->xGenericListItem ) );
 
@@ -3749,7 +3767,6 @@ BaseType_t xTaskGetAffinity( TaskHandle_t xTask )
 	uint8_t *pucEndOfStack;
 	UBaseType_t uxReturn;
 
-		UNTESTED_FUNCTION();
 		pxTCB = prvGetTCBFromHandle( xTask );
 
 		#if portSTACK_GROWTH < 0
@@ -3770,6 +3787,19 @@ BaseType_t xTaskGetAffinity( TaskHandle_t xTask )
 #endif /* INCLUDE_uxTaskGetStackHighWaterMark */
 /*-----------------------------------------------------------*/
 
+#if (INCLUDE_pxTaskGetStackStart == 1)
+   uint8_t* pxTaskGetStackStart( TaskHandle_t xTask)
+   {
+   TCB_t *pxTCB;
+   UBaseType_t uxReturn;
+
+       pxTCB = prvGetTCBFromHandle( xTask );
+       return ( uint8_t * ) pxTCB->pxStack;
+   }
+
+#endif /* INCLUDE_pxTaskGetStackStart */
+/*-----------------------------------------------------------*/
+
 #if ( INCLUDE_vTaskDelete == 1 )
 
 
@@ -3954,7 +3984,7 @@ TCB_t *pxTCB;
 
 					/* Inherit the priority before being moved into the new list. */
 					pxTCB->uxPriority = pxCurrentTCB[ xPortGetCoreID() ]->uxPriority;
-					prvAddTaskToReadyList( pxTCB );
+                    prvReaddTaskToReadyList( pxTCB );
 				}
 				else
 				{
@@ -4025,7 +4055,7 @@ TCB_t *pxTCB;
 					any other purpose if this task is running, and it must be
 					running to give back the mutex. */
 					listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) pxTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
-					prvAddTaskToReadyList( pxTCB );
+                    prvReaddTaskToReadyList( pxTCB );
 
 					/* Return true to indicate that a context switch is required.
 					This is only actually required in the corner case whereby
@@ -4066,7 +4096,7 @@ TCB_t *pxTCB;
 /* Gotcha (which seems to be deliberate in FreeRTOS, according to
 http://www.freertos.org/FreeRTOS_Support_Forum_Archive/December_2012/freertos_PIC32_Bug_-_vTaskEnterCritical_6400806.html
 ) is that calling vTaskEnterCritical followed by vTaskExitCritical will leave the interrupts DISABLED when the scheduler
-is not running.  Re-enabling the scheduler will re-enable the interrupts instead. 
+is not running.  Re-enabling the scheduler will re-enable the interrupts instead.
 
 For ESP32 FreeRTOS, vTaskEnterCritical implements both portENTER_CRITICAL and portENTER_CRITICAL_ISR.
 */
@@ -4112,11 +4142,11 @@ For ESP32 FreeRTOS, vTaskEnterCritical implements both portENTER_CRITICAL and po
 			protect against recursive calls if the assert function also uses a
 			critical section. */
 
-			/* DISABLED in the esp32 port - because of SMP, For ESP32 
-			FreeRTOS, vTaskEnterCritical implements both 
+			/* DISABLED in the esp32 port - because of SMP, For ESP32
+			FreeRTOS, vTaskEnterCritical implements both
 			portENTER_CRITICAL and portENTER_CRITICAL_ISR. vTaskEnterCritical
 			has to be used in way more places than before, and some are called
-			both from ISR as well as non-ISR code, thus we re-organized 
+			both from ISR as well as non-ISR code, thus we re-organized
 			vTaskEnterCritical to also work in ISRs. */
 #if 0
 			if( pxCurrentTCB[ xPortGetCoreID() ]->uxCriticalNesting == 1 )
@@ -4177,7 +4207,7 @@ For ESP32 FreeRTOS, vTaskExitCritical implements both portEXIT_CRITICAL and port
 			mtCOVERAGE_TEST_MARKER();
 		}
 	}
-	
+
 #endif /* portCRITICAL_NESTING_IN_TCB */
 /*-----------------------------------------------------------*/
 
@@ -4508,6 +4538,7 @@ TickType_t uxReturn;
 							of a delayed task list to ensure the task is not
 							woken by a timing event.  It will block
 							indefinitely. */
+                            traceMOVED_TASK_TO_SUSPENDED_LIST(pxCurrentTCB);
 							vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB[ xPortGetCoreID() ]->xGenericListItem ) );
 						}
 						else
@@ -4624,6 +4655,7 @@ TickType_t uxReturn;
 							of a delayed task list to ensure the task is not
 							woken by a timing event.  It will block
 							indefinitely. */
+                            traceMOVED_TASK_TO_SUSPENDED_LIST(pxCurrentTCB);
 							vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB[ xPortGetCoreID() ]->xGenericListItem ) );
 						}
 						else
@@ -4929,7 +4961,7 @@ TickType_t uxReturn;
 					this task pending until the scheduler is resumed. */
 					vListInsertEnd( &( xPendingReadyList[ xPortGetCoreID() ] ), &( pxTCB->xEventListItem ) );
 				}
-				
+
 				if( tskCAN_RUN_HERE(pxTCB->xCoreID) && pxTCB->uxPriority > pxCurrentTCB[ xPortGetCoreID() ]->uxPriority )
 				{
 					/* The notified task has a priority above the currently
@@ -4956,6 +4988,22 @@ TickType_t uxReturn;
 
 #if ( configENABLE_TASK_SNAPSHOT == 1 )
 
+    static void prvTaskGetSnapshot( TaskSnapshot_t *pxTaskSnapshotArray, UBaseType_t *uxTask, TCB_t *pxTCB )
+    {
+        pxTaskSnapshotArray[ *uxTask ].pxTCB = pxTCB;
+        pxTaskSnapshotArray[ *uxTask ].pxTopOfStack = (StackType_t *)pxTCB->pxTopOfStack;
+        #if( portSTACK_GROWTH < 0 )
+        {
+            pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxTCB->pxEndOfStack;
+        }
+        #else
+        {
+            pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxTCB->pxStack;
+        }
+        #endif
+        (*uxTask)++;
+    }
+
 	static void prvTaskGetSnapshotsFromList( TaskSnapshot_t *pxTaskSnapshotArray, UBaseType_t *uxTask, const UBaseType_t uxArraySize, List_t *pxList )
 	{
 		TCB_t *pxNextTCB, *pxFirstTCB;
@@ -4970,20 +5018,7 @@ TickType_t uxReturn;
 				if( *uxTask >= uxArraySize )
 					break;
 
-				pxTaskSnapshotArray[ *uxTask ].pxTCB = pxNextTCB;
-				pxTaskSnapshotArray[ *uxTask ].pxTopOfStack = (StackType_t *)pxNextTCB->pxTopOfStack;
-				#if( portSTACK_GROWTH < 0 )
-				{
-					pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxNextTCB->pxEndOfStack;
-				}
-				#else
-				{
-					pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxNextTCB->pxStack;
-				}
-				#endif
-
-				(*uxTask)++;
-
+                prvTaskGetSnapshot( pxTaskSnapshotArray, uxTask, pxNextTCB );
 			} while( pxNextTCB != pxFirstTCB );
 		}
 		else
@@ -4996,35 +5031,41 @@ TickType_t uxReturn;
 	{
 		UBaseType_t uxTask = 0, i = 0;
 
+PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB[ portNUM_PROCESSORS ] = { NULL };
+
+
 		*pxTcbSz = sizeof(TCB_t);
-
+		/* Fill in an TaskStatus_t structure with information on each
+		task in the Ready state. */
+		i = configMAX_PRIORITIES;
+		do
 		{
-			/* Fill in an TaskStatus_t structure with information on each
-			task in the Ready state. */
-			i = configMAX_PRIORITIES;
-			do
-			{
-				i--;
-				prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &( pxReadyTasksLists[ i ] ) );
-			} while( i > ( UBaseType_t ) tskIDLE_PRIORITY ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
+			i--;
+			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &( pxReadyTasksLists[ i ] ) );
+		} while( i > ( UBaseType_t ) tskIDLE_PRIORITY ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
 
-			/* Fill in an TaskStatus_t structure with information on each
-			task in the Blocked state. */
-			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, ( List_t * ) pxDelayedTaskList );
-			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, ( List_t * ) pxOverflowDelayedTaskList );
+		/* Fill in an TaskStatus_t structure with information on each
+		task in the Blocked state. */
+		prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, ( List_t * ) pxDelayedTaskList );
+		prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, ( List_t * ) pxOverflowDelayedTaskList );
+        for (i = 0; i < portNUM_PROCESSORS; i++) {
+            if( uxTask >= uxArraySize )
+                    break;
+            prvTaskGetSnapshot( pxTaskSnapshotArray, &uxTask, pxCurrentTCB[ i ] );
+            prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &( xPendingReadyList[ i ] ) );
+        }
 
-			#if( INCLUDE_vTaskDelete == 1 )
-			{
-				prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &xTasksWaitingTermination );
-			}
-			#endif
-
-			#if ( INCLUDE_vTaskSuspend == 1 )
-			{
-				prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &xSuspendedTaskList );
-			}
-			#endif
+		#if( INCLUDE_vTaskDelete == 1 )
+		{
+			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &xTasksWaitingTermination );
 		}
+		#endif
+
+		#if ( INCLUDE_vTaskSuspend == 1 )
+		{
+			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, &xSuspendedTaskList );
+		}
+		#endif
 		return uxTask;
 	}
 

components/freertos/timers.c

@@ -780,9 +780,9 @@ static void prvCheckForValidListAndQueue( void )
 	/* Check that the list from which active timers are referenced, and the
 	queue used to communicate with the timer service, have been
 	initialised. */
-	
+
 	/* Erm, yes, this is a problem. We can't lock until the lock is initialized, and we can't initialize the lock
-	   atomically because we don't have a lock yet... I'm pretty sure doubly-initializing a lock on 2 cpus 
+	   atomically because we don't have a lock yet... I'm pretty sure doubly-initializing a lock on 2 cpus
 	   is no problem in the current implementation, but this is not a nice way to solve things. ToDo - improve. */
 
 	if( xTimerQueue == NULL ) vPortCPUInitializeMutex( &xTimerMux );

components/freertos/xtensa_intr.c

@@ -138,6 +138,21 @@ xt_handler xt_set_interrupt_handler(int n, xt_handler f, void * arg)
     return ((old == &xt_unhandled_interrupt) ? 0 : old);
 }
 
+#if CONFIG_SYSVIEW_ENABLE
+void * xt_get_interrupt_handler_arg(int n)
+{
+    xt_handler_table_entry * entry;
+
+    if( n < 0 || n >= XCHAL_NUM_INTERRUPTS )
+        return 0;       /* invalid interrupt number */
+
+    /* Convert exception number to _xt_exception_table name */
+    n = n * portNUM_PROCESSORS + xPortGetCoreID();
+
+    entry = _xt_interrupt_table + n;
+    return entry->arg;
+}
+#endif
 
 #endif /* XCHAL_HAVE_INTERRUPTS */
 

docs/Doxyfile

@@ -1,7 +1,7 @@
 # This is Doxygen configuration file
 #
 # Doxygen provides over 260 configuration statements
-# To make this file easier to follow, 
+# To make this file easier to follow,
 # it contains only statements that are non-default
 #
 # NOTE:
@@ -17,7 +17,7 @@ PROJECT_NAME = "ESP32 Programming Guide"
 
 ## The 'INPUT' statement below is used as input by script 'gen-df-input.py'
 ## to automatically generate API reference list files heder_file.inc
-## These files are placed in '_inc' directory 
+## These files are placed in '_inc' directory
 ## and used to include in API reference documentation
 
 INPUT = \
@@ -126,10 +126,14 @@ INPUT = \
     ## ULP Coprocessor - API Guides
     ##
     ## NOTE: for line below header_file.inc is not used
-    ../components/ulp/include/esp32/ulp.h
+    ../components/ulp/include/esp32/ulp.h \
+    ##
+    ## Application Level Tracing - API Reference
+    ##
+    ../components/app_trace/include/esp_app_trace.h
 
 
-## Get warnings for functions that have no documentation for their parameters or return value 
+## Get warnings for functions that have no documentation for their parameters or return value
 ##
 WARN_NO_PARAMDOC = YES
 

docs/api-guides/SYSVIEW_FreeRTOS.txt

@@ -0,0 +1,104 @@
+128        vTaskAllocateMPURegions             xTask=%t pxRegions=%u
+33        vTaskDelete                         xTaskToDelete=%t
+34        vTaskDelay                          xTicksToDelay=%u
+35        vTaskDelayUntil                     
+129        uxTaskPriorityGet                   xTask=%t
+56        uxTaskPriorityGetFromISR            xTask=%t
+130        eTaskGetState                       xTask=%t
+55        vTaskPrioritySet                    xTask=%t uxNewPriority=%u
+36        vTaskSuspend                        xTaskToSuspend=%t
+40        vTaskResume                         xTaskToResume=%t
+43        xTaskResumeFromISR                  xTaskToResume=%t
+131        vTaskStartScheduler                  
+132        vTaskEndScheduler                    
+133        vTaskSuspendAll                      
+134        xTaskResumeAll                       
+135        xTaskGetTickCount                    
+57        xTaskGetTickCountFromISR             
+136        uxTaskGetNumberOfTasks               
+137        pcTaskGetTaskName                   xTaskToQuery=%t
+138        uxTaskGetStackHighWaterMark         xTask=%t
+139        vTaskSetApplicationTaskTag          xTask=%t pxHookFunction=%u
+140        xTaskGetApplicationTaskTag          xTask=%t
+141        vTaskSetThreadLocalStoragePointer   xTaskToSet=%T xIndex=%u pvValue=%u
+142        pvTaskGetThreadLocalStoragePointer  xTaskToQuery=%T xIndex=%u
+143        xTaskCallApplicationTaskHook        xTask=%T pvParameter=%u
+144        xTaskGetIdleTaskHandle               
+145        uxTaskGetSystemState                pxTaskStatusArray=%u uxArraySize=%u pulTotalRunTime=%u
+146        vTaskList                           pcWriteBuffer=%u
+147        vTaskGetRunTimeStats                pcWriteBuffer=%u
+44        xTaskGenericNotify                  xTaskToNotify=%t ulValue=%u eAction=%u pulPreviousNotificationValue=%u
+45        xTaskGenericNotifyFromISR           xTaskToNotify=%t ulValue=%u eAction=%u pulPreviousNotificationValue=%u pxHigherPriorityTaskWoken=%u
+46        xTaskNotifyWait                     ulBitsToClearOnEntry=%u ulBitsToClearOnExit=%u pulNotificationValue=%u xTicksToWait=%u
+38        vTaskNotifyGiveFromISR              xTaskToNotify=%t pxHigherPriorityTaskWoken=%u
+37        ulTaskNotifyTake                    xClearCountOnExit=%u xTicksToWait=%u
+148        xTaskNotifyStateClear               xTask=%t
+149        xTaskGetCurrentTaskHandle            
+150        vTaskSetTimeOutState                pxTimeOut=%u
+151        xTaskCheckForTimeOut                pxTimeOut=%u pxTicksToWait=%u
+152        vTaskMissedYield                     
+153        xTaskGetSchedulerState               
+39        vTaskPriorityInherit                pxMutexHolder=%p
+42        xTaskPriorityDisinherit             pxMutexHolder=%p
+154        xTaskGenericCreate                  pxTaskCode=%u pcName=%u usStackDepth=%u pvParameters=%u uxPriority=%u pxCreatedTask=%u puxStackBuffer=%u xRegions=%u
+155        uxTaskGetTaskNumber                 xTask=%u
+156        vTaskSetTaskNumber                  xTask=%u uxHandle=%u
+41        vTaskStepTick                       xTicksToJump=%u
+157        eTaskConfirmSleepModeStatus          
+158        xTimerCreate                        pcTimerName=%u xTimerPeriodInTicks=%u uxAutoReload=%u pvTimerID=%u pxCallbackFunction=%u
+159        pvTimerGetTimerID                   xTimer=%u
+160        vTimerSetTimerID                    xTimer=%u pvNewID=%u
+161        xTimerIsTimerActive                 xTimer=%u
+162        xTimerGetTimerDaemonTaskHandle       
+163        xTimerPendFunctionCallFromISR       xFunctionToPend=%u pvParameter1=%u ulParameter2=%u pxHigherPriorityTaskWoken=%u
+164        xTimerPendFunctionCall              xFunctionToPend=%u pvParameter1=%u ulParameter2=%u xTicksToWait=%u
+165        pcTimerGetTimerName                 xTimer=%u
+166        xTimerCreateTimerTask                
+167        xTimerGenericCommand                xTimer=%u xCommandID=%u xOptionalValue=%u pxHigherPriorityTaskWoken=%u xTicksToWait=%u
+53        xQueueGenericSend                   xQueue=%I pvItemToQueue=%p xTicksToWait=%u xCopyPosition=%u
+50        xQueuePeekFromISR                   xQueue=%I pvBuffer=%p
+49        xQueueGenericReceive                xQueue=%I pvBuffer=%p xTicksToWait=%u xJustPeek=%u
+168        uxQueueMessagesWaiting              xQueue=%I
+169        uxQueueSpacesAvailable              xQueue=%I
+48        vQueueDelete                        xQueue=%I
+54        xQueueGenericSendFromISR            xQueue=%I pvItemToQueue=%p pxHigherPriorityTaskWoken=%u xCopyPosition=%u
+61        xQueueGiveFromISR                   xQueue=%I pxHigherPriorityTaskWoken=%u
+51        xQueueReceiveFromISR                xQueue=%I pvBuffer=%p pxHigherPriorityTaskWoken=%u
+62        xQueueIsQueueEmptyFromISR           xQueue=%I
+63       xQueueIsQueueFullFromISR            xQueue=%I
+170       uxQueueMessagesWaitingFromISR       xQueue=%I
+171       xQueueAltGenericSend                xQueue=%I pvItemToQueue=%p xTicksToWait=%u xCopyPosition=%u
+172       xQueueAltGenericReceive             xQueue=%I pvBuffer=%p xTicksToWait=%u xJustPeeking=%u
+173       xQueueCRSendFromISR                 xQueue=%I pvItemToQueue=%p xCoRoutinePreviouslyWoken=%u
+174       xQueueCRReceiveFromISR              xQueue=%I pvBuffer=%p pxTaskWoken=%u
+175       xQueueCRSend                        xQueue=%I pvItemToQueue=%p xTicksToWait=%u
+176       xQueueCRReceive                     xQueue=%I pvBuffer=%p xTicksToWait=%u
+177       xQueueCreateMutex                   ucQueueType=%u
+178       xQueueCreateCountingSemaphore       uxMaxCount=%u uxInitialCount=%u
+179       xQueueGetMutexHolder                xSemaphore=%u
+180       xQueueTakeMutexRecursive            xMutex=%u xTicksToWait=%u
+181       xQueueGiveMutexRecursive            pxMutex=%u
+52       vQueueAddToRegistry                 xQueue=%I pcName=%u
+182       vQueueUnregisterQueue               xQueue=%I
+47       xQueueGenericCreate                 uxQueueLength=%u uxItemSize=%u ucQueueType=%u
+183       xQueueCreateSet                     uxEventQueueLength=%u
+184       xQueueAddToSet                      xQueueOrSemaphore=%u xQueueSet=%u
+185       xQueueRemoveFromSet                 xQueueOrSemaphore=%u xQueueSet=%u
+186       xQueueSelectFromSet                 xQueueSet=%u xTicksToWait=%u
+187       xQueueSelectFromSetFromISR          xQueueSet=%u
+188       xQueueGenericReset                  xQueue=%I xNewQueue=%u
+189       vListInitialise                     pxList=%u
+190       vListInitialiseItem                 pxItem=%u
+191       vListInsert                         pxList=%u pxNewListItem=%u
+192       vListInsertEnd                      pxList=%u pxNewListItem=%u
+193       uxListRemove                        pxItemToRemove=%u
+194       xEventGroupCreate                    
+195       xEventGroupWaitBits                 xEventGroup=%u uxBitsToWaitFor=%u xClearOnExit=%u xWaitForAllBits=%u xTicksToWait=%u
+196       xEventGroupClearBits                xEventGroup=%u uxBitsToClear=%u
+58       xEventGroupClearBitsFromISR         xEventGroup=%u uxBitsToSet=%u
+197       xEventGroupSetBits                  xEventGroup=%u uxBitsToSet=%u
+59       xEventGroupSetBitsFromISR           xEventGroup=%u uxBitsToSet=%u pxHigherPriorityTaskWoken=%u
+198       xEventGroupSync                     xEventGroup=%u uxBitsToSet=%u uxBitsToWaitFor=%u xTicksToWait=%u
+60       xEventGroupGetBitsFromISR           xEventGroup=%u
+199       vEventGroupDelete                   xEventGroup=%u
+200       uxEventGroupGetNumber               xEventGroup=%u

docs/api-guides/app_trace.rst

@@ -0,0 +1,365 @@
+Application Level Tracing library
+=================================
+
+Overview
+--------
+
+IDF provides useful feature for program behaviour analysis: application level tracing. It is implemented in the corresponding library and can be enabled via menuconfig. This feature allows to transfer arbitrary data between host and ESP32 via JTAG interface with small overhead on program execution.
+Developers can use this library to send application specific state of execution to the host and receive commands or other type of info in the opposite direction at runtime. The main use cases of this library are:
+
+1. System behaviour analysis. See `System Behaviour Analysis with SEGGER SystemView`_.
+2. Lightweight logging to the host. See `Logging to Host`_.
+3. Collecting application specific data. See `Application Specific Tracing`_.
+
+Tracing components when working over JTAG interface are shown in the figure below.
+
+.. figure:: ../_static/app_trace/overview.png
+    :align: center
+    :alt: Tracing Components when Working Over JTAG
+    :figclass: align-center
+
+    Tracing Components when Working Over JTAG
+
+.. note::
+
+    Currently only JTAG interface is supported as transport.
+
+Modes of operation
+------------------
+
+The library supports two modes of operation:
+
+ - **Post-mortem mode.** This is the default mode. The mode does not need interaction from the host side. In this mode tracing module does not check whether host has read all the data from *HW UP BUFFER* buffer and overwrites old data with the new ones. This mode is useful when only the latest trace data are interesting to the user, e.g. for analyzing program's behaviour just before the crash. Host can read the data later on upon user request, e.g. via special OpenOCD command in case of working via JTAG interface.
+ - **Streaming mode.** Tracing module enters this mode when host connects to ESP32. In this mode before writing new data to *HW UP BUFFER* tracing module checks that there is enough space in it and if necessary waits for the host to read data and free enough memory. Maximum waiting time is controled via timeout values passed by users to corresponding API routines. So when application tries to write data to trace buffer using finite value of the maximum waiting time it is possible situation that this data will be dropped. Especially this is true for tracing from time critical code (ISRs, OS scheduler code etc.) when infinite timeouts can lead to system malfunction. In order to avoid loss of such critical data developers can enable additional data buffering via menuconfig option ``CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX``. This macro specifies the size of data which can be buffered in above conditions. The option can also help to overcome situation when data transfer to the host is temporarily slowed down, e.g due to USB bus congestions etc. But it will not help when average bitrate of trace data stream exceeds HW interface capabilities.
+
+Config Options and Dependencies
+-------------------------------
+
+Using of this feature depends on two components:
+
+1. **Host side:** Application tracing is done over JTAG, so it needs OpenOCD to be set up and running on host machine. For instructions how to set it up, please, see :doc:`Debugging <../api-guides/openocd>` for details.
+2. **Target side:** Application tracing functionality can be enabled by ``CONFIG_ESP32_APPTRACE_ENABLE`` macro via menuconfig. This option enables the module and makes tracing API available for users. Actually there is menu which allows selecting destination for the trace data (HW interface for transport). So choosing one of the destinations automatically enables ``CONFIG_ESP32_APPTRACE_ENABLE`` option.
+
+.. note::
+
+    In order to achieve higher data rates and minimize number of dropped packets it is recommended to modify JTAG adapter working frequency in OpenOCD config file ``$IDF_PATH/docs/esp32.cfg``. Maximum tested stable speed on ESP-WROVER-KIT board is 26MHz, so for this board you need to have the following statement in your configuration file ``adapter_khz 26000`` instead of the default ``adapter_khz 200``. Actually maximum stable JTAG frequency can depend on the host system configuration. In general JTAG clock shuld not exceed APB clock / 4.
+
+There are two additional menuconfig options not mentioned above:
+
+1. ``CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH``. This option is necessary due to the nature of working over JTAG. In that mode trace data are exposed to the host in 16KB blocks. In post-mortem mode when one block is filled it is exposed to the host and the previous one becomes unavailable. In other words trace data are overwritten in 16KB granularity. On panic the latest data from the current input block are exposed to host and host can read them for post-analysis. It can happen that system panic occurs when there are very small amount of data which are not exposed to the host yet. In this case the previous 16KB of collected data will be lost and host will see the latest, but very small piece of the trace. It can be insufficient to diagnose the problem. This menuconfig option allows avoiding such situations. It controls the threshold for flushing data in case of panic. For example user can decide that it needs not less then 512 bytes of the recent trace data, so if there is less then 512 bytes of pending data at the moment of panic they will not be flushed and will not overwrite previous 16KB. The option is only meaningful in post-mortem mode and when working over JTAG.
+2. ``CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO``. The option is only meaningful in streaming mode and controls the maximum time tracing module will wait for the host to read the last data in case of panic.
+
+
+How to use this library
+-----------------------
+
+This library provides API for transferring arbitrary data between host and ESP32. When enabled in menuconfig target application tracing module is initialized automatically at the system startup, so all what the user needs to do is to call corresponding API to send, receive or flush the data.
+
+Application Specific Tracing
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In general user should decide what type of data should be transferred in every direction and how these data must be interpreted (processed). The following steps must be performed to transfer data between target and host:
+
+1. On target side user should implement algorithms for writing trace data to the host. Piece of code below shows an example how to do this.
+
+.. code-block:: c
+
+    #include "esp_app_trace.h"
+    ...
+    char buf[] = "Hello World!";
+    esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, buf, strlen(buf), ESP_APPTRACE_TMO_INFINITE);
+    if (res != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to write data to host!");
+        return res;
+    }
+
+``esp_apptrace_write()`` function uses memcpy to copy user data to the internal buffer. In some cases it can be more optimal to use ``esp_apptrace_buffer_get()`` and ``esp_apptrace_buffer_put()`` functions. They allow developers to allocate buffer and fill it themselves. The following piece of code shows how to do this.
+
+.. code-block:: c
+
+    #include "esp_app_trace.h"
+    ...
+    int number = 10;
+    char *ptr = (char *)esp_apptrace_buffer_get(32, 100/*tmo in us*/);
+    if (ptr == NULL) {
+        ESP_LOGE("Failed to get buffer!");
+        return ESP_FAIL;
+    }
+    sprintf(ptr, "Here is the number %d", number);
+    esp_err_t res = esp_apptrace_buffer_put(ptr, 100/*tmo in us*/);
+    if (res != ESP_OK) {
+        /* in case of error host tracing tool (e.g. OpenOCD) will report incomplete user buffer */
+        ESP_LOGE("Failed to put buffer!");
+        return res;
+    }
+
+Also according to his needs user may want to receive data from the host. Piece of code below shows an example how to do this.
+
+.. code-block:: c
+
+    #include "esp_app_trace.h"
+    ...
+    char buf[32];
+    size_t sz = sizeof(buf);
+    /* check for incoming data and read them if any */
+    esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_TRAX, buf, &sz, 0/*do not wait*/);
+    if (res != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to read data from host!");
+        return res;
+    }
+    if (sz > 0) {
+        /* we have data, process them */
+        ...
+    }
+
+2. The next step is to build the program image and download it to the target as described in :doc:`Build and Flash <../get-started/make-project>`.
+3. Run OpenOCD (see :doc:`Debugging <../api-guides/openocd>`).
+4. Connect to OpenOCD telnet server. On Linux it can be done using the following command in terminal ``telnet <oocd_host> 4444``. If telnet session is opened on the same machine which runs OpenOCD you can use ``localhost`` as ``<oocd_host>`` in the command above.
+5. Start trace data collection using special OpenOCD command. This command will transfer tracing data and redirect them to specified file or socket (currently only files are supported as trace data destination). For description of the corresponding commands see `OpenOCD Application Level Tracing Commands`_.
+6. The final step is to process received data. Since format of data is defined by user the processing stage is out of the scope of this document. Good starting points for data processor are python scripts in ``$IDF_PATH/tools/esp_app_trace``: ``apptrace_proc.py`` (used for feature tests) and ``logtrace_proc.py`` (see more details in section `Logging to Host`_).
+
+OpenOCD Application Level Tracing Commands
+""""""""""""""""""""""""""""""""""""""""""
+
+*HW UP BUFFER* is shared between user data blocks and filling of the allocated memory is performed on behalf of the API caller (in task or ISR context). In multithreading environment it can happen that task/ISR which fills the buffer is preempted by another high prio task/ISR. So it is possible situation that user data preparation process is not completed at the moment when that chunk is read by the host. To handle such conditions tracing module prepends all user data chunks with header which contains allocated user buffer size (2 bytes) and length of actually written data (2 bytes). So total length of the header is 4 bytes. OpenOCD command which reads trace data reports error when it reads incomplete user data chunk, but in any case it puts contents of the whole user chunk (including unfilled area) to output file.
+Below is the description of available OpenOCD application tracing commands.
+
+.. note::
+
+    Currently OpenOCD does not provide commands to send arbitrary user data to the target.
+
+Command usage:
+
+``esp108 apptrace [start <options>] | [stop] | [status] | [dump <cores_num> <outfile>]``
+
+Sub-commands:
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Sub-command
+      - Description
+    * - start
+      - Start tracing (continuous streaming).
+    * - stop
+      - Stop tracing.
+    * - status
+      - Get tracing status.
+    * - dump
+      - Dump all data from *HW UP BUFFER* (post-mortem dump).
+
+Start command syntax:
+
+  ``start <outfile1> [outfile2] [poll_period [trace_size [stop_tmo [wait4halt [skip_size]]]]``
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Argument
+      - Description
+    * - outfile1
+      - Path to file to save data from PRO CPU. This argument should have the following format: ``file://path/to/file``.
+    * - outfile2
+      - Path to file to save data from APP CPU. This argument should have the following format: ``file://path/to/file``.
+    * - poll_period
+      - Data polling period (in ms). If greater then 0 then command runs in non-blocking mode. By default 1 ms.
+    * - trace_size
+      - Maximum size of data to collect (in bytes). Tracing is stopped after specified amount of data is received. By default -1 (trace size stop trigger is disabled).
+    * - stop_tmo
+      - Idle timeout (in sec). Tracing is stopped if there is no data for specified period of time. By default -1 (disable this stop trigger).
+    * - wait4halt
+      - If 0 start tracing immediately, otherwise command waits for the target to be halted (after reset, by breakpoint etc.) and then automatically resumes it and starts tracing. By default 0.
+    * - skip_size
+      - Number of bytes to skip at the start. By default 0.
+
+.. note::
+
+    If ``poll_period`` is 0 OpenOCD telnet command line will not be avalable until tracing is stopped. You must stop it manually by resetting the board or pressing CTRL+C in OpenOCD window (not one with the telnet session).
+
+Logging to Host
+^^^^^^^^^^^^^^^
+
+IDF implements useful feature: logging to host via application level tracing library. This is a kind of semihosting when all ESP_LOGx calls sends strings to be printed to the host instead of UART. This can be useful because "printing to host" eliminates some steps performed when logging to UART. The most part of work is done on the host.
+By default IDF's logging library uses vprintf-like function to write formatted output to dedicated UART. In general it invloves the following steps:
+
+1. Format string is parsed to obtain type of each argument.
+2. According to its type every argument is converted to string representation.
+3. Format string combined with converted arguments is sent to UART.
+
+Though implementation of vprintf-like function can be optimised to a certain level, all steps above have to be peformed in any case and every step takes some time (especially item 3). So it is frequent situation when addition of extra logging to the program to diagnose some problem changes its behaviour and problem dissapears or in the worst cases program can not work normally at all and ends up with an error or even hangs.
+Possible ways to overcome this problem are to use higher UART bitrates (or another faster interface) and/or move string formatting procedure to the host.
+Application level tracing feature can be used to transfer log information to host using ``esp_apptrace_vprintf`` function. This function does not perform full parsing of the format string and arguments, instead it just calculates number of arguments passed and sends them along with the format string address to the host. On the host log data are processed and printed out by a special Python script.
+
+Limitations
+"""""""""""
+
+Curent implmentation of logging over JTAG has several limitations:
+
+1. Tracing from ``ESP_EARLY_LOGx`` macros is not supported.
+2. No support for printf arguments which size exceeds 4 bytes (e.g. ``double`` and ``uint64_t``).
+3. Only strings from .rodata section are supported as format strings and arguments.
+4. Maximum number of printf arguments is 256.
+
+How To Use It
+"""""""""""""
+
+In order to use logging via trace module user needs to perform the following steps:
+
+1. On target side special vprintf-like function needs to be installed. As it was mentioned earlier this function is ``esp_apptrace_vprintf``. It sends log data to the host. Example code is shown below.
+
+.. code-block:: c
+
+    #include "esp_app_trace.h"
+    ...
+    void app_main()
+    {
+        // set log vprintf handler
+        esp_log_set_vprintf(esp_apptrace_vprintf);
+        ...
+        // user code using ESP_LOGx starts here
+        // all data passed to ESP_LOGx are sent to host
+        ...
+        // restore log vprintf handler
+        esp_log_set_vprintf(vprintf);
+        // flush last data to host
+        esp_apptrace_flush(ESP_APPTRACE_DEST_TRAX, 100000 /*tmo in us*/);
+        ESP_LOGI(TAG, "Tracing is finished."); // this will be printed out to UART
+        while (1);
+    }
+
+2. Follow instructions in items 2-5 in `Application Specific Tracing`_.
+3. To print out collected log records run the following command in terminal: ``$IDF_PATH/tools/esp_app_trace/logtrace_proc.py /path/to/trace/file /path/to/program/elf/file``.
+
+Log Trace Processor Command Options
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Command usage:
+
+``logtrace_proc.py [-h] [--no-errors] <trace_file> <elf_file>``
+
+Positional arguments:
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Argument
+      - Description
+    * - trace_file
+      - Path to log trace file
+    * - elf_file
+      - Path to program ELF file
+
+Optional arguments:
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Argument
+      - Description
+    * - -h, --help
+      - show this help message and exit
+    * - --no-errors, -n
+      - Do not print errors
+
+System Behaviour Analysis with SEGGER SystemView
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Another useful IDF feature built on top of application tracing library is the system level tracing which produces traces compatible with SEGGER SystemView tool (see `SystemView <https://www.segger.com/systemview.html>`_). SEGGER SystemView is a real-time recording and visualization tool that allows to analyze runtime behavior of an application.
+
+.. note::
+
+    Currently IDF-based application is able to generate SystemView compatible traces, but tracing process can not be controlled using that tool.
+
+How To Use It
+"""""""""""""
+
+Support for this feature is enabled by ``CONFIG_SYSVIEW_ENABLE`` menuconfig option. It also enables a bunch of options related to that type of tracing:
+
+1. ``CONFIG_SYSVIEW_TS_SOURCE`` selects the source of timestamps for SystemView events. In single core mode timestamps are generated using ESP32 internal cycle counter running at maximum 240 Mhz (~4ns granularity). In dual-core mode external timer working at 40Mhz is used, so timestamp granularity is 25 ns.
+2. ``CONFIG_SYSVIEW_EVT_XXX`` enables or disables particular SystemView event.
+
+IDF has all the code required to produce SystemView compatible traces, so user can just configure necessary project options (see above), build, download the image to target and use OpenOCD to collect data as described in the previous sections.
+
+OpenOCD SystemView Tracing Command Options
+"""""""""""""""""""""""""""""""""""""""""""
+
+Command usage:
+
+``esp108 sysview [start <options>] | [stop] | [status]``
+
+Sub-commands:
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Sub-command
+      - Description
+    * - start
+      - Start tracing (continuous streaming).
+    * - stop
+      - Stop tracing.
+    * - status
+      - Get tracing status.
+
+Start command syntax:
+
+  ``start <outfile1> [outfile2] [poll_period [trace_size [stop_tmo]]]``
+
+  .. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Argument
+      - Description
+    * - outfile1
+      - Path to file to save data from PRO CPU. This argument should have the following format: ``file://path/to/file``.
+    * - outfile2
+      - Path to file to save data from APP CPU. This argument should have the following format: ``file://path/to/file``.
+    * - poll_period
+      - Data polling period (in ms). If greater then 0 then command runs in non-blocking mode. By default 1 ms.
+    * - trace_size
+      - Maximum size of data to collect (in bytes). Tracing is stopped after specified amount of data is received. By default -1 (trace size stop trigger is disabled).
+    * - stop_tmo
+      - Idle timeout (in sec). Tracing is stopped if there is no data for specified period of time. By default -1 (disable this stop trigger).
+
+.. note::
+
+    If ``poll_period`` is 0 OpenOCD telnet command line will not be avalable until tracing is stopped. You must stop it manually by resetting the board or pressing CTRL+C in OpenOCD window (not one with the telnet session).
+
+Data Visualization
+""""""""""""""""""
+
+After trace data are collected user can use special tool to visuailize the results and inspect behaviour of the program. Unfortunately SystemView does not support tracing from multiple cores. So when tracing from ESP32 working in dual-core mode two files are generated: one for PRO CPU and another one for APP CPU.
+User can load every file into separate instance of the tool. It is uneasy and awkward to analyze data for every core in separate instance of the tool.
+Fortunately there is Eclipse plugin called *Impulse* which can load several trace files and makes its possible to inspect events from both cores in one view. Also this plugin has no limitation of 1000000 events as compared to free version of SystemView.
+
+Good instruction on how to install, configure and visualize data in Impulse from one core can be found `here <https://mcuoneclipse.com/2016/07/31/impulse-segger-systemview-in-eclipse/>`_.
+
+.. note::
+
+    IDF uses its own mapping for SystemView FreeRTOS events IDs, so user needs to replace original file with mapping ``$SYSVIEW_INSTALL_DIR/Description/SYSVIEW_FreeRTOS.txt`` with ``$IDF_PATH/docs/api-guides/SYSVIEW_FreeRTOS.txt``.
+    Also contents of that IDF specific file should be used when configuring SystemView serializer using above link.
+
+Configure Impulse for Dual Core Traces
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+After installing Impulse and ensuring that it can succussefully load trace files for each core in separate tabs user can add special Multi Adapter port and load both files into one view. To do this user needs to do the following in Eclipse:
+
+1. Open 'Signal Ports' view. Go to Windows->Show View->Other menu. Find 'Signal Ports' view in Impulse folder and double-click on it.
+2. In 'Signal Ports' view right-click on 'Ports' and select 'Add ...'->New Multi Adapter Port
+3. In open dialog Press 'Add' button and select 'New Pipe/File'.
+4. In open dialog select 'SystemView Serializer' as Serializer and set path to PRO CPU trace file. Press OK.
+5. Repeat steps 3-4 for APP CPU trace file.
+6. Double-click on created port. View for this port should open.
+7. Click Start/Stop Streaming button. Data should be loaded.
+8. Use 'Zoom Out', 'Zoom In' and 'Zoom Fit' button to inspect data.
+9. For settings measurement cursors and other features please see `Impulse documentation <http://toem.de/index.php/projects/impulse>`_).
+
+.. note::
+
+    If you have problems with visualization (no data are shown or strange behaviour of zoom action is observed) you can try to delete current signal hierarchy and double click on necessary file or port. Eclipse will ask you to create new signal hierarchy.

docs/api-guides/index.rst

@@ -14,4 +14,4 @@ API Guides
    Deep Sleep Wake Stubs <deep-sleep-stub>
    ULP Coprocessor <ulp>
    Unit Testing <unit-tests>
-
+   Application Level Tracing <app_trace>

docs/api-reference/system/app_trace.rst

@@ -0,0 +1,44 @@
+Application Level Tracing
+=========================
+
+Overview
+--------
+
+IDF provides useful feature for program behaviour analysis: application level tracing. It is implemented in the corresponding library and can be enabled via menuconfig. This feature allows to transfer arbitrary data between host and ESP32 via JTAG interface with small overhead on program execution.
+Developers can use this library to send application specific state of execution to the host and receive commands or other type of info in the opposite direction at runtime. The main use cases of this library are:
+
+1. System behaviour analysis.
+2. Lightweight logging to the host.
+3. Collecting application specific data.
+
+API Reference
+-------------
+
+Header Files
+^^^^^^^^^^^^
+
+  * :component_file:`app_trace/include/esp_app_trace.h`
+
+Macros
+^^^^^^
+
+.. doxygendefine:: ESP_APPTRACE_TMO_INFINITE
+
+Enumerations
+^^^^^^^^^^^^
+
+.. doxygenenum:: esp_apptrace_dest_t
+
+
+Functions
+^^^^^^^^^
+
+.. doxygenfunction:: esp_apptrace_init
+.. doxygenfunction:: esp_apptrace_buffer_get
+.. doxygenfunction:: esp_apptrace_buffer_put
+.. doxygenfunction:: esp_apptrace_write
+.. doxygenfunction:: esp_apptrace_vprintf_to
+.. doxygenfunction:: esp_apptrace_vprintf
+.. doxygenfunction:: esp_apptrace_read
+.. doxygenfunction:: esp_apptrace_flush
+.. doxygenfunction:: esp_apptrace_flush_nolock

docs/api-reference/system/index.rst

@@ -11,6 +11,7 @@ System API
    Deep Sleep <deep_sleep>
    Logging <log>
    Base MAC address <base_mac_address>
+   Application Level Tracing <app_trace>
 
 
 Example code for this API section is provided in :example:`system` directory of ESP-IDF examples.

examples/get-started/blink/main/blink.c

@@ -40,5 +40,5 @@ void blink_task(void *pvParameter)
 
 void app_main()
 {
-    xTaskCreate(&blink_task, "blink_task", 512, NULL, 5, NULL);
+    xTaskCreate(&blink_task, "blink_task", 2048, NULL, 5, NULL);
 }

tools/unit-test-app/sdkconfig

@@ -87,6 +87,17 @@ CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
 #
 # Component config
 #
+
+#
+# Application Level Tracing
+#
+# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set
+CONFIG_ESP32_APPTRACE_DEST_NONE=y
+# CONFIG_ESP32_APPTRACE_ENABLE is not set
+
+#
+# FreeRTOS SystemView Tracing
+#
 # CONFIG_AWS_IOT_SDK is not set
 # CONFIG_BT_ENABLED is not set
 CONFIG_BT_RESERVE_DRAM=0
@@ -107,10 +118,6 @@ CONFIG_TRACEMEM_RESERVE_DRAM=0x0
 # CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set
 CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y
 # CONFIG_ESP32_ENABLE_COREDUMP is not set
-# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set
-# CONFIG_ESP32_APPTRACE_DEST_UART is not set
-CONFIG_ESP32_APPTRACE_DEST_NONE=y
-# CONFIG_ESP32_APPTRACE_ENABLE is not set
 # CONFIG_TWO_UNIVERSAL_MAC_ADDRESS is not set
 CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS=y
 CONFIG_NUMBER_OF_UNIVERSAL_MAC_ADDRESS=4
@@ -206,7 +213,7 @@ CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set
 CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y
-# CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK is not set
+CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y
 CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=3
 CONFIG_FREERTOS_ASSERT_FAIL_ABORT=y
 # CONFIG_FREERTOS_ASSERT_FAIL_PRINT_CONTINUE is not set